Contract 0xEEbeC7874f46C4452610A11FA6bE0264f7f0557F 1

 
Txn Hash
Method
Block
From
To
Value
0x1c8ff3adcba9a0e0ad1b8e0ab998dc6fbf7ef0886a27d84949e09627600059ccBatch Exec135616012021-11-06 7:08:07275 days 21 hrs ago0xceef5841a5df8f93ac26c0f078dfb51ce1df96f8 IN  Furucombo: Proxy v0.13.10.02561569 Ether0.006658665
0x3381edf0114c34c7aa7eb1a108fa8474904689b2fda3d4a5a417a727a0262885Batch Exec125281592021-05-29 8:26:15436 days 20 hrs ago0xbb390731fdbc9128522375bac0adaeafdbbe5572 IN  Furucombo: Proxy v0.13.10 Ether0.00110
0xd35abe7edad2a584d459b8ccd80add85f3880b87bd7a42e8fddec395431c0e9eBatch Exec123527162021-05-02 4:44:21463 days 23 hrs ago0xa9f64f3a4db732cf7ade9d8d0972c38fe287132c IN  Furucombo: Proxy v0.13.10 Ether0.0046731623
0x84cd6077fb22ac0a2d9b1d4775e884cc7c559e1d1c925752b5c3b7749ba266c6Batch Exec123525352021-05-02 4:00:35464 days 41 mins ago0xd7fd2f22d1bd95d20c3565519cb9ee2da721a275 IN  Furucombo: Proxy v0.13.10.03617714 Ether0.0011828623
0xc2e9cc66fc0ed329385bb4eda320caff334039b0887a2922e68a2a00b7b524a2Batch Exec123518622021-05-02 1:31:43464 days 3 hrs ago0x710e398bdc7ea4482a57fdd605a703f59370f845 IN  Furucombo: Proxy v0.13.10.01 Ether0.0041186323.10000023
0xa99bae8cb70942f9820b3e34e2e85facbbd5559221490e2ae0ac5f1ec9305bc7Batch Exec123456982021-05-01 2:50:01465 days 1 hr ago0x0912634db96388f843cc588a59865ae2a6da1bb3 IN  Furucombo: Proxy v0.13.10.000001 Ether0.0007530
0x22df6912802ae82a3b3ebf3c7e5ac1fb2ae20778603bec6a535cd04196c3f7d9Batch Exec123092262021-04-25 11:37:07470 days 17 hrs ago0x124b138c11b8c270356911865bd0999226849305 IN  Furucombo: Proxy v0.13.10 Ether0.0038249420
0x24211e22d6e224caa2a38de9577b459e10a22933e40acebfcfeada2ced8eab20Batch Exec117297922021-01-26 6:45:05559 days 21 hrs ago0x672d16df7e268b178d25c35d90b902b1ded35140 IN  Furucombo: Proxy v0.13.10 Ether0.0038313268
0x7c41912a6821047a4d01d2842d032da18ee4eb1353e0517bf5dccf453d83e9c7Batch Exec116965342021-01-21 3:56:52565 days 45 mins agoENS Name bitomoon.eth IN  Furucombo: Proxy v0.13.10.02 Ether0.0358761660
0xdfd0036d9d8f133781b59b89e7a3e5e150c527e76f6b3a2f799964493aa2be52Batch Exec116965342021-01-21 3:56:52565 days 45 mins agoENS Name bitomoon.eth IN  Furucombo: Proxy v0.13.10.02 Ether0.0341978550
0x747bde915cd7ba896091d4be119fde612b96ea8472a65eac06716ff3885d1fc9Batch Exec116965342021-01-21 3:56:52565 days 45 mins agoENS Name bitomoon.eth IN  Furucombo: Proxy v0.13.10.01546733 Ether0.009138855
0x6c5f96685a32cbc6aa2ee7c584d95b37b832dbabcf3fc19bc2b2d0ed674566acBatch Exec116965342021-01-21 3:56:52565 days 45 mins agoENS Name bitomoon.eth IN  Furucombo: Proxy v0.13.10.02706783 Ether0.0313773550
0x4ca478265cca4bf91a9f85ab9bb2e720902b197609f5e2361378485411a9d7e1Batch Exec116965312021-01-21 3:56:19565 days 45 mins agoENS Name bitomoon.eth IN  Furucombo: Proxy v0.13.10.01186933 Ether0.0345379379.2
0x4fbec2707ed404496fcd0e6cd84698da4891970d7e2d6fc721bb73322cb466f7Batch Exec116964922021-01-21 3:47:42565 days 54 mins agoENS Name bitomoon.eth IN  Furucombo: Proxy v0.13.10.01546733 Ether0.0221850252.8
0x5f450cc929e6d933b56d3425f9c71774ede71208556672b38ecfd1e56efb3d39Batch Exec116732892021-01-17 14:34:42568 days 14 hrs ago0xae543c8a86cc7d0437687e7778fdb771efe0b322 IN  Furucombo: Proxy v0.13.10 Ether0.0463891640
0xfadebc78038ea2a7f58c3ff9c336627d03614c58e01a0cc90c4d7784d2701ce8Batch Exec116719452021-01-17 9:35:34568 days 19 hrs agoENS Name ethoswallet.eth IN  Furucombo: Proxy v0.13.10.01208445 Ether0.0023534423.57947691
0x9a05de0cb320904044593353b07e7bb224c4db70466c87bebdf06a506a5a83ecBatch Exec116445712021-01-13 4:49:49572 days 23 hrs ago0xba1c8672bc10b6bc7c8b0688a35200e5b376551c IN  Furucombo: Proxy v0.13.10 Ether0.0396383139
0xb68f2f494044ccde59150401e67493f54e70e71fa30e0013ce98bc56cc37e9d5Batch Exec116429682021-01-12 22:43:21573 days 5 hrs ago0xca1136f0ba8a996e49655a3429ed8b0c623945fd IN  Furucombo: Proxy v0.13.10 Ether0.0042219550
0x26792f2f785ab4e1ba01ca4bc2282af1e34ab307475edea5c2d764cf1e35c275Batch Exec116429682021-01-12 22:43:21573 days 5 hrs ago0xca1136f0ba8a996e49655a3429ed8b0c623945fd IN  Furucombo: Proxy v0.13.10 Ether0.0083955640
0xfc0e8a6c9f1ae988a716f7cff19fd976f1067b238d12fb0fe272f8b3222ab3f8Batch Exec116429472021-01-12 22:38:21573 days 6 hrs ago0xab17a98b538ce9552f228421b57705b01b38750a IN  Furucombo: Proxy v0.13.10 Ether0.0047882440
0x38cf766f19e91cdee90a94698aff2f9a447b9f785438ba75827222387d955d0aBatch Exec116424852021-01-12 20:59:13573 days 7 hrs ago0x0e00ee62262f9efa8b7f344f951d14db08b5cff4 IN  Furucombo: Proxy v0.13.10.03610741 Ether0.018947241
0x42a7e50921019ead0cc3a67eb67187b11342a09092496612edbff488e789a557Batch Exec116414042021-01-12 17:07:30573 days 11 hrs ago0x6d0294a8d6302d8ff668420f331b06f99de804fc IN  Furucombo: Proxy v0.13.10.79874 Ether0.0197972351
0x8164dbccabef43a5abd35efff7331cfee2ff1afed17f6e410ede8eaba2192c53Batch Exec116410862021-01-12 16:02:25573 days 12 hrs ago0xfa457c009641f6041eb23a5ae3547bd51b756958 IN  Furucombo: Proxy v0.13.10.01912 Ether0.0040299745
0x9e6f4f79e13d5eee19d348a2fcdfd3431567f96e6d418ad4c79977fbb4c82197Batch Exec116405492021-01-12 14:09:47573 days 14 hrs ago0x7893b13e58310cdac183e5ba95774405ce373f83 IN  Furucombo: Proxy v0.13.10 Ether0.07630588108
0x97c1b9ee63f1ad291ac04aa41e39cfb68f37eba4d6e11bf5db54d7798cd2f190Batch Exec116404212021-01-12 13:42:05573 days 14 hrs ago0x16181a87921f0c5bfa86673c39d2cf1873a3fd67 IN  Furucombo: Proxy v0.13.10 Ether0.0242507102
[ Download CSV Export 

OVERVIEW

Furucombo Proxy v0.13.1

Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x84cd6077fb22ac0a2d9b1d4775e884cc7c559e1d1c925752b5c3b7749ba266c6123525352021-05-02 4:00:35464 days 41 mins ago Furucombo: Proxy v0.13.10x0d0d8c59922427ae41b710347502915e86c13cf00.03617714 Ether
0xc2e9cc66fc0ed329385bb4eda320caff334039b0887a2922e68a2a00b7b524a2123518622021-05-02 1:31:43464 days 3 hrs ago Furucombo: Proxy v0.13.1 Uniswap V2: Router 20.01 Ether
0x7c41912a6821047a4d01d2842d032da18ee4eb1353e0517bf5dccf453d83e9c7116965342021-01-21 3:56:52565 days 45 mins ago Furucombo: Proxy v0.13.1 1inch.exchange0.01 Ether
0x7c41912a6821047a4d01d2842d032da18ee4eb1353e0517bf5dccf453d83e9c7116965342021-01-21 3:56:52565 days 45 mins ago Furucombo: Proxy v0.13.1 Uniswap V2: Router 20.01 Ether
0xdfd0036d9d8f133781b59b89e7a3e5e150c527e76f6b3a2f799964493aa2be52116965342021-01-21 3:56:52565 days 45 mins ago Furucombo: Proxy v0.13.1 1inch.exchange0.01 Ether
0xdfd0036d9d8f133781b59b89e7a3e5e150c527e76f6b3a2f799964493aa2be52116965342021-01-21 3:56:52565 days 45 mins ago Furucombo: Proxy v0.13.1 Uniswap V2: Router 20.01 Ether
0x747bde915cd7ba896091d4be119fde612b96ea8472a65eac06716ff3885d1fc9116965342021-01-21 3:56:52565 days 45 mins ago Furucombo: Proxy v0.13.1 Uniswap V2: Router 20.01546733 Ether
0x6c5f96685a32cbc6aa2ee7c584d95b37b832dbabcf3fc19bc2b2d0ed674566ac116965342021-01-21 3:56:52565 days 45 mins ago Furucombo: Proxy v0.13.1 1inch.exchange0.0116005 Ether
0x6c5f96685a32cbc6aa2ee7c584d95b37b832dbabcf3fc19bc2b2d0ed674566ac116965342021-01-21 3:56:52565 days 45 mins ago Furucombo: Proxy v0.13.1 Uniswap V2: Router 20.01546733 Ether
0x4ca478265cca4bf91a9f85ab9bb2e720902b197609f5e2361378485411a9d7e1116965312021-01-21 3:56:19565 days 45 mins ago Furucombo: Proxy v0.13.1 1inch.exchange0.01186933 Ether
0x4fbec2707ed404496fcd0e6cd84698da4891970d7e2d6fc721bb73322cb466f7116964922021-01-21 3:47:42565 days 54 mins ago Furucombo: Proxy v0.13.1 1inch.exchange0.01546733 Ether
0xfadebc78038ea2a7f58c3ff9c336627d03614c58e01a0cc90c4d7784d2701ce8116719452021-01-17 9:35:34568 days 19 hrs ago Furucombo: Proxy v0.13.1 Uniswap V2: Router 20.01208445 Ether
0x38cf766f19e91cdee90a94698aff2f9a447b9f785438ba75827222387d955d0a116424852021-01-12 20:59:13573 days 7 hrs ago Furucombo: Proxy v0.13.1 1inch.exchange0.03610741 Ether
0x42a7e50921019ead0cc3a67eb67187b11342a09092496612edbff488e789a557116414042021-01-12 17:07:30573 days 11 hrs ago Furucombo: Proxy v0.13.10x6d0294a8d6302d8ff668420f331b06f99de804fc0.00235428 Ether
0x42a7e50921019ead0cc3a67eb67187b11342a09092496612edbff488e789a557116414042021-01-12 17:07:30573 days 11 hrs ago Uniswap V2: Router 2 Furucombo: Proxy v0.13.10.00235428 Ether
0x42a7e50921019ead0cc3a67eb67187b11342a09092496612edbff488e789a557116414042021-01-12 17:07:30573 days 11 hrs ago Furucombo: Proxy v0.13.1 Uniswap V2: Router 20.39874 Ether
0x42a7e50921019ead0cc3a67eb67187b11342a09092496612edbff488e789a557116414042021-01-12 17:07:30573 days 11 hrs ago Furucombo: Proxy v0.13.1 Uniswap V2: Router 20.4 Ether
0x8164dbccabef43a5abd35efff7331cfee2ff1afed17f6e410ede8eaba2192c53116410862021-01-12 16:02:25573 days 12 hrs ago Furucombo: Proxy v0.13.1 Uniswap V2: Router 20.01912 Ether
0x9e6f4f79e13d5eee19d348a2fcdfd3431567f96e6d418ad4c79977fbb4c82197116405492021-01-12 14:09:47573 days 14 hrs ago Furucombo: Proxy v0.13.10x7893b13e58310cdac183e5ba95774405ce373f8345.93601841 Ether
0x9e6f4f79e13d5eee19d348a2fcdfd3431567f96e6d418ad4c79977fbb4c82197116405492021-01-12 14:09:47573 days 14 hrs ago Uniswap V2: Router 2 Furucombo: Proxy v0.13.10.05701762 Ether
0x9e6f4f79e13d5eee19d348a2fcdfd3431567f96e6d418ad4c79977fbb4c82197116405492021-01-12 14:09:47573 days 14 hrs ago Furucombo: Proxy v0.13.1 Uniswap V2: Router 211.02099921 Ether
0x9e6f4f79e13d5eee19d348a2fcdfd3431567f96e6d418ad4c79977fbb4c82197116405492021-01-12 14:09:47573 days 14 hrs ago DSProxy #191,171 Furucombo: Proxy v0.13.156.9 Ether
0xaa9371c1dcc8070259a560bca96857f07f76b71c217b4b1d32ee198a2830f082116403722021-01-12 13:27:36573 days 15 hrs ago Furucombo: Proxy v0.13.10x66248fa96332f35123b59a0fd84f34b52b34128e0.00020769 Ether
0xaa9371c1dcc8070259a560bca96857f07f76b71c217b4b1d32ee198a2830f082116403722021-01-12 13:27:36573 days 15 hrs ago Uniswap V2: Router 2 Furucombo: Proxy v0.13.10.00020769 Ether
0xaa9371c1dcc8070259a560bca96857f07f76b71c217b4b1d32ee198a2830f082116403722021-01-12 13:27:36573 days 15 hrs ago Furucombo: Proxy v0.13.1 Uniswap V2: Router 20.05067 Ether
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Proxy

Compiler Version
v0.5.16+commit.9c3226ce

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2020-12-23
*/

// File: localhost/contracts/Config.sol

pragma solidity ^0.5.0;

contract Config {
    // function signature of "postProcess()"
    bytes4 constant POSTPROCESS_SIG = 0xc2722916;

    // Handler post-process type. Others should not happen now.
    enum HandlerType {Token, Custom, Others}
}

// File: localhost/contracts/lib/LibCache.sol

pragma solidity ^0.5.0;

library LibCache {
    function setAddress(bytes32[] storage _cache, address _input) internal {
        _cache.push(bytes32(uint256(uint160(_input))));
    }

    function set(bytes32[] storage _cache, bytes32 _input) internal {
        _cache.push(_input);
    }

    function setHandlerType(bytes32[] storage _cache, uint256 _input) internal {
        require(_input < uint96(-1), "Invalid Handler Type");
        _cache.push(bytes12(uint96(_input)));
    }

    function setSender(bytes32[] storage _cache, address _input) internal {
        require(_cache.length == 0, "cache not empty");
        setAddress(_cache, _input);
    }

    function getAddress(bytes32[] storage _cache)
        internal
        returns (address ret)
    {
        ret = address(uint160(uint256(peek(_cache))));
        _cache.pop();
    }

    function getSig(bytes32[] storage _cache) internal returns (bytes4 ret) {
        ret = bytes4(peek(_cache));
        _cache.pop();
    }

    function get(bytes32[] storage _cache) internal returns (bytes32 ret) {
        ret = peek(_cache);
        _cache.pop();
    }

    function peek(bytes32[] storage _cache)
        internal
        view
        returns (bytes32 ret)
    {
        require(_cache.length > 0, "cache empty");
        ret = _cache[_cache.length - 1];
    }

    function getSender(bytes32[] storage _cache)
        internal
        returns (address ret)
    {
        require(_cache.length > 0, "cache empty");
        ret = address(uint160(uint256(_cache[0])));
    }
}

// File: localhost/contracts/Cache.sol

pragma solidity ^0.5.0;


/// @notice A cache structure composed by a bytes32 array
contract Cache {
    using LibCache for bytes32[];

    bytes32[] cache;

    modifier isCacheEmpty() {
        require(cache.length == 0, "Cache not empty");
        _;
    }
}

// File: localhost/contracts/interface/IRegistry.sol

pragma solidity ^0.5.0;


interface IRegistry {
    function isValid(address handler) external view returns (bool result);

    function getInfo(address handler) external view returns (bytes32 info);
}

// File: @openzeppelin/contracts/utils/Address.sol

pragma solidity ^0.5.5;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following 
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @dev Converts an `address` into `address payable`. Note that this is
     * simply a type cast: the actual underlying value is not changed.
     *
     * _Available since v2.4.0._
     */
    function toPayable(address account) internal pure returns (address payable) {
        return address(uint160(account));
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     *
     * _Available since v2.4.0._
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-call-value
        (bool success, ) = recipient.call.value(amount)("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }
}

// File: @openzeppelin/contracts/math/SafeMath.sol

pragma solidity ^0.5.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     *
     * _Available since v2.4.0._
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.5.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol

pragma solidity ^0.5.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: localhost/contracts/Proxy.sol

pragma solidity ^0.5.0;
pragma experimental ABIEncoderV2;






/**
 * @title The entrance of Furucombo
 * @author Ben Huang
 */
contract Proxy is Cache, Config {
    using Address for address;
    using SafeERC20 for IERC20;

    // keccak256 hash of "furucombo.handler.registry"
    // prettier-ignore
    bytes32 private constant HANDLER_REGISTRY = 0x6874162fd62902201ea0f4bf541086067b3b88bd802fac9e150fd2d1db584e19;

    constructor(address registry) public {
        bytes32 slot = HANDLER_REGISTRY;
        assembly {
            sstore(slot, registry)
        }
    }

    /**
     * @notice Direct transfer from EOA should be reverted.
     * @dev Callback function will be handled here.
     */
    function() external payable {
        require(Address.isContract(msg.sender), "Not allowed from EOA");

        // If triggered by a function call, caller should be registered in registry.
        // The function call will then be forwarded to the location registered in
        // registry.
        if (msg.data.length != 0) {
            require(_isValid(msg.sender), "Invalid caller");

            address target =
                address(bytes20(IRegistry(_getRegistry()).getInfo(msg.sender)));
            _exec(target, msg.data);
        }
    }

    /**
     * @notice Combo execution function. Including three phases: pre-process,
     * exection and post-process.
     * @param tos The handlers of combo.
     * @param datas The combo datas.
     */
    function batchExec(address[] memory tos, bytes[] memory datas)
        public
        payable
    {
        _preProcess();
        _execs(tos, datas);
        _postProcess();
    }

    /**
     * @notice The execution interface for callback function to be executed.
     * @dev This function can only be called through the handler, which makes
     * the caller become proxy itself.
     */
    function execs(address[] memory tos, bytes[] memory datas) public payable {
        require(msg.sender == address(this), "Does not allow external calls");
        require(cache.length > 0, "Cache should be initialized");
        _execs(tos, datas);
    }

    /**
     * @notice The execution phase.
     * @param tos The handlers of combo.
     * @param datas The combo datas.
     */
    function _execs(address[] memory tos, bytes[] memory datas) internal {
        require(
            tos.length == datas.length,
            "Tos and datas length inconsistent"
        );
        for (uint256 i = 0; i < tos.length; i++) {
            _exec(tos[i], datas[i]);
            // Setup the process to be triggered in the post-process phase
            _setPostProcess(tos[i]);
        }
    }

    /**
     * @notice The execution of a single cube.
     * @param _to The handler of cube.
     * @param _data The cube execution data.
     */
    function _exec(address _to, bytes memory _data)
        internal
        returns (bytes memory result)
    {
        require(_isValid(_to), "Invalid handler");
        assembly {
            let succeeded := delegatecall(
                sub(gas, 5000),
                _to,
                add(_data, 0x20),
                mload(_data),
                0,
                0
            )
            let size := returndatasize

            result := mload(0x40)
            mstore(
                0x40,
                add(result, and(add(add(size, 0x20), 0x1f), not(0x1f)))
            )
            mstore(result, size)
            returndatacopy(add(result, 0x20), 0, size)

            switch iszero(succeeded)
                case 1 {
                    revert(add(result, 0x20), size)
                }
        }
    }

    /**
     * @notice Setup the post-process.
     * @param _to The handler of post-process.
     */
    function _setPostProcess(address _to) internal {
        // If the cache length equals 1, just skip
        // If the top is a custom post-process, replace it with the handler
        // address.
        require(cache.length > 0, "cache empty");
        if (cache.length == 1) return;
        else if (cache.peek() == bytes32(bytes12(uint96(HandlerType.Custom)))) {
            cache.pop();
            // Check if the handler is already set.
            if (bytes4(cache.peek()) != 0x00000000) cache.setAddress(_to);
            cache.setHandlerType(uint256(HandlerType.Custom));
        }
    }

    /// @notice The pre-process phase.
    function _preProcess() internal isCacheEmpty {
        // Set the sender on the top of cache.
        cache.setSender(msg.sender);
    }

    /// @notice The post-process phase.
    function _postProcess() internal {
        // If the top of cache is HandlerType.Custom (which makes it being zero
        // address when `cache.getAddress()`), get the handler address and execute
        // the handler with it and the post-process function selector.
        // If not, use it as token address and send the token back to user.
        while (cache.length > 1) {
            address addr = cache.getAddress();
            if (addr == address(0)) {
                addr = cache.getAddress();
                _exec(addr, abi.encodeWithSelector(POSTPROCESS_SIG));
            } else {
                uint256 amount = IERC20(addr).balanceOf(address(this));
                if (amount > 0) IERC20(addr).safeTransfer(msg.sender, amount);
            }
        }

        // Balance should also be returned to user
        uint256 amount = address(this).balance;
        if (amount > 0) msg.sender.transfer(amount);

        // Pop the msg.sender
        cache.pop();
    }

    /// @notice Get the registry contract address.
    function _getRegistry() internal view returns (address registry) {
        bytes32 slot = HANDLER_REGISTRY;
        assembly {
            registry := sload(slot)
        }
    }

    /// @notice Check if the handler is valid in registry.
    function _isValid(address handler) internal view returns (bool result) {
        return IRegistry(_getRegistry()).isValid(handler);
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"registry","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"constant":false,"inputs":[{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"bytes[]","name":"datas","type":"bytes[]"}],"name":"batchExec","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"bytes[]","name":"datas","type":"bytes[]"}],"name":"execs","outputs":[],"payable":true,"stateMutability":"payable","type":"function"}]

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

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

000000000000000000000000846f271627b970773b235afb11fe0fcf12206c86

-----Decoded View---------------
Arg [0] : registry (address): 0x846f271627b970773b235afb11fe0fcf12206c86

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000846f271627b970773b235afb11fe0fcf12206c86


Deployed ByteCode Sourcemap

18012:6040:0:-;;;;;;;;;;;;;;;;;;;;;;;18657:30;18676:10;18657:18;:30::i;:::-;18649:63;;;;-1:-1:-1;;;18649:63:0;;;;;;;;;;;;;;;;;18920:8;:20;18916:252;;18965:20;18974:10;18965:8;:20::i;:::-;18957:47;;;;-1:-1:-1;;;18957:47:0;;;;;;;;;19021:14;19081;:12;:14::i;:::-;-1:-1:-1;;;;;19071:33:0;;19105:10;19071:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19071:45:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19071:45:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;19071:45:0;;;;;;;;;19055:63;;19021:97;;19133:23;19139:6;19147:8;;19133:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;19133:5:0;;-1:-1:-1;;;19133:23:0:i;:::-;;18916:252;;18012:6040;19395:187;;;;;;;;;:::i;19805:258::-;;;;;;;;;:::i;3308:619::-;3368:4;3836:20;;3679:66;3876:23;;;;;;:42;;-1:-1:-1;3903:15:0;;;3876:42;3868:51;3308:619;-1:-1:-1;;;;3308:619:0:o;23910:139::-;23968:11;24009:14;:12;:14::i;:::-;-1:-1:-1;;;;;23999:33:0;;24033:7;23999:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23999:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23999:42:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;23999:42:0;;;;;;;;;23992:49;23910:139;-1:-1:-1;;23910:139:0:o;23659:183::-;18241:66;23813:11;;23786:49::o;20778:857::-;20862:19;20907:13;20916:3;20907:8;:13::i;:::-;20899:41;;;;-1:-1:-1;;;20899:41:0;;;;;;;;;21164:1;21144;21119:5;21113:12;21089:4;21082:5;21078:16;21056:3;21032:4;21027:3;21023:14;20992:188;21206:14;21252:4;21246:11;21236:21;;21367:4;21363:9;21356:4;21349;21343;21339:15;21335:26;21331:42;21323:6;21319:55;21296:4;21271:118;21418:4;21410:6;21403:20;21474:4;21471:1;21464:4;21456:6;21452:17;21437:42;21509:9;21502:17;21542:1;21537:80;;;;21495:122;;21537:80;21593:4;21586;21578:6;21574:17;21567:31;21495:122;;20960:668;;;;;;:::o;19395:187::-;19507:13;:11;:13::i;:::-;19531:18;19538:3;19543:5;19531:6;:18::i;:::-;19560:14;:12;:14::i;:::-;19395:187;;:::o;19805:258::-;19898:10;19920:4;19898:27;19890:69;;;;-1:-1:-1;;;19890:69:0;;;;;;;;;19993:1;19978:12;19970:56;;;;-1:-1:-1;;;19970:56:0;;;;;;;;;20037:18;20044:3;20049:5;20037:6;:18::i;22405:139::-;2213:5;:12;:17;2205:45;;;;-1:-1:-1;;;2205:45:0;;;;;;;;;22509:27;:5;22525:10;22509:27;:15;:27;:::i;:::-;22405:139::o;20206:412::-;20322:5;:12;20308:3;:10;:26;20286:109;;;;-1:-1:-1;;;20286:109:0;;;;;;;;;20411:9;20406:205;20430:3;:10;20426:1;:14;20406:205;;;20462:23;20468:3;20472:1;20468:6;;;;;;;;;;;;;;20476:5;20482:1;20476:8;;;;;;;;;;;;;;20462:5;:23::i;:::-;;20576;20592:3;20596:1;20592:6;;;;;;;;;;;;;;20576:15;:23::i;:::-;20442:3;;20406:205;;;;20206:412;;:::o;22593:1006::-;22958:5;:12;22973:1;-1:-1:-1;22951:429:0;;;22991:12;23006:18;:5;:16;:18::i;:::-;22991:33;-1:-1:-1;;;;;;23043:18:0;;23039:330;;23089:18;:5;:16;:18::i;:::-;23138:39;;;22:32:-1;6:49;;23138:39:0;;;;;;49:4:-1;25:18;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;23082:25:0;;-1:-1:-1;23126:52:0;;23082:25;;23126:5;:52::i;:::-;;23039:330;;;23236:37;;-1:-1:-1;;;23236:37:0;;23219:14;;-1:-1:-1;;;;;23236:22:0;;;;;:37;;23267:4;;23236:37;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23236:37:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23236:37:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;23236:37:0;;;;;;;;;23219:54;-1:-1:-1;23296:10:0;;23292:61;;23308:45;-1:-1:-1;;;;;23308:25:0;;23334:10;23346:6;23308:45;:25;:45;:::i;:::-;23039:330;;22951:429;;;;23461:21;23497:10;;23493:43;;23509:27;;:10;;:27;;;;;23529:6;;23509:27;;;;23529:6;23509:10;:27;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23509:27:0;23493:43;23580:5;:11;;;;;;;;;;;;;;;;;;;;;;;;22593:1006;:::o;859:172::-;948:13;;:18;940:46;;;;-1:-1:-1;;;940:46:0;;;;;;;;;997:26;1008:6;1016;997:10;:26::i;21749:608::-;21980:1;21965:12;21957:40;;;;-1:-1:-1;;;21957:40:0;;;;;;;;;22012:5;:12;22028:1;22012:17;22008:342;;;22031:7;;22008:342;-1:-1:-1;;;22057:12:0;:5;:10;:12::i;:::-;:60;22053:297;;;22134:5;:11;;;;;;;;;;;;;;;;;;;;;;;;22224:12;:5;:10;:12::i;:::-;-1:-1:-1;;;;;;22217:34:0;;22213:61;;22253:21;:5;22270:3;22253:21;:16;:21;:::i;:::-;22289:49;:5;22318:18;22289:20;:49::i;:::-;21749:608;:::o;1039:187::-;1121:11;1180:12;1185:6;1180:4;:12::i;:::-;1172:21;;1150:45;;1206:6;:12;;;;;;;;;;;;;;;;;;;;;;;;1039:187;;;:::o;14669:176::-;14778:58;;14752:85;;14771:5;;-1:-1:-1;;;14801:23:0;14778:58;;14826:2;;14830:5;;14778:58;;;;;;;;-1:-1:-1;;26:21;;;22:32;6:49;;14778:58:0;;;49:4:-1;25:18;;61:17;;-1:-1;;;;;182:15;-1:-1;;;;;;14778:58:0;;;179:29:-1;;;;160:49;;;14752:18:0;:85::i;404:136::-;27:10:-1;;39:1;23:18;;45:23;;498:33:0;486:46;;;;;;;-1:-1:-1;;;;;506:24:0;;;486:46;;;404:136::o;1520:210::-;1647:13;;1610:11;;1639:41;;;;-1:-1:-1;;;1639:41:0;;;;;;;;;1704:13;;1697:6;;-1:-1:-1;;1704:17:0;;;1697:25;;;;;;;;;;;;;;1691:31;;1520:210;;;:::o;658:193::-;752:19;;;744:52;;;;-1:-1:-1;;;744:52:0;;;;;;;;;27:10:-1;;39:1;23:18;;45:23;;-1:-1;807:36:0;;;;;;;819:23;;;;;-1:-1:-1;;;;;;807:36:0;;;;658:193::o;16708:1114::-;17312:27;17320:5;-1:-1:-1;;;;;17312:25:0;;:27::i;:::-;17304:71;;;;-1:-1:-1;;;17304:71:0;;;;;;;;;17449:12;17463:23;17498:5;-1:-1:-1;;;;;17490:19:0;17510:4;17490:25;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;17448:67:0;;;;17534:7;17526:52;;;;-1:-1:-1;;;17526:52:0;;;;;;;;;17595:17;;:21;17591:224;;17737:10;17726:30;;;;;;;;;;;;;;17718:85;;;;-1:-1:-1;;;17718:85:0;;;;;;;;;16708:1114;;;;:::o;5:130:-1:-;72:20;;97:33;72:20;97:33;;160:707;;277:3;270:4;262:6;258:17;254:27;244:2;;295:1;292;285:12;244:2;332:6;319:20;354:80;369:64;426:6;369:64;;;354:80;;;345:89;;451:5;476:6;469:5;462:21;506:4;498:6;494:17;484:27;;528:4;523:3;519:14;512:21;;581:6;628:3;620:4;612:6;608:17;603:3;599:27;596:36;593:2;;;645:1;642;635:12;593:2;670:1;655:206;680:6;677:1;674:13;655:206;;;738:3;760:37;793:3;781:10;760:37;;;748:50;;-1:-1;821:4;812:14;;;;840;;;;;702:1;695:9;655:206;;;659:14;237:630;;;;;;;;891:693;;1013:3;1006:4;998:6;994:17;990:27;980:2;;1031:1;1028;1021:12;980:2;1068:6;1055:20;1090:85;1105:69;1167:6;1105:69;;1090:85;1203:21;;;1247:4;1235:17;;;;1081:94;;-1:-1;1260:14;;1235:17;1355:1;1340:238;1365:6;1362:1;1359:13;1340:238;;;1448:3;1435:17;1427:6;1423:30;1472:42;1510:3;1498:10;1472:42;;;1460:55;;-1:-1;1538:4;1529:14;;;;1557;;;;;1387:1;1380:9;1340:238;;1592:128;1667:13;;1685:30;1667:13;1685:30;;1727:134;1805:13;;1823:33;1805:13;1823:33;;1869:432;;1966:3;1959:4;1951:6;1947:17;1943:27;1933:2;;1984:1;1981;1974:12;1933:2;2021:6;2008:20;2043:60;2058:44;2095:6;2058:44;;2043:60;2034:69;;2123:6;2116:5;2109:21;2159:4;2151:6;2147:17;2192:4;2185:5;2181:16;2227:3;2218:6;2213:3;2209:16;2206:25;2203:2;;;2244:1;2241;2234:12;2203:2;2254:41;2288:6;2283:3;2278;2254:41;;2450:648;;;2626:2;2614:9;2605:7;2601:23;2597:32;2594:2;;;2642:1;2639;2632:12;2594:2;2677:31;;2728:18;2717:30;;2714:2;;;2760:1;2757;2750:12;2714:2;2780:78;2850:7;2841:6;2830:9;2826:22;2780:78;;;2770:88;;2656:208;2923:2;2912:9;2908:18;2895:32;2947:18;2939:6;2936:30;2933:2;;;2979:1;2976;2969:12;2933:2;2999:83;3074:7;3065:6;3054:9;3050:22;2999:83;;;2989:93;;2874:214;2588:510;;;;;;3105:257;;3217:2;3205:9;3196:7;3192:23;3188:32;3185:2;;;3233:1;3230;3223:12;3185:2;3268:1;3285:61;3338:7;3318:9;3285:61;;3369:263;;3484:2;3472:9;3463:7;3459:23;3455:32;3452:2;;;3500:1;3497;3490:12;3452:2;3535:1;3552:64;3608:7;3588:9;3552:64;;3909:142;4000:45;4039:5;4000:45;;;3995:3;3988:58;3982:69;;;4058:113;4141:24;4159:5;4141:24;;4178:356;;4306:38;4338:5;4306:38;;;4356:88;4437:6;4432:3;4356:88;;;4349:95;;4449:52;4494:6;4489:3;4482:4;4475:5;4471:16;4449:52;;;4513:16;;;;;4286:248;-1:-1;;4286:248;4542:315;;4702:67;4766:2;4761:3;4702:67;;;-1:-1;;;4782:38;;4848:2;4839:12;;4688:169;-1:-1;;4688:169;4866:314;;5026:67;5090:2;5085:3;5026:67;;;-1:-1;;;5106:37;;5171:2;5162:12;;5012:168;-1:-1;;5012:168;5189:332;;5349:67;5413:2;5408:3;5349:67;;;5449:34;5429:55;;5512:2;5503:12;;5335:186;-1:-1;;5335:186;5530:315;;5690:67;5754:2;5749:3;5690:67;;;-1:-1;;;5770:38;;5836:2;5827:12;;5676:169;-1:-1;;5676:169;5854:320;;6014:67;6078:2;6073:3;6014:67;;;-1:-1;;;6094:43;;6165:2;6156:12;;6000:174;-1:-1;;6000:174;6183:320;;6343:67;6407:2;6402:3;6343:67;;;-1:-1;;;6423:43;;6494:2;6485:12;;6329:174;-1:-1;;6329:174;6512:315;;6672:67;6736:2;6731:3;6672:67;;;-1:-1;;;6752:38;;6818:2;6809:12;;6658:169;-1:-1;;6658:169;6836:329;;6996:67;7060:2;7055:3;6996:67;;;7096:31;7076:52;;7156:2;7147:12;;6982:183;-1:-1;;6982:183;7174:370;;7334:67;7398:2;7393:3;7334:67;;;7434:34;7414:55;;-1:-1;;;7498:2;7489:12;;7482:25;7535:2;7526:12;;7320:224;-1:-1;;7320:224;7553:311;;7713:67;7777:2;7772:3;7713:67;;;-1:-1;;;7793:34;;7855:2;7846:12;;7699:165;-1:-1;;7699:165;7873:379;;8033:67;8097:2;8092:3;8033:67;;;8133:34;8113:55;;-1:-1;;;8197:2;8188:12;;8181:34;8243:2;8234:12;;8019:233;-1:-1;;8019:233;8261:327;;8421:67;8485:2;8480:3;8421:67;;;8521:29;8501:50;;8579:2;8570:12;;8407:181;-1:-1;;8407:181;8597:331;;8757:67;8821:2;8816:3;8757:67;;;8857:33;8837:54;;8919:2;8910:12;;8743:185;-1:-1;;8743:185;8936:113;9019:24;9037:5;9019:24;;9056:262;;9200:93;9289:3;9280:6;9200:93;;;9193:100;9181:137;-1:-1;;;9181:137;9325:213;9443:2;9428:18;;9457:71;9432:9;9501:6;9457:71;;9545:229;9671:2;9656:18;;9685:79;9660:9;9737:6;9685:79;;9781:324;9927:2;9912:18;;9941:71;9916:9;9985:6;9941:71;;;10023:72;10091:2;10080:9;10076:18;10067:6;10023:72;;10112:407;10303:2;10317:47;;;10288:18;;10378:131;10288:18;10378:131;;10526:407;10717:2;10731:47;;;10702:18;;10792:131;10702:18;10792:131;;10940:407;11131:2;11145:47;;;11116:18;;11206:131;11116:18;11206:131;;11354:407;11545:2;11559:47;;;11530:18;;11620:131;11530:18;11620:131;;11768:407;11959:2;11973:47;;;11944:18;;12034:131;11944:18;12034:131;;12182:407;12373:2;12387:47;;;12358:18;;12448:131;12358:18;12448:131;;12596:407;12787:2;12801:47;;;12772:18;;12862:131;12772:18;12862:131;;13010:407;13201:2;13215:47;;;13186:18;;13276:131;13186:18;13276:131;;13424:407;13615:2;13629:47;;;13600:18;;13690:131;13600:18;13690:131;;13838:407;14029:2;14043:47;;;14014:18;;14104:131;14014:18;14104:131;;14252:407;14443:2;14457:47;;;14428:18;;14518:131;14428:18;14518:131;;14666:407;14857:2;14871:47;;;14842:18;;14932:131;14842:18;14932:131;;15080:407;15271:2;15285:47;;;15256:18;;15346:131;15256:18;15346:131;;15494:256;15556:2;15550:9;15582:17;;;15657:18;15642:34;;15678:22;;;15639:62;15636:2;;;15714:1;15711;15704:12;15636:2;15730;15723:22;15534:216;;-1:-1;15534:216;15757:304;;15916:18;15908:6;15905:30;15902:2;;;15948:1;15945;15938:12;15902:2;-1:-1;15983:4;15971:17;;;16036:15;;15839:222;16384:317;;16523:18;16515:6;16512:30;16509:2;;;16555:1;16552;16545:12;16509:2;-1:-1;16686:4;16622;16599:17;;;;-1:-1;;16595:33;16676:15;;16446:255;16708:121;16795:12;;16766:63;16837:144;16972:3;16950:31;-1:-1;16950:31;16990:163;17093:19;;;17142:4;17133:14;;17086:67;17161:91;;17223:24;17241:5;17223:24;;17259:85;17325:13;17318:21;;17301:43;17351:72;17413:5;17396:27;17430:121;-1:-1;;;;;17492:54;;17475:76;17637:129;;17724:37;17755:5;17773:121;17852:37;17883:5;17852:37;;18017:145;18098:6;18093:3;18088;18075:30;-1:-1;18154:1;18136:16;;18129:27;18068:94;18171:268;18236:1;18243:101;18257:6;18254:1;18251:13;18243:101;;;18324:11;;;18318:18;18305:11;;;18298:39;18279:2;18272:10;18243:101;;;18359:6;18356:1;18353:13;18350:2;;;-1:-1;;18424:1;18406:16;;18399:27;18220:219;18447:117;18516:24;18534:5;18516:24;;;18509:5;18506:35;18496:2;;18555:1;18552;18545:12;18571:111;18637:21;18652:5;18637:21;;18689:117;18758:24;18776:5;18758:24;

Swarm Source

bzzr://d417f22287b43f76fecc81426a53cb2f75ba11bd4f6524873e52018b329dd4cc
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.

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.