Contract 0xdef1c0ded9bec7f1a1670819833240f027b25eff 16

 

Contract Overview

0x: Exchange Proxy
Balance:
227.217189009781310942 MATIC

MATIC Value:
$209.54 (@ $0.92/MATIC)

Token:
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x1bcbe3817e1e7ca57243c7424bdc3ca34f70c9ea0a9dab4b46fd6c200f7f30300x415565b0366076122022-12-09 6:25:3453 secs ago0x18615bcf792a9af80bc0000e5d0d66148afa7b30 IN  0x: Exchange Proxy0 MATIC0.012008268 36
0x2834b5bfcc93dc9f8c675bda4af96af5e0dba55eb06146f998d716f7e8b8cfcc0x415565b0366076002022-12-09 6:25:101 min ago0x74bfccb5927509e68e67ec19b468851d131748b8 IN  0x: Exchange Proxy12.993210529437103 MATIC0.014116859225 60.207015019
0xb2ff828c98442ba2fbf0259aaf2e4f9d5f94fbb57f728a908a5f3239dfe7222f0x415565b0366075912022-12-09 6:24:521 min ago0x18615bcf792a9af80bc0000e5d0d66148afa7b30 IN  0x: Exchange Proxy0 MATIC0.018795911 47
0x3a98ada58251c74b90bded8cd671c0d06f988065169106e4ef1f350447f3879a0x415565b0366075752022-12-09 6:24:202 mins ago0xc73c66fcf350930ede9efbe7e8a0ab690b79dbcb IN  0x: Exchange Proxy0 MATIC0.012764150475 37.550896325
0xbad3c9949e2abd2ce8ba6aa7341111fbd7bd1d7097dc850621bd8b6c6830ba150x415565b0366075712022-12-09 6:24:122 mins ago0xc73c66fcf350930ede9efbe7e8a0ab690b79dbcb IN  0x: Exchange Proxy0 MATIC0.008973245524 37.696376761
0x2ba9e440b50f3f7976519eeae8f5f6aa67313782ec7eff7d66a7a8ae8ecbeee40x415565b0366075672022-12-09 6:24:042 mins ago0xc73c66fcf350930ede9efbe7e8a0ab690b79dbcb IN  0x: Exchange Proxy0 MATIC0.008954446944 37.617404406
0x36d9ecd6ebdf4565a70ecccb6d1d6e836085380b22da98b5c10e7d961307eaa40x415565b0366075672022-12-09 6:24:042 mins ago0x8e020883b9f380730568a3a436c188b3d6c478f1 IN  0x: Exchange Proxy0 MATIC0.08776305150
0x993fc31d57cc9b07c4db55437f14bf767fd532f3b53677ea0e73f56bf66332160x415565b0366075422022-12-09 6:23:103 mins ago0x8e020883b9f380730568a3a436c188b3d6c478f1 IN  0x: Exchange Proxy0 MATIC0.09245625150
0xaa6d982f5621a66ecb77811fb89bc4ef2dfec36989dd42e7afd6385e3a6f3ce00x415565b0366075152022-12-09 6:22:164 mins ago0x8e020883b9f380730568a3a436c188b3d6c478f1 IN  0x: Exchange Proxy0 MATIC0.071466150
0xbc6268e731a5d58bdcf1aa79b39d38cdf871303cd80922b85dc6e3daca4b68750x415565b0366074922022-12-09 6:21:304 mins ago0x8e020883b9f380730568a3a436c188b3d6c478f1 IN  0x: Exchange Proxy0 MATIC0.0433872150
0x4e0a7d44fbf3070d076ec209bb32bf6080c80d7f178661636c14356ed06758230x415565b0366074722022-12-09 6:20:465 mins ago0x8e020883b9f380730568a3a436c188b3d6c478f1 IN  0x: Exchange Proxy0 MATIC0.0669114150
0x8a55d110912d62af9a7eb7c9b2b488d009612461c39ebd1e28ac04895190e2be0x415565b0366074592022-12-09 6:20:206 mins ago0x2d30749beb40c847a7115a9fda92147a2fd9060d IN  0x: Exchange Proxy0 MATIC0.0144489936 45.2
0x8773ccaf1d71158448d7f16a9715f6773f9c7d6a3323e2bd04f657bdd8a77ea50x415565b0366074492022-12-09 6:20:006 mins ago0x8e020883b9f380730568a3a436c188b3d6c478f1 IN  0x: Exchange Proxy0 MATIC0.0969573150
0xb35234c51ee00e7f9ed77583345986b82af0d993716d3ae98365991308424a2d0x415565b0366074302022-12-09 6:19:227 mins ago0x8e020883b9f380730568a3a436c188b3d6c478f1 IN  0x: Exchange Proxy0 MATIC0.08792295150
0xbcf04fc6e57e156b600f9b431377ee9ea8238e1651f8d538ae634af26d927cc90x415565b0366073932022-12-09 6:18:048 mins ago0x4f64cdf5ffd8f7ee3c282020b7cc105372452233 IN  0x: Exchange Proxy0 MATIC0.007658954201 32.300452949
0x9900dda1eaf8afddecafa342ff62db84087ca284475a331a951ba9d64b2968d20x415565b0366073852022-12-09 6:17:488 mins ago0xb922bd8b9d6d0eaff44a5be01ba91d86e2f6c789 IN  0x: Exchange Proxy0 MATIC0.01118665 50
0xe01e046d8953981b3da09be4179cece40f11063035373015440c34155e8d07f50x415565b0366073722022-12-09 6:17:229 mins ago0x246ae3f021558d4bbe4b47f9402039dbf4ba83ed IN  0x: Exchange Proxy0 MATIC0.03740685150
0x3baede59142f05703869f0894cd4f98abe3b7eb183dfd0f9fb9b6595558ef0a4Fill Taker Signe...366073662022-12-09 6:17:109 mins ago0xeff023bb006da503414507062bb4b86291e8707f IN  0x: Exchange Proxy0 MATIC0.004406233213 34.187323688
0xa90386fe23a5e81ea82408e82c12573fb53b104cc714b8815fb406b7c1099dbe0x415565b0366073582022-12-09 6:16:509 mins ago0x246ae3f021558d4bbe4b47f9402039dbf4ba83ed IN  0x: Exchange Proxy0 MATIC0.03741135150
0x3d629cedf4099d185c960abb659c1b8f07a6bfb09917dec5eae5623dab7359960x415565b0366073192022-12-09 6:15:3210 mins ago0x8e020883b9f380730568a3a436c188b3d6c478f1 IN  0x: Exchange Proxy0 MATIC0.0768858150
0x67c5c9e4afbcef89a7973ebb937e6656c3fbabb9810d3f9e312fa794237ebd6bBuy ERC721366072892022-12-09 6:14:2811 mins ago0xd65945a17fc09629891ddb6f58e514acb3898ade IN  0x: Exchange Proxy0 MATIC0.0278193 300
0xe67c1daad1d4cbc61ef266c85d977e6ead6502f473f8e9f61ee1376722b1ae320x415565b0366072842022-12-09 6:14:1812 mins ago0x4f64cdf5ffd8f7ee3c282020b7cc105372452233 IN  0x: Exchange Proxy0.32 MATIC0.007841602918 33.46364525
0x35a246868afbda2cef91cfe1fbeeb68b67c6022d63449b6414b0bbefc280f9550x415565b0366072732022-12-09 6:13:5612 mins ago0xb922bd8b9d6d0eaff44a5be01ba91d86e2f6c789 IN  0x: Exchange Proxy7 MATIC0.009910404 42
0xf43f914164c4d7499871d4d7d8405ec2d8fe44cf02fa98a912e4cbd4df95636a0x415565b0366072712022-12-09 6:13:5212 mins ago0x18615bcf792a9af80bc0000e5d0d66148afa7b30 IN  0x: Exchange Proxy0 MATIC0.01964949 49
0xc462f447cc0a5ddf659a2c8204d477763d68f38c010073d88f498a4ae6fe737b0x415565b0366072532022-12-09 6:13:1613 mins ago0x8e020883b9f380730568a3a436c188b3d6c478f1 IN  0x: Exchange Proxy0 MATIC0.062691150
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x2834b5bfcc93dc9f8c675bda4af96af5e0dba55eb06146f998d716f7e8b8cfcc366076002022-12-09 6:25:101 min ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet12.993210529437103 MATIC
0xf712d3c2e117f4157327793ea0f0149b3a0932505d1400d1f4f65e70b978dcbc366073832022-12-09 6:17:448 mins ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet99.125 MATIC
0xf712d3c2e117f4157327793ea0f0149b3a0932505d1400d1f4f65e70b978dcbc366073832022-12-09 6:17:448 mins ago 0xc590175e458b83680867afd273527ff58f74c02b 0x: Exchange Proxy99.125 MATIC
0x3baede59142f05703869f0894cd4f98abe3b7eb183dfd0f9fb9b6595558ef0a4366073662022-12-09 6:17:109 mins ago 0x: Exchange Proxy0x52a50cbab53305d3f38ab24c8956d84f9f3ae42910.804552429374517248 MATIC
0x3baede59142f05703869f0894cd4f98abe3b7eb183dfd0f9fb9b6595558ef0a4366073662022-12-09 6:17:109 mins ago Polygon: WMATIC Token 0x: Exchange Proxy10.804552429374517248 MATIC
0xe67c1daad1d4cbc61ef266c85d977e6ead6502f473f8e9f61ee1376722b1ae32366072842022-12-09 6:14:1812 mins ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet0.32 MATIC
0x1b57db15fd4b43555b01a9f7034facdd27f85b673b3c0738ce6f06a44d07e267366072812022-12-09 6:14:1212 mins ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet391 MATIC
0x1b57db15fd4b43555b01a9f7034facdd27f85b673b3c0738ce6f06a44d07e267366072812022-12-09 6:14:1212 mins ago 0x1231deb6f5749ef6ce6943a275a1d3e7486f4eae 0x: Exchange Proxy391 MATIC
0x35a246868afbda2cef91cfe1fbeeb68b67c6022d63449b6414b0bbefc280f955366072732022-12-09 6:13:5612 mins ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet7 MATIC
0x34369d5db159715dd6132d3900086dd4c786a6c68bee12db35243e79d29d903b366072342022-12-09 6:12:3813 mins ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet25 MATIC
0x34369d5db159715dd6132d3900086dd4c786a6c68bee12db35243e79d29d903b366072342022-12-09 6:12:3813 mins ago 0x1231deb6f5749ef6ce6943a275a1d3e7486f4eae 0x: Exchange Proxy25 MATIC
0x3da9bbe31c52100ead5305fec3901b830b1b73ab329d4a3cc6280db8fe5c6e17366072332022-12-09 6:12:3613 mins ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet0.29 MATIC
0xcae4f45ba863bcc1e7a78ab8e6b6eef1deb5cb39377196bf680f53d7779c02ae366070842022-12-09 6:07:2619 mins ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet0.495625 MATIC
0xcae4f45ba863bcc1e7a78ab8e6b6eef1deb5cb39377196bf680f53d7779c02ae366070842022-12-09 6:07:2619 mins ago 0xc590175e458b83680867afd273527ff58f74c02b 0x: Exchange Proxy0.495625 MATIC
0xc139129c3df4e0799b12f2425eb5cbb88afa9a71ef2dd9ade19813648d82fc1c366070652022-12-09 6:06:4819 mins ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet4 MATIC
0xc139129c3df4e0799b12f2425eb5cbb88afa9a71ef2dd9ade19813648d82fc1c366070652022-12-09 6:06:4819 mins ago 0xc590175e458b83680867afd273527ff58f74c02b 0x: Exchange Proxy4 MATIC
0x84afd9ae00e4216ff364d797cfabfd268875e1c5ddfbbbbc0e7de61f55f8a7d1366068322022-12-09 5:58:4627 mins ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet4.95625 MATIC
0x84afd9ae00e4216ff364d797cfabfd268875e1c5ddfbbbbc0e7de61f55f8a7d1366068322022-12-09 5:58:4627 mins ago 0xc590175e458b83680867afd273527ff58f74c02b 0x: Exchange Proxy4.95625 MATIC
0x6f3be6881137dcd3cdb738af04e79cb9c9b89705d451929293ade62027f7e763366068022022-12-09 5:57:4628 mins ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet89.2125 MATIC
0x6f3be6881137dcd3cdb738af04e79cb9c9b89705d451929293ade62027f7e763366068022022-12-09 5:57:4628 mins ago 0xc590175e458b83680867afd273527ff58f74c02b 0x: Exchange Proxy89.2125 MATIC
0xdf29c49dd137f8045e9e1600c119f421d949b6c716ab172f1f4cfa8ce6b53557366067292022-12-09 5:55:1631 mins ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet3.965 MATIC
0xdf29c49dd137f8045e9e1600c119f421d949b6c716ab172f1f4cfa8ce6b53557366067292022-12-09 5:55:1631 mins ago 0xc590175e458b83680867afd273527ff58f74c02b 0x: Exchange Proxy3.965 MATIC
0xaac4167e014915175fbcc04fc8b3e405a8dea31ad43ae7b35d73571e621b5921366064642022-12-09 5:44:0242 mins ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet47 MATIC
0x2e7da91b4a2f0d2d5c3ef07a64c39dc1e8c153a741498b617f347f02f3d769cf366064412022-12-09 5:43:1243 mins ago 0x: Exchange Proxy 0x: Exchange Proxy Flash Wallet7.434375 MATIC
0x2e7da91b4a2f0d2d5c3ef07a64c39dc1e8c153a741498b617f347f02f3d769cf366064412022-12-09 5:43:1243 mins ago 0xc590175e458b83680867afd273527ff58f74c02b 0x: Exchange Proxy7.434375 MATIC
[ 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 "./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
    }

    /// @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/jacob/projects/ethdev/0x/workspace-remote/workspace/0x-monorepo/node_modules/@0x/contracts-utils",
    "@0x/contracts-erc20=/Users/jacob/projects/ethdev/0x/workspace-remote/workspace/0x-monorepo/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)

0000000000000000000000000b0f84dee8b4098e85d97a930052fea117a6eba2

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

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000000b0f84dee8b4098e85d97a930052fea117a6eba2


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://d2c385ac4c1daa8630ee3a7827a6ee50c6ab12628698fb06d386c40cdf0dd8e6
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.