Contract 0xdef1c0ded9bec7f1a1670819833240f027b25eff 10

 

Contract Overview

Balance:
3.52291718649684909 BNB

BNB Value:
$1,710.41 (@ $485.51/BNB)

Token:
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xa36999a90c52691c9138f80e1991b161d396af375d613382c08614afbcdca3e2Sell To Pancake ...119306392021-10-20 7:39:026 secs ago0xa8b7e06ce6eabd5eb8593a9afd7018e56991bdd3 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0.3 BNB0.00117902
0x9804620405132a6fb87c3927b8c7b93dcfcf3d9b9bcd32ce701c407a2598a604Sell To Pancake ...119306382021-10-20 7:38:599 secs ago0x64b00809dc07da74e1912b25fc3143c8ea9440f9 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0.00001 BNB0.000779694
0x356411340ef241ba8a6ecd5d7598b3f0d8cb32611f14600c293e5e5753e3e6cf0x415565b0119306332021-10-20 7:38:4424 secs ago0xf6950781f62a5085434dfc261a518ad27cc2f834 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0.011017 BNB0.006439085
0x46e1fb56c2dcb5c902b1051d6ce3f25fd269c29ba5e3a3bdcd970fd202c31372Sell To Pancake ...119306322021-10-20 7:38:4127 secs ago0x5d59671889649562a8275154c36482c5d3bb90cf IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0.62 BNB0.000588185
0xb70c32fb9bde23829aa71503b51185edb120b2a0815dc6a6fb621bba661be65dSell To Pancake ...119306302021-10-20 7:38:3533 secs ago0x581759b2d91d34eab0ada4f87638afd252d2b389 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0.00001 BNB0.000779694
0x545660d55932945a90f3fa614bbd5791c3dff7bb60d1e261c7424e9e1889c4490x415565b0119306292021-10-20 7:38:3236 secs ago0x09cedfc8ec093ab184582d112a06964503212842 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff2 BNB0.00278267
0xcf0e334ff90f5ec5bec1760edeff58bb1277cdf3e5171e454f5f18c33b5d01c5Sell To Pancake ...119306272021-10-20 7:38:2642 secs ago0x139a1b44d26bcf9352a517edb27414e68a5aec38 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0 BNB0.000604698
0x589ddcd98b390df933fca68fb8df5097ac4915f855b0e0d42c1f883a21c141400x415565b0119306262021-10-20 7:38:2345 secs ago0xc617f62f56aafc88b62bd57201b5744929adf8bc IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0 BNB0.001879422
0x728e510e04ef899ddfb3d6dd8f9dcf94551cc64ab82fa72d053587b358cd07bcSell To Pancake ...119306112021-10-20 7:37:381 min ago0x76d0c38b8c737feae57a6d4af8e89e59cc88a4d7 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0 BNB0.0017743
0x7dea9e9efd4a0b2b1bce5292661854f3874ce45b16a20ecd7b70c0815dfbac900x415565b0119306102021-10-20 7:37:351 min ago0x3fca66b8ebec0d878751a96016e85f31a6847c53 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0 BNB0.002905735
0xa48d21ece2dd2c54db4eaac379369b39bec2ecd3b649f902aecf1871b9b0b6100x415565b0119306022021-10-20 7:37:111 min ago0x5000d53cbbd40376a2ef79d0dbe9a0c533da10b2 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0.5 BNB0.003205855
0xe8b2667410d5f80e5386900779525d422b1fd19f3fa38c1425a759117b1263950x415565b0119306012021-10-20 7:37:082 mins ago0xb47f8d9795df1bc9e5cf7cf4fb7abae3aeed9a58 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0.32 BNB0.00224572
0xdf553b0b803fa7b6e8f3ecef9f475636fc2c947e4d7b0e79f71271cb391a2c70Sell To Pancake ...119306012021-10-20 7:37:082 mins ago0xfceebe5c5aadcd068e78c2052feeeddff69c3529 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0 BNB0.000539275
0x1cbf50e4543e558e0ed29288004535dca382299a2ec9ca539e2f00b6049faf77Sell To Pancake ...119305892021-10-20 7:36:322 mins ago0x62a68b0908af577a92ab3f9b2a98d03d06ecd6c2 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0.00001 BNB0.000779694
0x096baa952b89ecb249f2c1a47356082ee1693aa0940e7f66b489e1f0fd2e8e9aSell To Pancake ...119305872021-10-20 7:36:262 mins ago0xb7774735f68a751984b5fff8f0954698be2120d9 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0 BNB0.00078625
0x20726f43700cdc4f263752f7049dbc4909a4f2ce81026cace3c44be8c5cf251eSell To Pancake ...119305872021-10-20 7:36:262 mins ago0xb7774735f68a751984b5fff8f0954698be2120d9 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0 BNB0.00078625
0x6869c355a91a6e17e83f47fd46c7b8645054e2a6968f33eebc478bdf9a1937940x415565b0119305852021-10-20 7:36:202 mins ago0x9abf818ef34eff2c1f6efc111de1a8f61c21883b IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0 BNB0.002435475
0x1f3c44ec8974a3efe5423c0dc1f7a0136d06d68d08db28fb8c5af597d7eb17d5Sell To Pancake ...119305852021-10-20 7:36:202 mins ago0x08fc4eefa2e436af0db3b112a3bc33c31e70d7ce IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0 BNB0.000651066
0x89ca21605c000007db9c9320426d762cb6f409e9375e75959eacd0269fc2792aSell To Pancake ...119305802021-10-20 7:36:053 mins ago0x51f0d503371b6c893803f1d42e9058af8b66cd5e IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0 BNB0.000612492
0xea2c4afbbc03bd9f6e42821c60d1f7afce81504f04fa4afd22dea1f12f7691f2Sell To Pancake ...119305792021-10-20 7:36:023 mins ago0xce4696d60b71b986af7ab8eb3afb51ccc0f828fc IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0.000005 BNB0.000528665
0x68ba05797741309608c411f61be74d5933de00adc9a5ce8bdf69fcc7ca0cf166Sell To Pancake ...119305712021-10-20 7:35:383 mins ago0x8beeb8b46a8147806b3d85198320da8fa7bbe2f2 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0.0022 BNB0.000823325
0x02919815768321816d33b54dad1b02127c2cb54e145d69289ccc3aa69385ae9cSell To Pancake ...119305712021-10-20 7:35:383 mins ago0x08fc4eefa2e436af0db3b112a3bc33c31e70d7ce IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0.5 BNB0.000588185
0x6ed7f3ca943c97dc5a75edf07c4a415df1718be6f62942f169ce1cd10f952bb30x415565b0119305692021-10-20 7:35:323 mins ago0xc617f62f56aafc88b62bd57201b5744929adf8bc IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0.22 BNB0.00131397
0xfa95c8c7224792fa7f08dfecd96bd2562a7b18bc16020c2f3955195201fb161eSell To Pancake ...119305612021-10-20 7:35:084 mins ago0x36b471ccba4b1926f0fa94c172e74aade5790484 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff1 BNB0.000573725
0xcb738f65e46a38b8cbd093144b938d105072679e98eb352d78888cf5d139a0afSell To Pancake ...119305552021-10-20 7:34:504 mins ago0x624a662ee4cb8c1b92a6c7adc240a054f98b0e47 IN  0xdef1c0ded9bec7f1a1670819833240f027b25eff0 BNB0.000667675
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x04739dd904ec6158bd4cbcfbf2ad9703c2046077d9c5eb22cb38fef58682985b119306202021-10-20 7:38:051 min ago 0xdef1c0ded9bec7f1a1670819833240f027b25eff 0xdb6f1920a889355780af7570773609bd8cb1f4980.1486875 BNB
0x04739dd904ec6158bd4cbcfbf2ad9703c2046077d9c5eb22cb38fef58682985b119306202021-10-20 7:38:051 min ago 0xc590175e458b83680867afd273527ff58f74c02b 0xdef1c0ded9bec7f1a1670819833240f027b25eff0.1486875 BNB
0xd24d5426dd0883cf60d036dd5fe9df73f9eba761abe2546b4fa77dd09f12e68d119306192021-10-20 7:38:021 min ago 0xdef1c0ded9bec7f1a1670819833240f027b25eff 0xc590175e458b83680867afd273527ff58f74c02b0.073901406532947638 BNB
0xd24d5426dd0883cf60d036dd5fe9df73f9eba761abe2546b4fa77dd09f12e68d119306192021-10-20 7:38:021 min ago Binance: WBNB Token 0xdef1c0ded9bec7f1a1670819833240f027b25eff0.073901406532947638 BNB
0x3cce6755f245c7171af0c268830c54d6c3fd3a77aa9067bf6cfc7f92e22cd8ca119306192021-10-20 7:38:021 min ago 0xdef1c0ded9bec7f1a1670819833240f027b25eff 0xdb6f1920a889355780af7570773609bd8cb1f4980.5 BNB
0x3cce6755f245c7171af0c268830c54d6c3fd3a77aa9067bf6cfc7f92e22cd8ca119306192021-10-20 7:38:021 min ago 0xc590175e458b83680867afd273527ff58f74c02b 0xdef1c0ded9bec7f1a1670819833240f027b25eff0.5 BNB
0x5ce81fcd864d360094afbf918c86b25b78931d75902bd6a4fd2a066fc29b1ef5119306182021-10-20 7:37:591 min ago 0xdef1c0ded9bec7f1a1670819833240f027b25eff 0xc590175e458b83680867afd273527ff58f74c02b0.072135719938235699 BNB
0x5ce81fcd864d360094afbf918c86b25b78931d75902bd6a4fd2a066fc29b1ef5119306182021-10-20 7:37:591 min ago Binance: WBNB Token 0xdef1c0ded9bec7f1a1670819833240f027b25eff0.072135719938235699 BNB
0xd8504411c6a3192040cea293f7ce110d72073351351f7f909e7b5e866b71d5e6119306162021-10-20 7:37:531 min ago 0xdef1c0ded9bec7f1a1670819833240f027b25eff 0xc590175e458b83680867afd273527ff58f74c02b0.006913213750740847 BNB
0xd8504411c6a3192040cea293f7ce110d72073351351f7f909e7b5e866b71d5e6119306162021-10-20 7:37:531 min ago Binance: WBNB Token 0xdef1c0ded9bec7f1a1670819833240f027b25eff0.006913213750740847 BNB
0x519a55ea078522ea0f010bc4904487769f9bd11aa439f09142ef0618b7666f8f119306142021-10-20 7:37:471 min ago 0xdef1c0ded9bec7f1a1670819833240f027b25eff 0xc590175e458b83680867afd273527ff58f74c02b0.388702554624024834 BNB
0x519a55ea078522ea0f010bc4904487769f9bd11aa439f09142ef0618b7666f8f119306142021-10-20 7:37:471 min ago Binance: WBNB Token 0xdef1c0ded9bec7f1a1670819833240f027b25eff0.388702554624024834 BNB
0x8c9e59b4eb7bd313ac17383155095faea09e5e5c9d966cb90f0ea0353ed2d01c119306112021-10-20 7:37:381 min ago 0xdef1c0ded9bec7f1a1670819833240f027b25eff 0xdb6f1920a889355780af7570773609bd8cb1f4980.019825 BNB
0x8c9e59b4eb7bd313ac17383155095faea09e5e5c9d966cb90f0ea0353ed2d01c119306112021-10-20 7:37:381 min ago 0xc590175e458b83680867afd273527ff58f74c02b 0xdef1c0ded9bec7f1a1670819833240f027b25eff0.019825 BNB
0x67145c1f2a8bdbe0a6039928ba7355f5f49a7673ec4bb39ab97b3c0902c882f8119306102021-10-20 7:37:351 min ago 0xdef1c0ded9bec7f1a1670819833240f027b25eff 0xc590175e458b83680867afd273527ff58f74c02b0.280351065019104776 BNB
0x67145c1f2a8bdbe0a6039928ba7355f5f49a7673ec4bb39ab97b3c0902c882f8119306102021-10-20 7:37:351 min ago Binance: WBNB Token 0xdef1c0ded9bec7f1a1670819833240f027b25eff0.280351065019104776 BNB
0x86fef5e4560a621d3bf656fb1188cc73e2bfd6d4dd8982295a2564067ee9f0f8119306082021-10-20 7:37:291 min ago 0xdef1c0ded9bec7f1a1670819833240f027b25eff 0xc590175e458b83680867afd273527ff58f74c02b0.287455651058055861 BNB
0x86fef5e4560a621d3bf656fb1188cc73e2bfd6d4dd8982295a2564067ee9f0f8119306082021-10-20 7:37:291 min ago Binance: WBNB Token 0xdef1c0ded9bec7f1a1670819833240f027b25eff0.287455651058055861 BNB
0x57e83014e8f245ebabc4b4462137042641f222460f4acc78cf66bbfcb5afb755119306072021-10-20 7:37:261 min ago 0xdef1c0ded9bec7f1a1670819833240f027b25eff 0xc590175e458b83680867afd273527ff58f74c02b0.004268223008875473 BNB
0x57e83014e8f245ebabc4b4462137042641f222460f4acc78cf66bbfcb5afb755119306072021-10-20 7:37:261 min ago Binance: WBNB Token 0xdef1c0ded9bec7f1a1670819833240f027b25eff0.004268223008875473 BNB
0xa75f1c41971e70706c3233aeaf80e34540cba35995bfcae8195e860a457b9d9d119306072021-10-20 7:37:261 min ago 0xdef1c0ded9bec7f1a1670819833240f027b25eff Binance: WBNB Token1.3481 BNB
0xa75f1c41971e70706c3233aeaf80e34540cba35995bfcae8195e860a457b9d9d119306072021-10-20 7:37:261 min ago 0xc590175e458b83680867afd273527ff58f74c02b 0xdef1c0ded9bec7f1a1670819833240f027b25eff1.3481 BNB
0x98107b282c3226f3cbd8c5863f993e95215e67c8afdecc1ba1f2a3b95e33c772119306072021-10-20 7:37:261 min ago 0xdef1c0ded9bec7f1a1670819833240f027b25eff 0xdb6f1920a889355780af7570773609bd8cb1f4980.99125 BNB
0x98107b282c3226f3cbd8c5863f993e95215e67c8afdecc1ba1f2a3b95e33c772119306072021-10-20 7:37:261 min ago 0xc590175e458b83680867afd273527ff58f74c02b 0xdef1c0ded9bec7f1a1670819833240f027b25eff0.99125 BNB
0x3d7eb72e28b446cdc6bb37b660110f481322cbf0585750b23c1817266e188f45119306062021-10-20 7:37:231 min ago 0xdef1c0ded9bec7f1a1670819833240f027b25eff 0xc590175e458b83680867afd273527ff58f74c02b0.02670334469923011 BNB
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
ZeroEx

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 1000000 runs

Other Settings:
istanbul EvmVersion, Apache-2.0 license
File 1 of 10 : ZeroEx.sol
// SPDX-License-Identifier: Apache-2.0
/*

  Copyright 2020 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

pragma solidity ^0.6.5;
pragma experimental ABIEncoderV2;

import "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol";
import "./migrations/LibBootstrap.sol";
import "./features/BootstrapFeature.sol";
import "./storage/LibProxyStorage.sol";
import "./errors/LibProxyRichErrors.sol";


/// @dev An extensible proxy contract that serves as a universal entry point for
///      interacting with the 0x protocol.
contract ZeroEx {
    // solhint-disable separate-by-one-line-in-contract,indent,var-name-mixedcase
    using LibBytesV06 for bytes;

    /// @dev Construct this contract and register the `BootstrapFeature` feature.
    ///      After constructing this contract, `bootstrap()` should be called
    ///      by `bootstrap()` to seed the initial feature set.
    /// @param bootstrapper Who can call `bootstrap()`.
    constructor(address bootstrapper) public {
        // Temporarily create and register the bootstrap feature.
        // It will deregister itself after `bootstrap()` has been called.
        BootstrapFeature bootstrap = new BootstrapFeature(bootstrapper);
        LibProxyStorage.getStorage().impls[bootstrap.bootstrap.selector] =
            address(bootstrap);
    }

    // solhint-disable state-visibility

    /// @dev Forwards calls to the appropriate implementation contract.
    fallback() external payable {
        bytes4 selector = msg.data.readBytes4(0);
        address impl = getFunctionImplementation(selector);
        if (impl == address(0)) {
            _revertWithData(LibProxyRichErrors.NotImplementedError(selector));
        }

        (bool success, bytes memory resultData) = impl.delegatecall(msg.data);
        if (!success) {
            _revertWithData(resultData);
        }
        _returnWithData(resultData);
    }

    /// @dev Fallback for just receiving ether.
    receive() external payable {}

    // solhint-enable state-visibility

    /// @dev Get the implementation contract of a registered function.
    /// @param selector The function selector.
    /// @return impl The implementation contract address.
    function getFunctionImplementation(bytes4 selector)
        public
        view
        returns (address impl)
    {
        return LibProxyStorage.getStorage().impls[selector];
    }

    /// @dev Revert with arbitrary bytes.
    /// @param data Revert data.
    function _revertWithData(bytes memory data) private pure {
        assembly { revert(add(data, 32), mload(data)) }
    }

    /// @dev Return with arbitrary bytes.
    /// @param data Return data.
    function _returnWithData(bytes memory data) private pure {
        assembly { return(add(data, 32), mload(data)) }
    }
}

File 2 of 10 : LibBytesV06.sol
// SPDX-License-Identifier: Apache-2.0
/*

  Copyright 2020 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

pragma solidity ^0.6.5;

import "./errors/LibBytesRichErrorsV06.sol";
import "./errors/LibRichErrorsV06.sol";


library LibBytesV06 {

    using LibBytesV06 for bytes;

    /// @dev Gets the memory address for a byte array.
    /// @param input Byte array to lookup.
    /// @return memoryAddress Memory address of byte array. This
    ///         points to the header of the byte array which contains
    ///         the length.
    function rawAddress(bytes memory input)
        internal
        pure
        returns (uint256 memoryAddress)
    {
        assembly {
            memoryAddress := input
        }
        return memoryAddress;
    }

    /// @dev Gets the memory address for the contents of a byte array.
    /// @param input Byte array to lookup.
    /// @return memoryAddress Memory address of the contents of the byte array.
    function contentAddress(bytes memory input)
        internal
        pure
        returns (uint256 memoryAddress)
    {
        assembly {
            memoryAddress := add(input, 32)
        }
        return memoryAddress;
    }

    /// @dev Copies `length` bytes from memory location `source` to `dest`.
    /// @param dest memory address to copy bytes to.
    /// @param source memory address to copy bytes from.
    /// @param length number of bytes to copy.
    function memCopy(
        uint256 dest,
        uint256 source,
        uint256 length
    )
        internal
        pure
    {
        if (length < 32) {
            // Handle a partial word by reading destination and masking
            // off the bits we are interested in.
            // This correctly handles overlap, zero lengths and source == dest
            assembly {
                let mask := sub(exp(256, sub(32, length)), 1)
                let s := and(mload(source), not(mask))
                let d := and(mload(dest), mask)
                mstore(dest, or(s, d))
            }
        } else {
            // Skip the O(length) loop when source == dest.
            if (source == dest) {
                return;
            }

            // For large copies we copy whole words at a time. The final
            // word is aligned to the end of the range (instead of after the
            // previous) to handle partial words. So a copy will look like this:
            //
            //  ####
            //      ####
            //          ####
            //            ####
            //
            // We handle overlap in the source and destination range by
            // changing the copying direction. This prevents us from
            // overwriting parts of source that we still need to copy.
            //
            // This correctly handles source == dest
            //
            if (source > dest) {
                assembly {
                    // We subtract 32 from `sEnd` and `dEnd` because it
                    // is easier to compare with in the loop, and these
                    // are also the addresses we need for copying the
                    // last bytes.
                    length := sub(length, 32)
                    let sEnd := add(source, length)
                    let dEnd := add(dest, length)

                    // Remember the last 32 bytes of source
                    // This needs to be done here and not after the loop
                    // because we may have overwritten the last bytes in
                    // source already due to overlap.
                    let last := mload(sEnd)

                    // Copy whole words front to back
                    // Note: the first check is always true,
                    // this could have been a do-while loop.
                    // solhint-disable-next-line no-empty-blocks
                    for {} lt(source, sEnd) {} {
                        mstore(dest, mload(source))
                        source := add(source, 32)
                        dest := add(dest, 32)
                    }

                    // Write the last 32 bytes
                    mstore(dEnd, last)
                }
            } else {
                assembly {
                    // We subtract 32 from `sEnd` and `dEnd` because those
                    // are the starting points when copying a word at the end.
                    length := sub(length, 32)
                    let sEnd := add(source, length)
                    let dEnd := add(dest, length)

                    // Remember the first 32 bytes of source
                    // This needs to be done here and not after the loop
                    // because we may have overwritten the first bytes in
                    // source already due to overlap.
                    let first := mload(source)

                    // Copy whole words back to front
                    // We use a signed comparisson here to allow dEnd to become
                    // negative (happens when source and dest < 32). Valid
                    // addresses in local memory will never be larger than
                    // 2**255, so they can be safely re-interpreted as signed.
                    // Note: the first check is always true,
                    // this could have been a do-while loop.
                    // solhint-disable-next-line no-empty-blocks
                    for {} slt(dest, dEnd) {} {
                        mstore(dEnd, mload(sEnd))
                        sEnd := sub(sEnd, 32)
                        dEnd := sub(dEnd, 32)
                    }

                    // Write the first 32 bytes
                    mstore(dest, first)
                }
            }
        }
    }

    /// @dev Returns a slices from a byte array.
    /// @param b The byte array to take a slice from.
    /// @param from The starting index for the slice (inclusive).
    /// @param to The final index for the slice (exclusive).
    /// @return result The slice containing bytes at indices [from, to)
    function slice(
        bytes memory b,
        uint256 from,
        uint256 to
    )
        internal
        pure
        returns (bytes memory result)
    {
        // Ensure that the from and to positions are valid positions for a slice within
        // the byte array that is being used.
        if (from > to) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
                from,
                to
            ));
        }
        if (to > b.length) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
                to,
                b.length
            ));
        }

        // Create a new bytes structure and copy contents
        result = new bytes(to - from);
        memCopy(
            result.contentAddress(),
            b.contentAddress() + from,
            result.length
        );
        return result;
    }

    /// @dev Returns a slice from a byte array without preserving the input.
    ///      When `from == 0`, the original array will match the slice.
    ///      In other cases its state will be corrupted.
    /// @param b The byte array to take a slice from. Will be destroyed in the process.
    /// @param from The starting index for the slice (inclusive).
    /// @param to The final index for the slice (exclusive).
    /// @return result The slice containing bytes at indices [from, to)
    function sliceDestructive(
        bytes memory b,
        uint256 from,
        uint256 to
    )
        internal
        pure
        returns (bytes memory result)
    {
        // Ensure that the from and to positions are valid positions for a slice within
        // the byte array that is being used.
        if (from > to) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,
                from,
                to
            ));
        }
        if (to > b.length) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,
                to,
                b.length
            ));
        }

        // Create a new bytes structure around [from, to) in-place.
        assembly {
            result := add(b, from)
            mstore(result, sub(to, from))
        }
        return result;
    }

    /// @dev Pops the last byte off of a byte array by modifying its length.
    /// @param b Byte array that will be modified.
    /// @return result The byte that was popped off.
    function popLastByte(bytes memory b)
        internal
        pure
        returns (bytes1 result)
    {
        if (b.length == 0) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanZeroRequired,
                b.length,
                0
            ));
        }

        // Store last byte.
        result = b[b.length - 1];

        assembly {
            // Decrement length of byte array.
            let newLen := sub(mload(b), 1)
            mstore(b, newLen)
        }
        return result;
    }

    /// @dev Tests equality of two byte arrays.
    /// @param lhs First byte array to compare.
    /// @param rhs Second byte array to compare.
    /// @return equal True if arrays are the same. False otherwise.
    function equals(
        bytes memory lhs,
        bytes memory rhs
    )
        internal
        pure
        returns (bool equal)
    {
        // Keccak gas cost is 30 + numWords * 6. This is a cheap way to compare.
        // We early exit on unequal lengths, but keccak would also correctly
        // handle this.
        return lhs.length == rhs.length && keccak256(lhs) == keccak256(rhs);
    }

    /// @dev Reads an address from a position in a byte array.
    /// @param b Byte array containing an address.
    /// @param index Index in byte array of address.
    /// @return result address from byte array.
    function readAddress(
        bytes memory b,
        uint256 index
    )
        internal
        pure
        returns (address result)
    {
        if (b.length < index + 20) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
                b.length,
                index + 20 // 20 is length of address
            ));
        }

        // Add offset to index:
        // 1. Arrays are prefixed by 32-byte length parameter (add 32 to index)
        // 2. Account for size difference between address length and 32-byte storage word (subtract 12 from index)
        index += 20;

        // Read address from array memory
        assembly {
            // 1. Add index to address of bytes array
            // 2. Load 32-byte word from memory
            // 3. Apply 20-byte mask to obtain address
            result := and(mload(add(b, index)), 0xffffffffffffffffffffffffffffffffffffffff)
        }
        return result;
    }

    /// @dev Writes an address into a specific position in a byte array.
    /// @param b Byte array to insert address into.
    /// @param index Index in byte array of address.
    /// @param input Address to put into byte array.
    function writeAddress(
        bytes memory b,
        uint256 index,
        address input
    )
        internal
        pure
    {
        if (b.length < index + 20) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,
                b.length,
                index + 20 // 20 is length of address
            ));
        }

        // Add offset to index:
        // 1. Arrays are prefixed by 32-byte length parameter (add 32 to index)
        // 2. Account for size difference between address length and 32-byte storage word (subtract 12 from index)
        index += 20;

        // Store address into array memory
        assembly {
            // The address occupies 20 bytes and mstore stores 32 bytes.
            // First fetch the 32-byte word where we'll be storing the address, then
            // apply a mask so we have only the bytes in the word that the address will not occupy.
            // Then combine these bytes with the address and store the 32 bytes back to memory with mstore.

            // 1. Add index to address of bytes array
            // 2. Load 32-byte word from memory
            // 3. Apply 12-byte mask to obtain extra bytes occupying word of memory where we'll store the address
            let neighbors := and(
                mload(add(b, index)),
                0xffffffffffffffffffffffff0000000000000000000000000000000000000000
            )

            // Make sure input address is clean.
            // (Solidity does not guarantee this)
            input := and(input, 0xffffffffffffffffffffffffffffffffffffffff)

            // Store the neighbors and address into memory
            mstore(add(b, index), xor(input, neighbors))
        }
    }

    /// @dev Reads a bytes32 value from a position in a byte array.
    /// @param b Byte array containing a bytes32 value.
    /// @param index Index in byte array of bytes32 value.
    /// @return result bytes32 value from byte array.
    function readBytes32(
        bytes memory b,
        uint256 index
    )
        internal
        pure
        returns (bytes32 result)
    {
        if (b.length < index + 32) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
                b.length,
                index + 32
            ));
        }

        // Arrays are prefixed by a 256 bit length parameter
        index += 32;

        // Read the bytes32 from array memory
        assembly {
            result := mload(add(b, index))
        }
        return result;
    }

    /// @dev Writes a bytes32 into a specific position in a byte array.
    /// @param b Byte array to insert <input> into.
    /// @param index Index in byte array of <input>.
    /// @param input bytes32 to put into byte array.
    function writeBytes32(
        bytes memory b,
        uint256 index,
        bytes32 input
    )
        internal
        pure
    {
        if (b.length < index + 32) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,
                b.length,
                index + 32
            ));
        }

        // Arrays are prefixed by a 256 bit length parameter
        index += 32;

        // Read the bytes32 from array memory
        assembly {
            mstore(add(b, index), input)
        }
    }

    /// @dev Reads a uint256 value from a position in a byte array.
    /// @param b Byte array containing a uint256 value.
    /// @param index Index in byte array of uint256 value.
    /// @return result uint256 value from byte array.
    function readUint256(
        bytes memory b,
        uint256 index
    )
        internal
        pure
        returns (uint256 result)
    {
        result = uint256(readBytes32(b, index));
        return result;
    }

    /// @dev Writes a uint256 into a specific position in a byte array.
    /// @param b Byte array to insert <input> into.
    /// @param index Index in byte array of <input>.
    /// @param input uint256 to put into byte array.
    function writeUint256(
        bytes memory b,
        uint256 index,
        uint256 input
    )
        internal
        pure
    {
        writeBytes32(b, index, bytes32(input));
    }

    /// @dev Reads an unpadded bytes4 value from a position in a byte array.
    /// @param b Byte array containing a bytes4 value.
    /// @param index Index in byte array of bytes4 value.
    /// @return result bytes4 value from byte array.
    function readBytes4(
        bytes memory b,
        uint256 index
    )
        internal
        pure
        returns (bytes4 result)
    {
        if (b.length < index + 4) {
            LibRichErrorsV06.rrevert(LibBytesRichErrorsV06.InvalidByteOperationError(
                LibBytesRichErrorsV06.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsFourRequired,
                b.length,
                index + 4
            ));
        }

        // Arrays are prefixed by a 32 byte length field
        index += 32;

        // Read the bytes4 from array memory
        assembly {
            result := mload(add(b, index))
            // Solidity does not require us to clean the trailing bytes.
            // We do it anyway
            result := and(result, 0xFFFFFFFF00000000000000000000000000000000000000000000000000000000)
        }
        return result;
    }

    /// @dev Writes a new length to a byte array.
    ///      Decreasing length will lead to removing the corresponding lower order bytes from the byte array.
    ///      Increasing length may lead to appending adjacent in-memory bytes to the end of the byte array.
    /// @param b Bytes array to write new length to.
    /// @param length New length of byte array.
    function writeLength(bytes memory b, uint256 length)
        internal
        pure
    {
        assembly {
            mstore(b, length)
        }
    }
}

File 3 of 10 : LibBytesRichErrorsV06.sol
// SPDX-License-Identifier: Apache-2.0
/*

  Copyright 2020 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

pragma solidity ^0.6.5;


library LibBytesRichErrorsV06 {

    enum InvalidByteOperationErrorCodes {
        FromLessThanOrEqualsToRequired,
        ToLessThanOrEqualsLengthRequired,
        LengthGreaterThanZeroRequired,
        LengthGreaterThanOrEqualsFourRequired,
        LengthGreaterThanOrEqualsTwentyRequired,
        LengthGreaterThanOrEqualsThirtyTwoRequired,
        LengthGreaterThanOrEqualsNestedBytesLengthRequired,
        DestinationLengthGreaterThanOrEqualSourceLengthRequired
    }

    // bytes4(keccak256("InvalidByteOperationError(uint8,uint256,uint256)"))
    bytes4 internal constant INVALID_BYTE_OPERATION_ERROR_SELECTOR =
        0x28006595;

    // solhint-disable func-name-mixedcase
    function InvalidByteOperationError(
        InvalidByteOperationErrorCodes errorCode,
        uint256 offset,
        uint256 required
    )
        internal
        pure
        returns (bytes memory)
    {
        return abi.encodeWithSelector(
            INVALID_BYTE_OPERATION_ERROR_SELECTOR,
            errorCode,
            offset,
            required
        );
    }
}

File 4 of 10 : LibRichErrorsV06.sol
// SPDX-License-Identifier: Apache-2.0
/*

  Copyright 2020 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

pragma solidity ^0.6.5;


library LibRichErrorsV06 {

    // bytes4(keccak256("Error(string)"))
    bytes4 internal constant STANDARD_ERROR_SELECTOR = 0x08c379a0;

    // solhint-disable func-name-mixedcase
    /// @dev ABI encode a standard, string revert error payload.
    ///      This is the same payload that would be included by a `revert(string)`
    ///      solidity statement. It has the function signature `Error(string)`.
    /// @param message The error string.
    /// @return The ABI encoded error.
    function StandardError(string memory message)
        internal
        pure
        returns (bytes memory)
    {
        return abi.encodeWithSelector(
            STANDARD_ERROR_SELECTOR,
            bytes(message)
        );
    }
    // solhint-enable func-name-mixedcase

    /// @dev Reverts an encoded rich revert reason `errorData`.
    /// @param errorData ABI encoded error data.
    function rrevert(bytes memory errorData)
        internal
        pure
    {
        assembly {
            revert(add(errorData, 0x20), mload(errorData))
        }
    }
}

File 5 of 10 : LibBootstrap.sol
// SPDX-License-Identifier: Apache-2.0
/*

  Copyright 2020 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

pragma solidity ^0.6.5;
pragma experimental ABIEncoderV2;

import "@0x/contracts-utils/contracts/src/v06/errors/LibRichErrorsV06.sol";
import "../errors/LibProxyRichErrors.sol";


library LibBootstrap {

    /// @dev Magic bytes returned by the bootstrapper to indicate success.
    ///      This is `keccack('BOOTSTRAP_SUCCESS')`.
    bytes4 internal constant BOOTSTRAP_SUCCESS = 0xd150751b;

    using LibRichErrorsV06 for bytes;

    /// @dev Perform a delegatecall and ensure it returns the magic bytes.
    /// @param target The call target.
    /// @param data The call data.
    function delegatecallBootstrapFunction(
        address target,
        bytes memory data
    )
        internal
    {
        (bool success, bytes memory resultData) = target.delegatecall(data);
        if (!success ||
            resultData.length != 32 ||
            abi.decode(resultData, (bytes4)) != BOOTSTRAP_SUCCESS)
        {
            LibProxyRichErrors.BootstrapCallFailedError(target, resultData).rrevert();
        }
    }
}

File 6 of 10 : LibProxyRichErrors.sol
// SPDX-License-Identifier: Apache-2.0
/*

  Copyright 2020 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

pragma solidity ^0.6.5;


library LibProxyRichErrors {

    // solhint-disable func-name-mixedcase

    function NotImplementedError(bytes4 selector)
        internal
        pure
        returns (bytes memory)
    {
        return abi.encodeWithSelector(
            bytes4(keccak256("NotImplementedError(bytes4)")),
            selector
        );
    }

    function InvalidBootstrapCallerError(address actual, address expected)
        internal
        pure
        returns (bytes memory)
    {
        return abi.encodeWithSelector(
            bytes4(keccak256("InvalidBootstrapCallerError(address,address)")),
            actual,
            expected
        );
    }

    function InvalidDieCallerError(address actual, address expected)
        internal
        pure
        returns (bytes memory)
    {
        return abi.encodeWithSelector(
            bytes4(keccak256("InvalidDieCallerError(address,address)")),
            actual,
            expected
        );
    }

    function BootstrapCallFailedError(address target, bytes memory resultData)
        internal
        pure
        returns (bytes memory)
    {
        return abi.encodeWithSelector(
            bytes4(keccak256("BootstrapCallFailedError(address,bytes)")),
            target,
            resultData
        );
    }
}

File 7 of 10 : BootstrapFeature.sol
// SPDX-License-Identifier: Apache-2.0
/*

  Copyright 2020 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

pragma solidity ^0.6.5;
pragma experimental ABIEncoderV2;

import "@0x/contracts-utils/contracts/src/v06/errors/LibRichErrorsV06.sol";
import "../migrations/LibBootstrap.sol";
import "../storage/LibProxyStorage.sol";
import "./IBootstrapFeature.sol";


/// @dev Detachable `bootstrap()` feature.
contract BootstrapFeature is
    IBootstrapFeature
{
    // solhint-disable state-visibility,indent
    /// @dev The ZeroEx contract.
    ///      This has to be immutable to persist across delegatecalls.
    address immutable private _deployer;
    /// @dev The implementation address of this contract.
    ///      This has to be immutable to persist across delegatecalls.
    address immutable private _implementation;
    /// @dev The deployer.
    ///      This has to be immutable to persist across delegatecalls.
    address immutable private _bootstrapCaller;
    // solhint-enable state-visibility,indent

    using LibRichErrorsV06 for bytes;

    /// @dev Construct this contract and set the bootstrap migration contract.
    ///      After constructing this contract, `bootstrap()` should be called
    ///      to seed the initial feature set.
    /// @param bootstrapCaller The allowed caller of `bootstrap()`.
    constructor(address bootstrapCaller) public {
        _deployer = msg.sender;
        _implementation = address(this);
        _bootstrapCaller = bootstrapCaller;
    }

    /// @dev Bootstrap the initial feature set of this contract by delegatecalling
    ///      into `target`. Before exiting the `bootstrap()` function will
    ///      deregister itself from the proxy to prevent being called again.
    /// @param target The bootstrapper contract address.
    /// @param callData The call data to execute on `target`.
    function bootstrap(address target, bytes calldata callData) external override {
        // Only the bootstrap caller can call this function.
        if (msg.sender != _bootstrapCaller) {
            LibProxyRichErrors.InvalidBootstrapCallerError(
                msg.sender,
                _bootstrapCaller
            ).rrevert();
        }
        // Deregister.
        LibProxyStorage.getStorage().impls[this.bootstrap.selector] = address(0);
        // Self-destruct.
        BootstrapFeature(_implementation).die();
        // Call the bootstrapper.
        LibBootstrap.delegatecallBootstrapFunction(target, callData);
    }

    /// @dev Self-destructs this contract.
    ///      Can only be called by the deployer.
    function die() external {
        assert(address(this) == _implementation);
        if (msg.sender != _deployer) {
            LibProxyRichErrors.InvalidDieCallerError(msg.sender, _deployer).rrevert();
        }
        selfdestruct(msg.sender);
    }
}

File 8 of 10 : LibProxyStorage.sol
// SPDX-License-Identifier: Apache-2.0
/*

  Copyright 2020 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

pragma solidity ^0.6.5;
pragma experimental ABIEncoderV2;

import "./LibStorage.sol";


/// @dev Storage helpers for the proxy contract.
library LibProxyStorage {

    /// @dev Storage bucket for proxy contract.
    struct Storage {
        // Mapping of function selector -> function implementation
        mapping(bytes4 => address) impls;
        // The owner of the proxy contract.
        address owner;
    }

    /// @dev Get the storage bucket for this contract.
    function getStorage() internal pure returns (Storage storage stor) {
        uint256 storageSlot = LibStorage.getStorageSlot(
            LibStorage.StorageId.Proxy
        );
        // Dip into assembly to change the slot pointed to by the local
        // variable `stor`.
        // See https://solidity.readthedocs.io/en/v0.6.8/assembly.html?highlight=slot#access-to-external-variables-functions-and-libraries
        assembly { stor_slot := storageSlot }
    }
}

File 9 of 10 : LibStorage.sol
// SPDX-License-Identifier: Apache-2.0
/*

  Copyright 2020 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

pragma solidity ^0.6.5;
pragma experimental ABIEncoderV2;


/// @dev Common storage helpers
library LibStorage {

    /// @dev What to bit-shift a storage ID by to get its slot.
    ///      This gives us a maximum of 2**128 inline fields in each bucket.
    uint256 private constant STORAGE_SLOT_EXP = 128;

    /// @dev Storage IDs for feature storage buckets.
    ///      WARNING: APPEND-ONLY.
    enum StorageId {
        Proxy,
        SimpleFunctionRegistry,
        Ownable,
        TokenSpender,
        TransformERC20,
        MetaTransactions,
        ReentrancyGuard,
        NativeOrders
    }

    /// @dev Get the storage slot given a storage ID. We assign unique, well-spaced
    ///     slots to storage bucket variables to ensure they do not overlap.
    ///     See: https://solidity.readthedocs.io/en/v0.6.6/assembly.html#access-to-external-variables-functions-and-libraries
    /// @param storageId An entry in `StorageId`
    /// @return slot The storage slot.
    function getStorageSlot(StorageId storageId)
        internal
        pure
        returns (uint256 slot)
    {
        // This should never overflow with a reasonable `STORAGE_SLOT_EXP`
        // because Solidity will do a range check on `storageId` during the cast.
        return (uint256(storageId) + 1) << STORAGE_SLOT_EXP;
    }
}

File 10 of 10 : IBootstrapFeature.sol
// SPDX-License-Identifier: Apache-2.0
/*

  Copyright 2020 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

pragma solidity ^0.6.5;
pragma experimental ABIEncoderV2;


/// @dev Detachable `bootstrap()` feature.
interface IBootstrapFeature {

    /// @dev Bootstrap the initial feature set of this contract by delegatecalling
    ///      into `target`. Before exiting the `bootstrap()` function will
    ///      deregister itself from the proxy to prevent being called again.
    /// @param target The bootstrapper contract address.
    /// @param callData The call data to execute on `target`.
    function bootstrap(address target, bytes calldata callData) external;
}

Settings
{
  "remappings": [
    "@0x/contracts-utils=/home/cluracan/code/0x-protocol/node_modules/@0x/contracts-utils",
    "@0x/contracts-erc20=/home/cluracan/code/0x-protocol/contracts/zero-ex/node_modules/@0x/contracts-erc20"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 1000000,
    "details": {
      "yul": true,
      "deduplicate": true,
      "cse": true,
      "constantOptimizer": true
    }
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "istanbul"
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"bootstrapper","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"bytes4","name":"selector","type":"bytes4"}],"name":"getFunctionImplementation","outputs":[{"internalType":"address","name":"impl","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000476898f5aCf513d35d655F8128cE647a6D590094

-----Decoded View---------------
Arg [0] : bootstrapper (address): 0x476898f5acf513d35d655f8128ce647a6d590094

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000476898f5aCf513d35d655F8128cE647a6D590094


Deployed ByteCode Sourcemap

1032:2256:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;1974:15;1992:22;2012:1;1992:8;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1992:19:0;;:22;-1:-1:-1;;1992:19:0;:22;-1:-1:-1;1992:22:0:i;:::-;1974:40;;2024:12;2039:35;2065:8;2039:25;:35::i;:::-;2024:50;-1:-1:-1;2088:18:0;;;2084:114;;2122:65;2138:48;2177:8;2138:38;:48::i;:::-;2122:15;:65::i;:::-;2209:12;2223:23;2250:4;:17;;2268:8;;2250:27;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2208:69;;;;2292:7;2287:66;;2315:27;2331:10;2315:15;:27::i;:::-;2362;2378:10;2362:15;:27::i;:::-;1936:460;;;;1032:2256;2701:183;;;;;;;;;;-1:-1:-1;2701:183:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;17014:880:7;17134:13;17178:5;17186:1;17178:9;17167:1;:8;:20;17163:299;;;17203:248;17228:222;17293:90;17401:1;:8;17427:5;17435:1;17427:9;17228:47;:222::i;17203:248::-;-1:-1:-1;17635:13:7;17538:2;17635:13;17629:20;17788:66;17776:79;;17014:880::o;2701:183:0:-;2798:12;2833:28;:26;:28::i;:::-;:44;;;;;:34;:44;;;;;;;;-1:-1:-1;2833:44:0;;;;;;;2701:183::o;723:251:1:-;816:12;894:40;949:8;851:116;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;723:251:1;;;:::o;2965:120:0:-;3071:4;3065:11;3060:2;3054:4;3050:13;3043:34;3166:120;3272:4;3266:11;3261:2;3255:4;3251:13;3244:34;1094:466:5;1139:20;1171:19;1193:75;1232:26;1193:25;:75::i;:::-;1171:97;1526:28;-1:-1:-1;;1526:28:5:o;1606:335:6:-;1698:12;922:3;1899:9;1891:18;;;;;;;;1912:1;1891:22;1890:44;;;1606:335;-1:-1:-1;;1606:335:6:o;1334:378:8:-;1522:12;1274:10;1593:37;;1644:9;1667:6;1687:8;1557:148;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1334:378:8;;;;;:::o;140:239:-1:-;;243:2;231:9;222:7;218:23;214:32;211:2;;;-1:-1;;249:12;211:2;84:6;71:20;2875:66;3899:5;2864:78;3875:5;3872:34;3862:2;;-1:-1;;3910:12;3862:2;301:62;205:174;-1:-1;;;205:174::o;1283:291::-;;3609:6;3604:3;3599;3586:30;3647:16;;3640:27;;;3647:16;1427:147;-1:-1;1427:147::o;1581:222::-;3210:42;3199:54;;;;457:37;;1708:2;1693:18;;1679:124::o;1810:218::-;2875:66;2864:78;;;;575:36;;1935:2;1920:18;;1906:122::o;2035:510::-;2251:2;2236:18;;3785:1;3775:12;;3765:2;;3791:9;3765:2;1068:83;;;2448:2;2433:18;;1234:37;;;;2531:2;2516:18;;;1234:37;2222:323;:::o

Swarm Source

ipfs://a3fbaa1115d10d5b99fcfa78b9e07eb7aee45d78378b0c1ecd0a75a0d813ebf4
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.