Contract 0x57805e5a227937BAc2B0FdaCaA30413ddac6B8E1 2

 

Contract Overview

Furucombo: Proxy v0.4.1
Balance:
0 Ether

EtherValue:
$0.00

Token:
Txn Hash Method
Block
From
To
Value
0xaa0516f448c47f3e607b428ee3a1be14fa42eee6297786c5f1cdf077eb6300c2Batch Exec127075872021-06-26 4:44:2892 days 19 hrs ago0x6fbc289ac452f91a77eff96fbe802eac5a96e412 IN  Furucombo: Proxy v0.4.10.000219 Ether0.000472864.5
0x029a9b9ba05bc0c1933df8b5b5080d3a2afae9dfedc440ba26152d1f35b52176Batch Exec125772192021-06-05 22:49:31113 days 1 hr ago0x69786abf3d4ffa5088628031f647289312e370ee IN  Furucombo: Proxy v0.4.10.0025 Ether0.00085882511
0xb0adc13f1c8c9c8bd6412bee1dbcf9f28916702c52a14c817b6aef96ee3b7026Batch Exec125560152021-06-02 15:54:01116 days 8 hrs ago0xc96005ca1202efa309bbeed6e330e3555a156a71 IN  Furucombo: Proxy v0.4.10 Ether0.02049300
0xa8bd10339f87e4708b3fd8ac3bf54e7069d6a32b2da401bd4423794fb1d985f3Batch Exec125560152021-06-02 15:54:01116 days 8 hrs ago0xc96005ca1202efa309bbeed6e330e3555a156a71 IN  Furucombo: Proxy v0.4.10 Ether0.0068715465
0xed18972e4da069e3081f9f4511effed28b0825b6afd242f0f5eea100bc885adfTransfer123544382021-05-02 11:20:05147 days 12 hrs ago0x75ff93c1870ae8d147c3071876d7474c2f4d7218 IN  Furucombo: Proxy v0.4.10.00001 Ether0.00046222
0xd3b8d709cba30deb50fc4cacb18f401f90e373c89efcb330f910d5f23e07f01fBatch Exec122140072021-04-10 19:14:37169 days 5 hrs ago0xba1c8672bc10b6bc7c8b0688a35200e5b376551c IN  Furucombo: Proxy v0.4.10 Ether0.01583863179
0x568881a18583bd0d0840498d7c39b38b500578a771fba9434cafc3772f4132a7Batch Exec115417132020-12-28 9:51:14272 days 14 hrs ago0x9b976453daedcb2b39d33f4b962236b19e58c309 IN  Furucombo: Proxy v0.4.10.02 Ether0.0074188846
0x4d10d71919963be3011b9eb416d621ec66034819ef5702dfb7717aaeddd906eaBatch Exec115414412020-12-28 8:53:23272 days 15 hrs ago0xe2abe2706a8bd68fe8ff82dda198e34c84ee5d76 IN  Furucombo: Proxy v0.4.11 Ether0.0276421967
0xac335f800ea3c6fd1179ba816a3caa2be228952c3fe214c77a04755cecffeb90Batch Exec115413902020-12-28 8:42:44272 days 15 hrs ago0x7a5770595e29909c60e04717f44d67ba6979e094 IN  Furucombo: Proxy v0.4.10.1 Ether0.01077927234146.000001459
0xd056f531307f83297f75d71f3dfa433a3a408261e0f5012761ce2e76bb2426f5Batch Exec115413892020-12-28 8:42:37272 days 15 hrs ago0x3a3c7ca8713acf4e9635bacc9b4cbf4410a25f1c IN  Furucombo: Proxy v0.4.10.025 Ether0.00221926953
0xefd7965a972f7865d94782fc2bdc008f03d0b14ce2467ac1219c52e43620dae6Batch Exec115413882020-12-28 8:42:31272 days 15 hrs ago0xd219192e53327b36b96b0792ae5ae639bddb3818 IN  Furucombo: Proxy v0.4.10.02 Ether0.0077414448
0x680f8f189ea6c28e80885336f6512dcfd71d5918af2cd7abe9017233cf57b712Batch Exec115413702020-12-28 8:39:20272 days 15 hrs ago0x959f5694c09d55829792f0b64a8ec50d74a66fa4 IN  Furucombo: Proxy v0.4.10.005011693788075 Ether0.00403120092755.200001751
0xd3fd67329e9c5830f53af91e2d56958187f44ffa150752f70d0731f254c71ea4Batch Exec115413632020-12-28 8:38:07272 days 15 hrs ago0x3d1311343511be21c1f75f39ce58a74cc2008d07 IN  Furucombo: Proxy v0.4.10.1 Ether0.0142122482
0x35a8109e5a3b743eb59b5b9687f3131ab8204aa80e84618e39fef860c624d5cdBatch Exec115413442020-12-28 8:32:52272 days 15 hrs ago0xe52ff879ae3be55c41d4801f45252450d106bb40 IN  Furucombo: Proxy v0.4.10.415 Ether0.00196918941
0x85004bce33f49ac546b8239f981867668720d7d6a64c3e86249f2227547ff90eBatch Exec115413342020-12-28 8:31:51272 days 15 hrs ago0x1dd59350ed9b8202555b5e15933abf747443db9e IN  Furucombo: Proxy v0.4.10.57505 Ether0.01856374332649.350001532
0xa2724d586bb19cd540a9750019154c04b275a6043908f9042b61397cf03f2536Batch Exec115413042020-12-28 8:27:12272 days 15 hrs ago0x09f9e2d056247b37c8a0f8fc28f6c25037ead393 IN  Furucombo: Proxy v0.4.11 Ether0.01406286034160.000001459
0x600bbfdf20faed075e70a3069445d3fb59b0f14103139285cdad1e687e176c7bBatch Exec115412992020-12-28 8:26:11272 days 15 hrs ago0xd99b80616ff7a413910a65c99cae039ad33e4eb8 IN  Furucombo: Proxy v0.4.10.1 Ether0.00830850
0x8e162b8b7db12156ecc34a391c3c748369b996a2bcfb43013b0de0fe934e1fb7Batch Exec115412992020-12-28 8:26:11272 days 15 hrs ago0xce612d91a21203671901142034a76ded9d8591ee IN  Furucombo: Proxy v0.4.10 Ether0.04241812851
0x70fcd880449bfcb7c7d280f4ad1fe81b948d9d7a0f560de9423113009ea5f156Batch Exec115412942020-12-28 8:25:28272 days 15 hrs ago0x79fc8bbaee66b425485b586fc0399380f512026f IN  Furucombo: Proxy v0.4.10.02 Ether0.00901139252
0xaf9dd1e3cc24ce0f49d47d848af1bcbbd043ed58cadb62f300840fe7a89743e0Batch Exec115412672020-12-28 8:20:56272 days 15 hrs ago0x083013b0f583f61e302bc0ce590bc34346e60946 IN  Furucombo: Proxy v0.4.10.1 Ether0.00408144585
0x0f98c36911569b2cec3a7891a9b5ce5e0e88d78e5c519adb67b4b3456d0b3fd6Batch Exec115412632020-12-28 8:20:33272 days 15 hrs agoENS Name nftei.eth IN  Furucombo: Proxy v0.4.118.817755220668292 Ether0.0214087243882.000001459
0xbb22c30dd59acc327ef7986ec4aee1ad6eee81163ba0ad4fee78d44ccfe19f75Batch Exec115412122020-12-28 8:10:23272 days 16 hrs ago0x47aa76ff3c7f4e756ade8c6a843f73d97993c7e8 IN  Furucombo: Proxy v0.4.11 Ether0.01193649623574.000001459
0x8064fd7ead57d18cbeda817f792b0ebb018a186663bb753644fb4625c692a72bBatch Exec115412012020-12-28 8:08:48272 days 16 hrs ago0x4fe33b3755f2e6103f3dd9495013839840e1c0d0 IN  Furucombo: Proxy v0.4.10.001 Ether0.01133347575
0x2fc21cc41f30ff20558078de3524ad5fb72d3ec945c55914da6f23e78c57ce4dBatch Exec115411612020-12-28 8:00:50272 days 16 hrs agoENS Name plumbly.eth IN  Furucombo: Proxy v0.4.10.9981 Ether0.0249457575
0x65e3e7ed003342a81540d404681f0864b3e588dfef4d014586ec766455eb0871Batch Exec115410732020-12-28 7:39:31272 days 16 hrs ago0x9a5571f86ed5badfba9658a505cf1e6f5c83b1a4 IN  Furucombo: Proxy v0.4.15.3 Ether0.01660961294
[ Download CSV Export 

OVERVIEW

Save time, save steps, infinite DeFi combinations. Build your own DeFi legos into one transaction without knowing how to code.

Latest 25 internal transaction
Parent Txn Hash Block From To Value
0xd3b8d709cba30deb50fc4cacb18f401f90e373c89efcb330f910d5f23e07f01f122140072021-04-10 19:14:37169 days 5 hrs ago Furucombo: Proxy v0.4.10xba1c8672bc10b6bc7c8b0688a35200e5b376551c0.056040444707710635 Ether
0xd3b8d709cba30deb50fc4cacb18f401f90e373c89efcb330f910d5f23e07f01f122140072021-04-10 19:14:37169 days 5 hrs ago Uniswap V2: Router 2 Furucombo: Proxy v0.4.10.056040444707710635 Ether
0x568881a18583bd0d0840498d7c39b38b500578a771fba9434cafc3772f4132a7115417132020-12-28 9:51:14272 days 14 hrs ago Furucombo: Proxy v0.4.1 Uniswap V2: Router 20.02 Ether
0x4d10d71919963be3011b9eb416d621ec66034819ef5702dfb7717aaeddd906ea115414412020-12-28 8:53:23272 days 15 hrs ago Furucombo: Proxy v0.4.10xe2abe2706a8bd68fe8ff82dda198e34c84ee5d761 Ether
0x4d10d71919963be3011b9eb416d621ec66034819ef5702dfb7717aaeddd906ea115414412020-12-28 8:53:23272 days 15 hrs ago 1inch.exchange Furucombo: Proxy v0.4.11 Ether
0x4d10d71919963be3011b9eb416d621ec66034819ef5702dfb7717aaeddd906ea115414412020-12-28 8:53:23272 days 15 hrs ago Furucombo: Proxy v0.4.1 1inch.exchange1 Ether
0xac335f800ea3c6fd1179ba816a3caa2be228952c3fe214c77a04755cecffeb90115413902020-12-28 8:42:44272 days 15 hrs ago Furucombo: Proxy v0.4.10x7a5770595e29909c60e04717f44d67ba6979e0940.041028279197521113 Ether
0xac335f800ea3c6fd1179ba816a3caa2be228952c3fe214c77a04755cecffeb90115413902020-12-28 8:42:44272 days 15 hrs ago Uniswap: USDC Furucombo: Proxy v0.4.10.041028279197521113 Ether
0xac335f800ea3c6fd1179ba816a3caa2be228952c3fe214c77a04755cecffeb90115413902020-12-28 8:42:44272 days 15 hrs ago Furucombo: Proxy v0.4.1 Uniswap: USDC0.1 Ether
0xefd7965a972f7865d94782fc2bdc008f03d0b14ce2467ac1219c52e43620dae6115413882020-12-28 8:42:31272 days 15 hrs ago Furucombo: Proxy v0.4.1 Uniswap V2: Router 20.02 Ether
0x680f8f189ea6c28e80885336f6512dcfd71d5918af2cd7abe9017233cf57b712115413702020-12-28 8:39:20272 days 15 hrs ago Furucombo: Proxy v0.4.10x132b81fee262686786f72bcf4b69131ff6ffc7b60.005011693788075562 Ether
0xd3fd67329e9c5830f53af91e2d56958187f44ffa150752f70d0731f254c71ea4115413632020-12-28 8:38:07272 days 15 hrs ago Furucombo: Proxy v0.4.1 Uniswap V2: Router 20.1 Ether
0x35a8109e5a3b743eb59b5b9687f3131ab8204aa80e84618e39fef860c624d5cd115413442020-12-28 8:32:52272 days 15 hrs ago Furucombo: Proxy v0.4.10xabdc670b6b76aa300c8382fe5be4add49ff9e3470.415 Ether
0x85004bce33f49ac546b8239f981867668720d7d6a64c3e86249f2227547ff90e115413342020-12-28 8:31:51272 days 15 hrs ago Furucombo: Proxy v0.4.10x1dd59350ed9b8202555b5e15933abf747443db9e0.000596026188401666 Ether
0x85004bce33f49ac546b8239f981867668720d7d6a64c3e86249f2227547ff90e115413342020-12-28 8:31:51272 days 15 hrs ago Uniswap V2: Router 2 Furucombo: Proxy v0.4.10.000596026188401666 Ether
0x85004bce33f49ac546b8239f981867668720d7d6a64c3e86249f2227547ff90e115413342020-12-28 8:31:51272 days 15 hrs ago Furucombo: Proxy v0.4.1 Uniswap V2: Router 20.28705 Ether
0x85004bce33f49ac546b8239f981867668720d7d6a64c3e86249f2227547ff90e115413342020-12-28 8:31:51272 days 15 hrs ago Furucombo: Proxy v0.4.1 Uniswap V2: Router 20.288 Ether
0xa2724d586bb19cd540a9750019154c04b275a6043908f9042b61397cf03f2536115413042020-12-28 8:27:12272 days 15 hrs ago Furucombo: Proxy v0.4.1 Uniswap V2: Router 21 Ether
0x600bbfdf20faed075e70a3069445d3fb59b0f14103139285cdad1e687e176c7b115412992020-12-28 8:26:11272 days 15 hrs ago Furucombo: Proxy v0.4.1 Uniswap V2: Router 20.1 Ether
0x8e162b8b7db12156ecc34a391c3c748369b996a2bcfb43013b0de0fe934e1fb7115412992020-12-28 8:26:11272 days 15 hrs ago Furucombo: Proxy v0.4.10xce612d91a21203671901142034a76ded9d8591ee0.121864244995210804 Ether
0x8e162b8b7db12156ecc34a391c3c748369b996a2bcfb43013b0de0fe934e1fb7115412992020-12-28 8:26:11272 days 15 hrs ago Furucombo: Proxy v0.4.1 DSProxy #159,65313.5 Ether
0x8e162b8b7db12156ecc34a391c3c748369b996a2bcfb43013b0de0fe934e1fb7115412992020-12-28 8:26:11272 days 15 hrs ago 1inch.exchange Furucombo: Proxy v0.4.113.621864244995210804 Ether
0x70fcd880449bfcb7c7d280f4ad1fe81b948d9d7a0f560de9423113009ea5f156115412942020-12-28 8:25:28272 days 15 hrs ago Furucombo: Proxy v0.4.1 Uniswap V2: Router 20.02 Ether
0xaf9dd1e3cc24ce0f49d47d848af1bcbbd043ed58cadb62f300840fe7a89743e0115412672020-12-28 8:20:56272 days 15 hrs ago Furucombo: Proxy v0.4.10xed28146d8894f507ea8d5a3b18dd3287d979959f0.1 Ether
0x0f98c36911569b2cec3a7891a9b5ce5e0e88d78e5c519adb67b4b3456d0b3fd6115412632020-12-28 8:20:33272 days 15 hrs ago Furucombo: Proxy v0.4.1 Uniswap V2: Router 218.817755220668292388 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-06-17
*/

// 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"
    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");
        _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 is empty, 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)

000000000000000000000000af1134a479c0d3ecae95cec4490b97305ac17970

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

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000af1134a479c0d3ecae95cec4490b97305ac17970


Deployed ByteCode Sourcemap

18020:5957:0:-;;;;;;;;;;;;;;;;;;;;;;;18641:30;18660:10;18641:18;:30::i;:::-;18633:63;;;;-1:-1:-1;;;18633:63:0;;;;;;;;;;;;;;;;;18904:8;:20;18900:267;;18949:20;18958:10;18949:8;:20::i;:::-;18941:47;;;;-1:-1:-1;;;18941:47:0;;;;;;;;;19005:14;19066;:12;:14::i;:::-;-1:-1:-1;;;;;19056:33:0;;19090:10;19056:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19056:45:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19056: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;19056:45:0;;;;;;;;;19022:95;;19005:112;;19132:23;19138:6;19146:8;;19132:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;19132:5:0;;-1:-1:-1;;;19132:23:0:i;:::-;;18900:267;;18020:5957;19394:187;;;;;;;;;:::i;19804:191::-;;;;;;;;;:::i;3314:619::-;3374:4;3842:20;;3685:66;3882:23;;;;;;:42;;-1:-1:-1;3909:15:0;;;3882:42;3874:51;3314:619;-1:-1:-1;;;;3314:619:0:o;23835:139::-;23893:11;23934:14;:12;:14::i;:::-;-1:-1:-1;;;;;23924:33:0;;23958:7;23924:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23924:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23924: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;23924:42:0;;;;;;;;;23917:49;23835:139;-1:-1:-1;;23835:139:0:o;23584:183::-;18225:66;23738:11;;23711:49::o;20710:857::-;20794:19;20839:13;20848:3;20839:8;:13::i;:::-;20831:41;;;;-1:-1:-1;;;20831:41:0;;;;;;;;;21096:1;21076;21051:5;21045:12;21021:4;21014:5;21010:16;20988:3;20964:4;20959:3;20955:14;20924:188;21138:14;21184:4;21178:11;21168:21;;21299:4;21295:9;21288:4;21281;21275;21271:15;21267:26;21263:42;21255:6;21251:55;21228:4;21203:118;21350:4;21342:6;21335:20;21406:4;21403:1;21396:4;21388:6;21384:17;21369:42;21441:9;21434:17;21474:1;21469:80;;;;21427:122;;21469:80;21525:4;21518;21510:6;21506:17;21499:31;21427:122;;20892:668;;;;;;:::o;19394:187::-;19506:13;:11;:13::i;:::-;19530:18;19537:3;19542:5;19530:6;:18::i;:::-;19559:14;:12;:14::i;:::-;19394:187;;:::o;19804:191::-;19897:10;19919:4;19897:27;19889:69;;;;-1:-1:-1;;;19889:69:0;;;;;;;;;19969:18;19976:3;19981:5;19969:6;:18::i;22330:139::-;2219:5;:12;:17;2211:45;;;;-1:-1:-1;;;2211:45:0;;;;;;;;;22434:27;:5;22450:10;22434:27;:15;:27;:::i;:::-;22330:139::o;20138:412::-;20254:5;:12;20240:3;:10;:26;20218:109;;;;-1:-1:-1;;;20218:109:0;;;;;;;;;20343:9;20338:205;20362:3;:10;20358:1;:14;20338:205;;;20394:23;20400:3;20404:1;20400:6;;;;;;;;;;;;;;20408:5;20414:1;20408:8;;;;;;;;;;;;;;20394:5;:23::i;:::-;;20508;20524:3;20528:1;20524:6;;;;;;;;;;;;;;20508:15;:23::i;:::-;20374:3;;20338:205;;;;20138:412;;:::o;22518:1006::-;22883:5;:12;22898:1;-1:-1:-1;22876:429:0;;;22916:12;22931:18;:5;:16;:18::i;:::-;22916:33;-1:-1:-1;;;;;;22968:18:0;;22964:330;;23014:18;:5;:16;:18::i;:::-;23063:39;;;22:32:-1;6:49;;23063:39:0;;;;;;49:4:-1;25:18;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;23007:25:0;;-1:-1:-1;23051:52:0;;23007:25;;23051:5;:52::i;:::-;;22964:330;;;23161:37;;-1:-1:-1;;;23161:37:0;;23144:14;;-1:-1:-1;;;;;23161:22:0;;;;;:37;;23192:4;;23161:37;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23161:37:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23161: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;23161:37:0;;;;;;;;;23144:54;-1:-1:-1;23221:10:0;;23217:61;;23233:45;-1:-1:-1;;;;;23233:25:0;;23259:10;23271:6;23233:45;:25;:45;:::i;:::-;22964:330;;22876:429;;;;23386:21;23422:10;;23418:43;;23434:27;;:10;;:27;;;;;23454:6;;23434:27;;;;23454:6;23434:10;:27;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23434:27:0;23418:43;23505:5;:11;;;;;;;;;;;;;;;;;;;;;;;;22518:1006;:::o;863:172::-;952:13;;:18;944:46;;;;-1:-1:-1;;;944:46:0;;;;;;;;;1001:26;1012:6;1020;1001:10;:26::i;21681:601::-;21905:1;21890:12;21882:40;;;;-1:-1:-1;;;21882:40:0;;;;;;;;;21937:5;:12;21953:1;21937:17;21933:342;;;21956:7;;21933:342;-1:-1:-1;;;21982:12:0;:5;:10;:12::i;:::-;:60;21978:297;;;22059:5;:11;;;;;;;;;;;;;;;;;;;;;;;;22149:12;:5;:10;:12::i;:::-;-1:-1:-1;;;;;;22142:34:0;;22138:61;;22178:21;:5;22195:3;22178:21;:16;:21;:::i;:::-;22214:49;:5;22243:18;22214:20;:49::i;:::-;21681:601;:::o;1043:187::-;1125:11;1184:12;1189:6;1184:4;:12::i;:::-;1176:21;;1154:45;;1210:6;:12;;;;;;;;;;;;;;;;;;;;;;;;1043:187;;;:::o;14675:176::-;14784:58;;14758:85;;14777:5;;-1:-1:-1;;;14807:23:0;14784:58;;14832:2;;14836:5;;14784:58;;;;;;;;-1:-1:-1;;26:21;;;22:32;6:49;;14784:58:0;;;49:4:-1;25:18;;61:17;;-1:-1;;;;;182:15;-1:-1;;;;;;14784:58:0;;;179:29:-1;;;;160:49;;;14758:18:0;:85::i;408:136::-;27:10:-1;;39:1;23:18;;45:23;;502:33:0;490:46;;;;;;;-1:-1:-1;;;;;510:24:0;;;490:46;;;408:136::o;1524:210::-;1651:13;;1614:11;;1643:41;;;;-1:-1:-1;;;1643:41:0;;;;;;;;;1708:13;;1701:6;;-1:-1:-1;;1708:17:0;;;1701:25;;;;;;;;;;;;;;1695:31;;1524:210;;;:::o;662:193::-;756:19;;;748:52;;;;-1:-1:-1;;;748:52:0;;;;;;;;;27:10:-1;;39:1;23:18;;45:23;;-1:-1;811:36:0;;;;;;;823:23;;;;;-1:-1:-1;;;;;;811:36:0;;;;662:193::o;16714:1114::-;17318:27;17326:5;-1:-1:-1;;;;;17318:25:0;;:27::i;:::-;17310:71;;;;-1:-1:-1;;;17310:71:0;;;;;;;;;17455:12;17469:23;17504:5;-1:-1:-1;;;;;17496:19:0;17516:4;17496: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;;17454:67:0;;;;17540:7;17532:52;;;;-1:-1:-1;;;17532:52:0;;;;;;;;;17601:17;;:21;17597:224;;17743:10;17732:30;;;;;;;;;;;;;;17724:85;;;;-1:-1:-1;;;17724:85:0;;;;;;;;;16714: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:331;;8421:67;8485:2;8480:3;8421:67;;;8521:33;8501:54;;8583:2;8574:12;;8407:185;-1:-1;;8407:185;8600:113;8683:24;8701:5;8683:24;;8720:262;;8864:93;8953:3;8944:6;8864:93;;;8857:100;8845:137;-1:-1;;;8845:137;8989:213;9107:2;9092:18;;9121:71;9096:9;9165:6;9121:71;;9209:229;9335:2;9320:18;;9349:79;9324:9;9401:6;9349:79;;9445:324;9591:2;9576:18;;9605:71;9580:9;9649:6;9605:71;;;9687:72;9755:2;9744:9;9740:18;9731:6;9687:72;;9776:407;9967:2;9981:47;;;9952:18;;10042:131;9952:18;10042:131;;10190:407;10381:2;10395:47;;;10366:18;;10456:131;10366:18;10456:131;;10604:407;10795:2;10809:47;;;10780:18;;10870:131;10780:18;10870:131;;11018:407;11209:2;11223:47;;;11194:18;;11284:131;11194:18;11284:131;;11432:407;11623:2;11637:47;;;11608:18;;11698:131;11608:18;11698:131;;11846:407;12037:2;12051:47;;;12022:18;;12112:131;12022:18;12112:131;;12260:407;12451:2;12465:47;;;12436:18;;12526:131;12436:18;12526:131;;12674:407;12865:2;12879:47;;;12850:18;;12940:131;12850:18;12940:131;;13088:407;13279:2;13293:47;;;13264:18;;13354:131;13264:18;13354:131;;13502:407;13693:2;13707:47;;;13678:18;;13768:131;13678:18;13768:131;;13916:407;14107:2;14121:47;;;14092:18;;14182:131;14092:18;14182:131;;14330:407;14521:2;14535:47;;;14506:18;;14596:131;14506:18;14596:131;;14744:256;14806:2;14800:9;14832:17;;;14907:18;14892:34;;14928:22;;;14889:62;14886:2;;;14964:1;14961;14954:12;14886:2;14980;14973:22;14784:216;;-1:-1;14784:216;15007:304;;15166:18;15158:6;15155:30;15152:2;;;15198:1;15195;15188:12;15152:2;-1:-1;15233:4;15221:17;;;15286:15;;15089:222;15634:317;;15773:18;15765:6;15762:30;15759:2;;;15805:1;15802;15795:12;15759:2;-1:-1;15936:4;15872;15849:17;;;;-1:-1;;15845:33;15926:15;;15696:255;15958:121;16045:12;;16016:63;16087:144;16222:3;16200:31;-1:-1;16200:31;16240:163;16343:19;;;16392:4;16383:14;;16336:67;16411:91;;16473:24;16491:5;16473:24;;16509:85;16575:13;16568:21;;16551:43;16601:72;16663:5;16646:27;16680:121;-1:-1;;;;;16742:54;;16725:76;16887:129;;16974:37;17005:5;17023:121;17102:37;17133:5;17102:37;;17267:145;17348:6;17343:3;17338;17325:30;-1:-1;17404:1;17386:16;;17379:27;17318:94;17421:268;17486:1;17493:101;17507:6;17504:1;17501:13;17493:101;;;17574:11;;;17568:18;17555:11;;;17548:39;17529:2;17522:10;17493:101;;;17609:6;17606:1;17603:13;17600:2;;;-1:-1;;17674:1;17656:16;;17649:27;17470:219;17697:117;17766:24;17784:5;17766:24;;;17759:5;17756:35;17746:2;;17805:1;17802;17795:12;17821:111;17887:21;17902:5;17887:21;;17939:117;18008:24;18026:5;18008:24;

Swarm Source

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