Contract 0xdef1abe32c034e558cdd535791643c58a13acc10 2

 
Txn Hash Method
Index
From
To
Value
0x44ca4175297fabadd62330f2cd7d3579aa4d131786551a6c0a927614d43a17bf0x415565b0137245692022-07-03 2:05:2513 mins ago0x543f7ccf5166ba9c8afb5e768accf9f401155370 IN  0xdef1abe32c034e558cdd535791643c58a13acc100.025620007531266 Ether0.0003568245031
0xf5dcf804e6d02bf6aeb54a88b25c8488d37fd2133b83bfc7d9542ff0b26ac4dd0x415565b0137243902022-07-03 2:00:0419 mins ago0x3bc291c64dd4b08a9224ead3770378c4b773b65a IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0003588675171
0x18e9177b50eed655cc87ec84d70ee2cfb78bc96d778573555db5ac289e5e80b40x415565b0137242732022-07-03 1:57:0922 mins ago0x1115a4ed27acdfd5a71b41704a9f58ca660ea7df IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0003224632431
0x21c25bd88849c5374d633e9b25cbce4b52b5be66e8366ca8a48bed0d0a729c820x415565b0137241902022-07-03 1:53:4225 mins ago0xcbcc36af59675e7b291dcbcf7c5adc7b9894969d IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0003625573391
0x28a8b4eebf053ea7b2a3de36764c9d34983ae11db80d7218d847e2d6f49f2c600x415565b0137237872022-07-03 1:43:2735 mins ago0x68526a4295236d2f18ceda8a200cddd5aab9e2cc IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0001665130510.001
0x556e09925b4265ce872514571aaacbe9f2effb3be1ab52d38cc518b5c5e8aff70x415565b0137232992022-07-03 1:33:1346 mins ago0x2a8f00f2394b70087f4dccd01aa2033135e169a1 IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0004097603771
0x7aa3479cb21a0bc28bdc1f9c19c4ca3994c14307f248e7698c991bb2e4edc5ee0x415565b0137232002022-07-03 1:29:1250 mins ago0x965658b4bd00dd1967cc4f8220462b6007f15860 IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0002966166581
0xa74c5177f0cc921a4c739294c3fee130fbe93437b75ef102bfeee8ab65924d020x415565b0137231182022-07-03 1:25:5153 mins ago0x45aec1c6b52e6f641aa97f7011f1b3c1fcbf3626 IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0004170799821
0x06aa9df2d4fee0aeed61b88b254b43acd387dc72f86ead4968bcc80b9f678c800x415565b0137229272022-07-03 1:18:141 hr ago0xac5fd8abbfb2efdb330f627d9d69d1c0909d6316 IN  0xdef1abe32c034e558cdd535791643c58a13acc100.0001 Ether0.0003329473291
0xd1dd1247db5e3b896166c3066207dc3be16967ae84566bc5144373658231fab10x415565b0137226072022-07-03 1:06:251 hr 12 mins ago0xc10f2e9051b674e4a7e6fbe9bd5af0a1fbf7ce24 IN  0xdef1abe32c034e558cdd535791643c58a13acc101.4 Ether0.0005618514391
0x45c70e16ec0bea86397928edcf79057f578dde5b5ae176db71b9989ba22aa1140x415565b0137224732022-07-03 1:00:471 hr 18 mins ago0x7939410279f369639a1ba84fc93bf03eddf1f9a8 IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0003906205761
0x7cbb551f5ae30846bee5a42a0303ef724cc0c5cf036caa0d7bf4ddb37a56c0690x415565b0137220832022-07-03 0:45:371 hr 33 mins ago0x40a123ddb1650a2839e5c96308466ad19bd68bea IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.000136953960.001
0x58a1f8601befcf0fd50ec538231673d9ed398ec9938ffed6d8a6e82828145c130x415565b0137220212022-07-03 0:43:161 hr 35 mins ago0x9b47dcd34e6358288db160899a7f9f62d21086d5 IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0003498460991
0x7f596fa432cc5e6b6e9dea2941b16cd5a08c9d1a7730346efe9dfa8e1be8adfc0x415565b0137220202022-07-03 0:43:161 hr 35 mins ago0xb8aa5d63491c087d40fee4311a89b1dcd74b0fdb IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0001671578120.001
0x6bd6a2967027046dba29e570f6f5c099cd2a10811f59553b71a70cb769b67b3f0x415565b0137219502022-07-03 0:39:041 hr 40 mins ago0x84acb4278360ab4a09df2f963a14724f51098518 IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0005948421371
0x657d258ee8439de70cdcdc13f3c77ffbf6a112e0c1648892272835e548cd58a20x415565b0137217372022-07-03 0:34:281 hr 44 mins ago0x84acb4278360ab4a09df2f963a14724f51098518 IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0004349077561
0x806540d511799a7284b2d9ea9ac36cf5c4cb03236129ff20879119407a69d6eb0x415565b0137216212022-07-03 0:31:351 hr 47 mins ago0x5a9d68c871325979b16dab50acff1f9ebfa9ab3f IN  0xdef1abe32c034e558cdd535791643c58a13acc100.002 Ether0.0003209089681
0xf038567cca90c4ea237fdbd2a8cbb5f7fba767335509307475e512b6bb6c98fc0x415565b0137215002022-07-03 0:30:351 hr 48 mins ago0x6e2e4991ebc00841e10419065c966b613bc4a84b IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0000723280110.001
0xfec83541c5c6e9de9d0f0f03764950ff99a171f89ed77516e39e64c7c1ab1b510x415565b0137211282022-07-03 0:20:521 hr 58 mins ago0x083e958db271a5ba105c0878a94507fe37f25446 IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0002877597691
0x4b18d9cc7f689e9d0031beb17246d27325a2462ac51a5a9f4ccffbf1555e8e4c0x415565b0137209272022-07-03 0:19:521 hr 59 mins ago0x68526a4295236d2f18ceda8a200cddd5aab9e2cc IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0000887167210.001
0x56ddb94dbfefaf4bbb0ee4c7b7eb6db8fcba12c72d8ee8374127ed02bd2fedc20x415565b0137208642022-07-03 0:19:521 hr 59 mins ago0x68526a4295236d2f18ceda8a200cddd5aab9e2cc IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0000887820690.001
0xfba19c40e19f6376853668615573573f50742e68bcdea607f545c9e0134ab4260x415565b0137203022022-07-03 0:10:512 hrs 8 mins ago0x6e2e4991ebc00841e10419065c966b613bc4a84b IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0001166151850.001
0x21b8902a86840a21aeac5867c67cb7cd1790350f500ead029d64a6e8a570688e0x415565b0137201772022-07-03 0:06:442 hrs 12 mins ago0xa8b352389a1935e96880f28a7ba6ec0cfd907a6b IN  0xdef1abe32c034e558cdd535791643c58a13acc100.001 Ether0.0003333345251
0x11b5588d31903929056b2472efdc6d55c45e14674032a945dc8c78c066bd5ff90x415565b0137200022022-07-03 0:01:062 hrs 18 mins ago0xa8b352389a1935e96880f28a7ba6ec0cfd907a6b IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0003153506351
0x7d5b6238d7dcf16c2c8a1a17a1a4769330a13793d97b4da7a4bee01b0f497b080x415565b0137196632022-07-02 23:42:572 hrs 36 mins ago0x364aeb719b357206f49049b7a406f38edd2a3419 IN  0xdef1abe32c034e558cdd535791643c58a13acc100 Ether0.0005623663470.0013
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x5f23b29d813096fd8f19c39c37c4c34fb93bc360efd35031844530b7c1c6f4b9137248812022-07-03 2:15:503 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0x5f23b29d813096fd8f19c39c37c4c34fb93bc360efd35031844530b7c1c6f4b9137248812022-07-03 2:15:503 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0x5f23b29d813096fd8f19c39c37c4c34fb93bc360efd35031844530b7c1c6f4b9137248812022-07-03 2:15:503 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0x5f23b29d813096fd8f19c39c37c4c34fb93bc360efd35031844530b7c1c6f4b9137248812022-07-03 2:15:503 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0x5f23b29d813096fd8f19c39c37c4c34fb93bc360efd35031844530b7c1c6f4b9137248812022-07-03 2:15:503 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0x7f5c764cbc14f9669b88837ca1490cca17c316070 Ether
0x5f23b29d813096fd8f19c39c37c4c34fb93bc360efd35031844530b7c1c6f4b9137248812022-07-03 2:15:503 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0x23e1fcf553a7db590562f8a47bd76a28e358455e0 Ether
0x5f23b29d813096fd8f19c39c37c4c34fb93bc360efd35031844530b7c1c6f4b9137248812022-07-03 2:15:503 mins ago 0x362fa9d0bca5d19f743db50738345ce2b40ec99f 0xdef1abe32c034e558cdd535791643c58a13acc100 Ether
0x44ca4175297fabadd62330f2cd7d3579aa4d131786551a6c0a927614d43a17bf137245692022-07-03 2:05:2513 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0x7f5c764cbc14f9669b88837ca1490cca17c316070 Ether
0x44ca4175297fabadd62330f2cd7d3579aa4d131786551a6c0a927614d43a17bf137245692022-07-03 2:05:2513 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0x44ca4175297fabadd62330f2cd7d3579aa4d131786551a6c0a927614d43a17bf137245692022-07-03 2:05:2513 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0x7f5c764cbc14f9669b88837ca1490cca17c316070 Ether
0x44ca4175297fabadd62330f2cd7d3579aa4d131786551a6c0a927614d43a17bf137245692022-07-03 2:05:2513 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0x44ca4175297fabadd62330f2cd7d3579aa4d131786551a6c0a927614d43a17bf137245692022-07-03 2:05:2513 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0x44ca4175297fabadd62330f2cd7d3579aa4d131786551a6c0a927614d43a17bf137245692022-07-03 2:05:2513 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0x44ca4175297fabadd62330f2cd7d3579aa4d131786551a6c0a927614d43a17bf137245692022-07-03 2:05:2513 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400.025620007531266499 Ether
0x44ca4175297fabadd62330f2cd7d3579aa4d131786551a6c0a927614d43a17bf137245692022-07-03 2:05:2513 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0x7f5c764cbc14f9669b88837ca1490cca17c316070 Ether
0x44ca4175297fabadd62330f2cd7d3579aa4d131786551a6c0a927614d43a17bf137245692022-07-03 2:05:2513 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0x23e1fcf553a7db590562f8a47bd76a28e358455e0 Ether
0xf5dcf804e6d02bf6aeb54a88b25c8488d37fd2133b83bfc7d9542ff0b26ac4dd137243902022-07-03 2:00:0419 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0xf5dcf804e6d02bf6aeb54a88b25c8488d37fd2133b83bfc7d9542ff0b26ac4dd137243902022-07-03 2:00:0419 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0xf5dcf804e6d02bf6aeb54a88b25c8488d37fd2133b83bfc7d9542ff0b26ac4dd137243902022-07-03 2:00:0419 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0xf5dcf804e6d02bf6aeb54a88b25c8488d37fd2133b83bfc7d9542ff0b26ac4dd137243902022-07-03 2:00:0419 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0xf5dcf804e6d02bf6aeb54a88b25c8488d37fd2133b83bfc7d9542ff0b26ac4dd137243902022-07-03 2:00:0419 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0x7f5c764cbc14f9669b88837ca1490cca17c316070 Ether
0xf5dcf804e6d02bf6aeb54a88b25c8488d37fd2133b83bfc7d9542ff0b26ac4dd137243902022-07-03 2:00:0419 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0x23e1fcf553a7db590562f8a47bd76a28e358455e0 Ether
0x18e9177b50eed655cc87ec84d70ee2cfb78bc96d778573555db5ac289e5e80b4137242732022-07-03 1:57:0922 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0x18e9177b50eed655cc87ec84d70ee2cfb78bc96d778573555db5ac289e5e80b4137242732022-07-03 1:57:0922 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
0x18e9177b50eed655cc87ec84d70ee2cfb78bc96d778573555db5ac289e5e80b4137242732022-07-03 1:57:0922 mins ago 0xdef1abe32c034e558cdd535791643c58a13acc10 0xa3128d9b7cca7d5af29780a56abeec12b05a67400 Ether
[ 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:
default 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 "./interfaces/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,
        OtcOrders
    }

    /// @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=/Users/zixingxin/protocol/node_modules/@0x/contracts-utils",
    "@0x/contracts-erc20=/Users/zixingxin/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)

00000000000000000000000062c0077baa246ab15cacc4e3f9c04f7467cb4593

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

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000062c0077baa246ab15cacc4e3f9c04f7467cb4593


Block Transaction Difficulty Gas Used Reward
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.