Contract 0xA3dfF6ae0F73f0970E31Da63B3736F7D3CEF683e

 

Contract Overview

DODO: DS Proxy V2
Balance:
0 MATIC

MATIC Value:
$0.00

Token:
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x5d654a227b20832e29b1ba9e4b98a9503a2299e1115250d0147c893b8d175cf4Create DODO Stab...365512002022-12-07 20:56:381 day 23 hrs ago0xf773f046c359e541cf7c9b77c66f6d512434e69f IN  DODO: DS Proxy V20 MATIC0.02475115658 42.68000045
0x28130e2fe06502c32dbbc1c22f537a47b52c221f59790b2974042b7c5fea5167Create DODO Stab...364083902022-12-04 8:48:105 days 11 hrs ago0x6866c58c9095406df06d810e7fb28520aadf11da IN  DODO: DS Proxy V20 MATIC0.018467910029 30.000000048
0x9292a6693e646fd4f1190b28c4896e2c319d7f41dac0019c06d524acb934d0e2Create DODO Stab...363514262022-12-02 22:42:266 days 21 hrs ago0x5af0c273174f6159bbf9aafc0fbb9eb7b7f8831d IN  DODO: DS Proxy V21.007927119998479 MATIC0.000051941737 1.134000025
0x444253602662e02052ec6e178d4b25b42533686e136bf3998bca933e1afff274Create DODO Stab...363475342022-12-02 20:24:117 days 6 mins ago0x516408065a6814d84daa7d58b4a70b79dea8cd4e IN  DODO: DS Proxy V20 MATIC0.01879583290430.000132324
0x43d32aea1f2b8318362444af6d09a3ff8a5943d4ad3350f48eaa02675146d6eaCreate DODO Stab...359951352022-11-24 5:02:0215 days 15 hrs ago0x7ad0bd489e1920aa540b084586fb6cbb952ec3ce IN  DODO: DS Proxy V20 MATIC0.031627350
0x8dabb3a3166e65fc5e356099c466663553a23424577b351274a0ae30b23a78b2Create DODO Stab...355846892022-11-14 5:56:3025 days 14 hrs ago0x46fada227785b2b231cb8252d61fc5e3b144b9ae IN  DODO: DS Proxy V20 MATIC0.019950480446 32.785573456
0x966ca593fef811a412793c3bb8081efa04fd6ba01b8d88f7b8e19215a2c45935Create DODO Stab...355587302022-11-13 14:54:4326 days 5 hrs ago0x46fada227785b2b231cb8252d61fc5e3b144b9ae IN  DODO: DS Proxy V29.455795909620203 MATIC0.02516125914 40.158678118
0x858588eba222d8c0295d9ba0f768c2c316778d1c24f5e32c9a7284d98fa20a60Create DODO Stab...345047062022-10-18 17:30:3952 days 3 hrs ago0xa6011275355935e0a637a2a7f9ee685ad77e6dc0 IN  DODO: DS Proxy V20.004 MATIC0.088167554283 142.918249343
0x74ee90ac3e6c2a7dbb6845279d1284d645a93cdb48c98eb7c03e53d1fdf3a496Create DODO Stab...343452102022-10-14 19:11:2656 days 1 hr ago0xb8312c70587ab6326c3a1c91840ee38390502399 IN  DODO: DS Proxy V20 MATIC0.096903489223 156.368586091
0x9bdef756f170ebea9f44a361d805035fccbfa41bd364ad81cccbe37bf2a537d4Create DODO Stab...343442532022-10-14 18:38:0856 days 1 hr ago0xb8312c70587ab6326c3a1c91840ee38390502399 IN  DODO: DS Proxy V20 MATIC0.120752978046 194.023076602
0x3a50ed1675fc34b1ac7316b1e85a3ad4d06f2e44900fd050321d1bc516e3e58bCreate DODO Stab...343441002022-10-14 18:32:5256 days 1 hr ago0xb8312c70587ab6326c3a1c91840ee38390502399 IN  DODO: DS Proxy V20 MATIC0.209570308141 334.149119452
0x603978cfd603f67ae4edf91fef6ee76a8742ae49230396c71093ff107ee2dd03Create DODO Stab...343433862022-10-14 18:08:2056 days 2 hrs ago0xb8312c70587ab6326c3a1c91840ee38390502399 IN  DODO: DS Proxy V20 MATIC0.138503804986 222.548983512
0xe13aea9eed72b191e8fce37c705f3d01bcfaec46d2fab3b2c42d6034a0e9180bCreate DODO Stab...343102522022-10-13 22:49:3956 days 21 hrs ago0xb8312c70587ab6326c3a1c91840ee38390502399 IN  DODO: DS Proxy V20 MATIC0.020751562746 33.320000042
0xcc5fbb7a1076b1468c78c5f3012aae839d7a460314b6883999f29de1cf1cd190Create DODO Stab...343101442022-10-13 22:45:5956 days 21 hrs ago0xb8312c70587ab6326c3a1c91840ee38390502399 IN  DODO: DS Proxy V20 MATIC0.018157200007 30.000000013
0x96df42e41d64e5cbd6234fcd345a8e12899db5ca9a2b36c39dde2f7e950426beCreate DODO Stab...339149792022-10-04 9:34:2566 days 10 hrs ago0x18eeaaecbc76611f6be8bd99d30dfa4f68289584 IN  DODO: DS Proxy V20 MATIC0.01840370831
0x41cc8fc8f43623b1b5b20c440234de138cc8c766a187d795f389fdbc8ab18681Create DODO Stab...339107382022-10-04 7:08:0466 days 13 hrs ago0x18eeaaecbc76611f6be8bd99d30dfa4f68289584 IN  DODO: DS Proxy V20 MATIC0.0194642831
0x26d726eb2efe8dfed7470603a1457993400ac330a9eaf600616c970a6b2475dfCreate DODO Stab...338878812022-10-03 17:59:0067 days 2 hrs ago0x0d6075398cc1b2fcd97b418ce80ad3633a747c9f IN  DODO: DS Proxy V20.00001 MATIC0.019367164538 30.555000013
0x046eb44537cf8c0108229bb8f6ef05976ccf5c93b0b14a07d624fe8208302a8bCreate DODO Stab...338224042022-10-02 4:05:4968 days 16 hrs ago0x3c665671b6cf145c2c50986fec1d0f61e9d255ba IN  DODO: DS Proxy V20 MATIC0.01883556078230.000001247
0xc8960c2a1e7e9161202e9df731e002f988633a7a2faa67eb424e6452753290a9Create DODO Stab...338223832022-10-02 4:05:0368 days 16 hrs ago0x3c665671b6cf145c2c50986fec1d0f61e9d255ba IN  DODO: DS Proxy V20 MATIC0.01907682079830.000001256
0xd131b7384e58fcc37c2f1ecfedb31081a45ee852f745e95411975767898f177fAdd DSP Liquidit...338221952022-10-02 3:56:2768 days 16 hrs ago0x3c665671b6cf145c2c50986fec1d0f61e9d255ba IN  DODO: DS Proxy V20 MATIC0.004798350230.000001255
0xa7147fa514d8bf7df23226526d1dbcd020e01a4e8e8850d563563e9f241f44a3Add DSP Liquidit...337972312022-10-01 13:31:3669 days 6 hrs ago0x3c665671b6cf145c2c50986fec1d0f61e9d255ba IN  DODO: DS Proxy V20 MATIC0.00479799019930.00000125
0x45c1a6b45e8acd9cd8aef3e9c2a94bf3d69779223ff4f2ec50227f3976fd75d9Create DODO Stab...337309482022-09-29 23:01:4370 days 21 hrs ago0x3c665671b6cf145c2c50986fec1d0f61e9d255ba IN  DODO: DS Proxy V20 MATIC0.01994896241330.931501246
0xca1fb462b6b07d2380d464d39b08122884c2db17ac005ff5ef01aa8a342bb603Add DSP Liquidit...337252552022-09-29 19:45:4471 days 45 mins ago0x3c665671b6cf145c2c50986fec1d0f61e9d255ba IN  DODO: DS Proxy V20 MATIC0.00486959464730.450001238
0x387c0b92e6d1b76eed082b97c2887e8b37ce5d599f4fa69e3c3a8d8e017b8ad9Add DSP Liquidit...336175632022-09-27 4:43:5973 days 15 hrs ago0x3c665671b6cf145c2c50986fec1d0f61e9d255ba IN  DODO: DS Proxy V20 MATIC0.00162876006730.000001249
0xceda75f06cec44ea3e57c5002530138b9e6122a668d3dd877beacb89be5a72f1Add DSP Liquidit...336175342022-09-27 4:42:5773 days 15 hrs ago0x3c665671b6cf145c2c50986fec1d0f61e9d255ba IN  DODO: DS Proxy V20 MATIC0.00443643018430.000001248
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x966ca593fef811a412793c3bb8081efa04fd6ba01b8d88f7b8e19215a2c45935355587302022-11-13 14:54:4326 days 5 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token9.455795909620203476 MATIC
0x858588eba222d8c0295d9ba0f768c2c316778d1c24f5e32c9a7284d98fa20a60345047062022-10-18 17:30:3952 days 3 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token0.004 MATIC
0x26d726eb2efe8dfed7470603a1457993400ac330a9eaf600616c970a6b2475df338878812022-10-03 17:59:0067 days 2 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token0.00001 MATIC
0xf84059fda94651b6c024b96efafc015df4bf484c3d282aeaedb2a790ba1cdb03335388002022-09-25 6:48:3075 days 13 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token2 MATIC
0x5ff9cde0e112bac21b23020e866c3ad0a0724b74c0d59fee47efec0b4d8f1efc335357532022-09-25 5:03:4275 days 15 hrs ago DODO: DS Proxy V20x3c665671b6cf145c2c50986fec1d0f61e9d255ba0.000872353600631884 MATIC
0x5ff9cde0e112bac21b23020e866c3ad0a0724b74c0d59fee47efec0b4d8f1efc335357532022-09-25 5:03:4275 days 15 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token5.157127646399368116 MATIC
0xf9960b453a5982051dd83b1eb26478317a7f1f76c1ade3fd6d800ab297c89721335355882022-09-25 4:58:0075 days 15 hrs ago DODO: DS Proxy V20x3c665671b6cf145c2c50986fec1d0f61e9d255ba0.00114948079731042 MATIC
0xf9960b453a5982051dd83b1eb26478317a7f1f76c1ade3fd6d800ab297c89721335355882022-09-25 4:58:0075 days 15 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token5.49885051920268958 MATIC
0x8a5fe8fb10aa06fccc662b592221a83663019c307cafc0159fda8c8685832ba5334990432022-09-24 7:42:2476 days 12 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token2 MATIC
0x95b22e9905949ab3dd046ac1c2e6f55db3ce97e733658949df01342e1bad56b8331104962022-09-14 21:33:5585 days 22 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token1 MATIC
0x068630c1f9ea37ac008ea39bff0277aba3f52432d45648db39d4cce38292c62e328441662022-09-08 11:31:5092 days 8 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token1.5 MATIC
0x5505b57b70152bac6c21213b7c57822711ae71fdb3b7c1af6afa75eb72655047328441182022-09-08 11:30:1092 days 9 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token1 MATIC
0x4c1be2c6a29230869a56c5eca70f6d1a911ff2629f9f82814d58193899fe80f0327629292022-09-06 12:23:5394 days 8 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token1.025979568039640485 MATIC
0xc3e68c702cc4ca52bc36867be32e456ae413fc724d46cb37dc5b05c0cafc333e325225802022-08-31 16:15:28100 days 4 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token1.040870419337418983 MATIC
0x5e853ee8e978c59b3ed7701f54064a04cb98e548a4492c4c62a4517fb0560c48323512222022-08-26 18:23:38105 days 2 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token1.292323597828896355 MATIC
0xbd0b55053107d7aa79e06495951d4bac266e84d803d8ab2c143681a93e563656321806672022-08-22 5:59:08109 days 14 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token0.258184188157139579 MATIC
0xa588cdaaa5e46981a4c9a716dd4c88557d84f6c748db18a7a6526c14ce5dd4ab321516942022-08-21 12:27:47110 days 8 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token30.868929051845417188 MATIC
0xe3719a1d5896651e2651c493959eafb9f7bded7003f26fd18bd16255cc07d1ef321513232022-08-21 12:14:28110 days 8 hrs ago DODO: DS Proxy V20xe8752ac348cfe46ee117fd6b932341777928a1e80.000000219045153312 MATIC
0xe3719a1d5896651e2651c493959eafb9f7bded7003f26fd18bd16255cc07d1ef321513232022-08-21 12:14:28110 days 8 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token14.462064780954846688 MATIC
0x971165f70a872173beea94bd5db2bb598f68ee6221b965f4f5d7d93a5885cbcc321177332022-08-20 16:24:15111 days 4 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token1 MATIC
0xa5090b33474aff43943cd3af3070b0b530d0f344d61653dbd04389a36efa8639318101122022-08-12 15:12:41119 days 5 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token53 MATIC
0xa03d4cbd3f33c41c133ec1a150a81d64a452b791180d0fa8f005886dac31212c317740782022-08-11 16:09:12120 days 4 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token12 MATIC
0x0911aead0a23863ed0d4055cba90fa70345faa2cd0e1e01e9f37c5e38ba6b41a317739772022-08-11 16:03:40120 days 4 hrs ago DODO: DS Proxy V20x2715cfdb3f065b3a7facbd17d097584b053f75ca0.000000000327771518 MATIC
0x0911aead0a23863ed0d4055cba90fa70345faa2cd0e1e01e9f37c5e38ba6b41a317739772022-08-11 16:03:40120 days 4 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token0.999999999672228482 MATIC
0x5316a3fbd2903bd4eb1176426fdc0f2eb3295d88ae477ad92abd3712a220f65c315666652022-08-05 23:51:44125 days 20 hrs ago DODO: DS Proxy V2 Polygon: WMATIC Token1.192384977365605098 MATIC
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
DODODspProxy

Compiler Version
v0.6.9+commit.3e3065ac

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, Apache-2.0 license

Contract Source Code (Solidity)

/**
 *Submitted for verification at polygonscan.com on 2021-06-11
*/

// File: contracts/intf/IDODOApprove.sol

/*

    Copyright 2020 DODO ZOO.
    SPDX-License-Identifier: Apache-2.0

*/

pragma solidity 0.6.9;


interface IDODOApprove {
    function claimTokens(address token,address who,address dest,uint256 amount) external;
    function getDODOProxy() external view returns (address);
}

// File: contracts/lib/InitializableOwnable.sol


/**
 * @title Ownable
 * @author DODO Breeder
 *
 * @notice Ownership related functions
 */
contract InitializableOwnable {
    address public _OWNER_;
    address public _NEW_OWNER_;
    bool internal _INITIALIZED_;

    // ============ Events ============

    event OwnershipTransferPrepared(address indexed previousOwner, address indexed newOwner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    // ============ Modifiers ============

    modifier notInitialized() {
        require(!_INITIALIZED_, "DODO_INITIALIZED");
        _;
    }

    modifier onlyOwner() {
        require(msg.sender == _OWNER_, "NOT_OWNER");
        _;
    }

    // ============ Functions ============

    function initOwner(address newOwner) public notInitialized {
        _INITIALIZED_ = true;
        _OWNER_ = newOwner;
    }

    function transferOwnership(address newOwner) public onlyOwner {
        emit OwnershipTransferPrepared(_OWNER_, newOwner);
        _NEW_OWNER_ = newOwner;
    }

    function claimOwnership() public {
        require(msg.sender == _NEW_OWNER_, "INVALID_CLAIM");
        emit OwnershipTransferred(_OWNER_, _NEW_OWNER_);
        _OWNER_ = _NEW_OWNER_;
        _NEW_OWNER_ = address(0);
    }
}

// File: contracts/SmartRoute/DODOApproveProxy.sol



interface IDODOApproveProxy {
    function isAllowedProxy(address _proxy) external view returns (bool);
    function claimTokens(address token,address who,address dest,uint256 amount) external;
}

/**
 * @title DODOApproveProxy
 * @author DODO Breeder
 *
 * @notice Allow different version dodoproxy to claim from DODOApprove
 */
contract DODOApproveProxy is InitializableOwnable {
    
    // ============ Storage ============
    uint256 private constant _TIMELOCK_DURATION_ = 3 days;
    mapping (address => bool) public _IS_ALLOWED_PROXY_;
    uint256 public _TIMELOCK_;
    address public _PENDING_ADD_DODO_PROXY_;
    address public immutable _DODO_APPROVE_;

    // ============ Modifiers ============
    modifier notLocked() {
        require(
            _TIMELOCK_ <= block.timestamp,
            "SetProxy is timelocked"
        );
        _;
    }

    constructor(address dodoApporve) public {
        _DODO_APPROVE_ = dodoApporve;
    }

    function init(address owner, address[] memory proxies) external {
        initOwner(owner);
        for(uint i = 0; i < proxies.length; i++) 
            _IS_ALLOWED_PROXY_[proxies[i]] = true;
    }

    function unlockAddProxy(address newDodoProxy) public onlyOwner {
        _TIMELOCK_ = block.timestamp + _TIMELOCK_DURATION_;
        _PENDING_ADD_DODO_PROXY_ = newDodoProxy;
    }

    function lockAddProxy() public onlyOwner {
       _PENDING_ADD_DODO_PROXY_ = address(0);
       _TIMELOCK_ = 0;
    }


    function addDODOProxy() external onlyOwner notLocked() {
        _IS_ALLOWED_PROXY_[_PENDING_ADD_DODO_PROXY_] = true;
        lockAddProxy();
    }

    function removeDODOProxy (address oldDodoProxy) public onlyOwner {
        _IS_ALLOWED_PROXY_[oldDodoProxy] = false;
    }
    
    function claimTokens(
        address token,
        address who,
        address dest,
        uint256 amount
    ) external {
        require(_IS_ALLOWED_PROXY_[msg.sender], "DODOApproveProxy:Access restricted");
        IDODOApprove(_DODO_APPROVE_).claimTokens(
            token,
            who,
            dest,
            amount
        );
    }

    function isAllowedProxy(address _proxy) external view returns (bool) {
        return _IS_ALLOWED_PROXY_[_proxy];
    }
}

// File: contracts/intf/IERC20.sol


/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    function decimals() external view returns (uint8);

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    /**
     * @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);
}

// File: contracts/intf/IWETH.sol



interface IWETH {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address src,
        address dst,
        uint256 wad
    ) external returns (bool);

    function deposit() external payable;

    function withdraw(uint256 wad) external;
}

// File: contracts/lib/SafeMath.sol

/**
 * @title SafeMath
 * @author DODO Breeder
 *
 * @notice Math operations with safety checks that revert on error
 */
library SafeMath {
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "MUL_ERROR");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "DIVIDING_ERROR");
        return a / b;
    }

    function divCeil(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 quotient = div(a, b);
        uint256 remainder = a - quotient * b;
        if (remainder > 0) {
            return quotient + 1;
        } else {
            return quotient;
        }
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SUB_ERROR");
        return a - b;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "ADD_ERROR");
        return c;
    }

    function sqrt(uint256 x) internal pure returns (uint256 y) {
        uint256 z = x / 2 + 1;
        y = x;
        while (z < y) {
            y = z;
            z = (x / z + z) / 2;
        }
    }
}

// File: contracts/lib/SafeERC20.sol



/**
 * @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;

    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));
    }

    /**
     * @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

        // 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: contracts/lib/DecimalMath.sol


/**
 * @title DecimalMath
 * @author DODO Breeder
 *
 * @notice Functions for fixed point number with 18 decimals
 */
library DecimalMath {
    using SafeMath for uint256;

    uint256 internal constant ONE = 10**18;
    uint256 internal constant ONE2 = 10**36;

    function mulFloor(uint256 target, uint256 d) internal pure returns (uint256) {
        return target.mul(d) / (10**18);
    }

    function mulCeil(uint256 target, uint256 d) internal pure returns (uint256) {
        return target.mul(d).divCeil(10**18);
    }

    function divFloor(uint256 target, uint256 d) internal pure returns (uint256) {
        return target.mul(10**18).div(d);
    }

    function divCeil(uint256 target, uint256 d) internal pure returns (uint256) {
        return target.mul(10**18).divCeil(d);
    }

    function reciprocalFloor(uint256 target) internal pure returns (uint256) {
        return uint256(10**36).div(target);
    }

    function reciprocalCeil(uint256 target) internal pure returns (uint256) {
        return uint256(10**36).divCeil(target);
    }
}

// File: contracts/lib/ReentrancyGuard.sol


/**
 * @title ReentrancyGuard
 * @author DODO Breeder
 *
 * @notice Protect functions from Reentrancy Attack
 */
contract ReentrancyGuard {
    // https://solidity.readthedocs.io/en/latest/control-structures.html?highlight=zero-state#scoping-and-declarations
    // zero-state of _ENTERED_ is false
    bool private _ENTERED_;

    modifier preventReentrant() {
        require(!_ENTERED_, "REENTRANT");
        _ENTERED_ = true;
        _;
        _ENTERED_ = false;
    }
}

// File: contracts/DODOStablePool/intf/IDSP.sol


interface IDSP {
    function init(
        address maintainer,
        address baseTokenAddress,
        address quoteTokenAddress,
        uint256 lpFeeRate,
        address mtFeeRateModel,
        uint256 i,
        uint256 k,
        bool isOpenTWAP
    ) external;

    function _BASE_TOKEN_() external view returns (address);

    function _QUOTE_TOKEN_() external view returns (address);

    function _I_() external view returns (uint256);

    function _MT_FEE_RATE_MODEL_() external view returns (address);

    function getVaultReserve() external view returns (uint256 baseReserve, uint256 quoteReserve);

    function sellBase(address to) external returns (uint256);

    function sellQuote(address to) external returns (uint256);

    function buyShares(address to) external returns (uint256,uint256,uint256);
}

// File: contracts/lib/CloneFactory.sol


interface ICloneFactory {
    function clone(address prototype) external returns (address proxy);
}

// introduction of proxy mode design: https://docs.openzeppelin.com/upgrades/2.8/
// minimum implementation of transparent proxy: https://eips.ethereum.org/EIPS/eip-1167

contract CloneFactory is ICloneFactory {
    function clone(address prototype) external override returns (address proxy) {
        bytes20 targetBytes = bytes20(prototype);
        assembly {
            let clone := mload(0x40)
            mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(clone, 0x14), targetBytes)
            mstore(
                add(clone, 0x28),
                0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
            )
            proxy := create(0, clone, 0x37)
        }
        return proxy;
    }
}

// File: contracts/Factory/DSPFactory.sol



interface IDSPFactory {
    function createDODOStablePool(
        address baseToken,
        address quoteToken,
        uint256 lpFeeRate,
        uint256 i,
        uint256 k,
        bool isOpenTWAP
    ) external returns (address newStablePool);
}

/**
 * @title DODO StablePool Factory
 * @author DODO Breeder
 *
 * @notice Create And Register DSP Pools
 */
contract DSPFactory is InitializableOwnable {
    // ============ Templates ============

    address public immutable _CLONE_FACTORY_;
    address public immutable _DEFAULT_MAINTAINER_;
    address public immutable _DEFAULT_MT_FEE_RATE_MODEL_;
    address public _DSP_TEMPLATE_;

    // ============ Registry ============

    // base -> quote -> DSP address list
    mapping(address => mapping(address => address[])) public _REGISTRY_;
    // creator -> DSP address list
    mapping(address => address[]) public _USER_REGISTRY_;

    // ============ Events ============

    event NewDSP(address baseToken, address quoteToken, address creator, address DSP);

    event RemoveDSP(address DSP);

    // ============ Functions ============

    constructor(
        address cloneFactory,
        address DSPTemplate,
        address defaultMaintainer,
        address defaultMtFeeRateModel
    ) public {
        _CLONE_FACTORY_ = cloneFactory;
        _DSP_TEMPLATE_ = DSPTemplate;
        _DEFAULT_MAINTAINER_ = defaultMaintainer;
        _DEFAULT_MT_FEE_RATE_MODEL_ = defaultMtFeeRateModel;
    }

    function createDODOStablePool(
        address baseToken,
        address quoteToken,
        uint256 lpFeeRate,
        uint256 i,
        uint256 k,
        bool isOpenTWAP
    ) external returns (address newStablePool) {
        newStablePool = ICloneFactory(_CLONE_FACTORY_).clone(_DSP_TEMPLATE_);
        {
            IDSP(newStablePool).init(
                _DEFAULT_MAINTAINER_,
                baseToken,
                quoteToken,
                lpFeeRate,
                _DEFAULT_MT_FEE_RATE_MODEL_,
                i,
                k,
                isOpenTWAP
            );
        }
        _REGISTRY_[baseToken][quoteToken].push(newStablePool);
        _USER_REGISTRY_[tx.origin].push(newStablePool);
        emit NewDSP(baseToken, quoteToken, tx.origin, newStablePool);
    }

    // ============ Admin Operation Functions ============

    function updateDSPTemplate(address _newDSPTemplate) external onlyOwner {
        _DSP_TEMPLATE_ = _newDSPTemplate;
    }

    function addPoolByAdmin(
        address creator,
        address baseToken,
        address quoteToken,
        address pool
    ) external onlyOwner {
        _REGISTRY_[baseToken][quoteToken].push(pool);
        _USER_REGISTRY_[creator].push(pool);
        emit NewDSP(baseToken, quoteToken, creator, pool);
    }

    function removePoolByAdmin(
        address creator,
        address baseToken,
        address quoteToken,
        address pool
    ) external onlyOwner {
        address[] memory registryList = _REGISTRY_[baseToken][quoteToken];
        for (uint256 i = 0; i < registryList.length; i++) {
            if (registryList[i] == pool) {
                registryList[i] = registryList[registryList.length - 1];
                break;
            }
        }
        _REGISTRY_[baseToken][quoteToken] = registryList;
        _REGISTRY_[baseToken][quoteToken].pop();
        address[] memory userRegistryList = _USER_REGISTRY_[creator];
        for (uint256 i = 0; i < userRegistryList.length; i++) {
            if (userRegistryList[i] == pool) {
                userRegistryList[i] = userRegistryList[userRegistryList.length - 1];
                break;
            }
        }
        _USER_REGISTRY_[creator] = userRegistryList;
        _USER_REGISTRY_[creator].pop();
        emit RemoveDSP(pool);
    }

    // ============ View Functions ============

    function getDODOPool(address baseToken, address quoteToken)
        external
        view
        returns (address[] memory machines)
    {
        return _REGISTRY_[baseToken][quoteToken];
    }

    function getDODOPoolBidirection(address token0, address token1)
        external
        view
        returns (address[] memory baseToken0Machines, address[] memory baseToken1Machines)
    {
        return (_REGISTRY_[token0][token1], _REGISTRY_[token1][token0]);
    }

    function getDODOPoolByUser(address user) external view returns (address[] memory machines) {
        return _USER_REGISTRY_[user];
    }
}

// File: contracts/SmartRoute/proxies/DODODspProxy.sol





/**
 * @title DODODspProxy
 * @author DODO Breeder
 *
 * @notice Entrance of DODO Stable Pair in DODO platform
 */
contract DODODspProxy is ReentrancyGuard {
    using SafeMath for uint256;

    // ============ Storage ============

    address constant _ETH_ADDRESS_ = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    address public immutable _WETH_;
    address public immutable _DODO_APPROVE_PROXY_;
    address public immutable _DSP_FACTORY_;

    // ============ Modifiers ============

    modifier judgeExpired(uint256 deadLine) {
        require(deadLine >= block.timestamp, "DODODspProxy: EXPIRED");
        _;
    }

    fallback() external payable {}

    receive() external payable {}

    constructor(
        address dspFactory,
        address payable weth,
        address dodoApproveProxy
    ) public {
        _DSP_FACTORY_ = dspFactory;
        _WETH_ = weth;
        _DODO_APPROVE_PROXY_ = dodoApproveProxy;
    }

    // ============ DSP Functions (create & add liquidity) ============

    function createDODOStablePair(
        address baseToken,
        address quoteToken,
        uint256 baseInAmount,
        uint256 quoteInAmount,
        uint256 lpFeeRate,
        uint256 i,
        uint256 k,
        bool isOpenTWAP,
        uint256 deadLine
    )
        external
        payable
        preventReentrant
        judgeExpired(deadLine)
        returns (address newDODOStablePair, uint256 shares)
    {
        {
            address _baseToken = baseToken == _ETH_ADDRESS_ ? _WETH_ : baseToken;
            address _quoteToken = quoteToken == _ETH_ADDRESS_ ? _WETH_ : quoteToken;
            newDODOStablePair = IDSPFactory(_DSP_FACTORY_).createDODOStablePool(
                _baseToken,
                _quoteToken,
                lpFeeRate,
                i,
                k,
                isOpenTWAP
            );
        }

        {
            address _baseToken = baseToken;
            address _quoteToken = quoteToken;
            _deposit(
                msg.sender,
                newDODOStablePair,
                _baseToken,
                baseInAmount,
                _baseToken == _ETH_ADDRESS_
            );
            _deposit(
                msg.sender,
                newDODOStablePair,
                _quoteToken,
                quoteInAmount,
                _quoteToken == _ETH_ADDRESS_
            );
        }

        (shares, , ) = IDSP(newDODOStablePair).buyShares(msg.sender);
    }

    function addDSPLiquidity(
        address dspAddress,
        uint256 baseInAmount,
        uint256 quoteInAmount,
        uint256 baseMinAmount,
        uint256 quoteMinAmount,
        uint8 flag, // 0 - ERC20, 1 - baseInETH, 2 - quoteInETH
        uint256 deadLine
    )
        external
        payable
        preventReentrant
        judgeExpired(deadLine)
        returns (
            uint256 shares,
            uint256 baseAdjustedInAmount,
            uint256 quoteAdjustedInAmount
        )
    {
        address _dsp = dspAddress;
        (baseAdjustedInAmount, quoteAdjustedInAmount) = _addDSPLiquidity(
            _dsp,
            baseInAmount,
            quoteInAmount
        );
        require(
            baseAdjustedInAmount >= baseMinAmount && quoteAdjustedInAmount >= quoteMinAmount,
            "DODODspProxy: deposit amount is not enough"
        );

        _deposit(msg.sender, _dsp, IDSP(_dsp)._BASE_TOKEN_(), baseAdjustedInAmount, flag == 1);
        _deposit(msg.sender, _dsp, IDSP(_dsp)._QUOTE_TOKEN_(), quoteAdjustedInAmount, flag == 2);
        
        (shares, , ) = IDSP(_dsp).buyShares(msg.sender);

        // refund dust eth
        if (flag == 1 && msg.value > baseAdjustedInAmount) msg.sender.transfer(msg.value - baseAdjustedInAmount);
        if (flag == 2 && msg.value > quoteAdjustedInAmount) msg.sender.transfer(msg.value - quoteAdjustedInAmount);
    }


    // =================== internal functions =====================

    function _addDSPLiquidity(
        address dspAddress,
        uint256 baseInAmount,
        uint256 quoteInAmount
    ) internal view returns (uint256 baseAdjustedInAmount, uint256 quoteAdjustedInAmount) {
        (uint256 baseReserve, uint256 quoteReserve) = IDSP(dspAddress).getVaultReserve();
        if (quoteReserve == 0 && baseReserve == 0) {
            uint256 i = IDSP(dspAddress)._I_();
            uint256 shares = quoteInAmount < DecimalMath.mulFloor(baseInAmount, i)
                ? DecimalMath.divFloor(quoteInAmount, i)
                : baseInAmount;
            baseAdjustedInAmount = shares;
            quoteAdjustedInAmount = DecimalMath.mulFloor(shares, i);
        }
        if (quoteReserve > 0 && baseReserve > 0) {
            uint256 baseIncreaseRatio = DecimalMath.divFloor(baseInAmount, baseReserve);
            uint256 quoteIncreaseRatio = DecimalMath.divFloor(quoteInAmount, quoteReserve);
            if (baseIncreaseRatio <= quoteIncreaseRatio) {
                baseAdjustedInAmount = baseInAmount;
                quoteAdjustedInAmount = DecimalMath.mulFloor(quoteReserve, baseIncreaseRatio);
            } else {
                quoteAdjustedInAmount = quoteInAmount;
                baseAdjustedInAmount = DecimalMath.mulFloor(baseReserve, quoteIncreaseRatio);
            }
        }
    }

    function _deposit(
        address from,
        address to,
        address token,
        uint256 amount,
        bool isETH
    ) internal {
        if (isETH) {
            if (amount > 0) {
                IWETH(_WETH_).deposit{value: amount}();
                if (to != address(this)) SafeERC20.safeTransfer(IERC20(_WETH_), to, amount);
            }
        } else {
            IDODOApproveProxy(_DODO_APPROVE_PROXY_).claimTokens(token, from, to, amount);
        }
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"dspFactory","type":"address"},{"internalType":"address payable","name":"weth","type":"address"},{"internalType":"address","name":"dodoApproveProxy","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"_DODO_APPROVE_PROXY_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_DSP_FACTORY_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_WETH_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"dspAddress","type":"address"},{"internalType":"uint256","name":"baseInAmount","type":"uint256"},{"internalType":"uint256","name":"quoteInAmount","type":"uint256"},{"internalType":"uint256","name":"baseMinAmount","type":"uint256"},{"internalType":"uint256","name":"quoteMinAmount","type":"uint256"},{"internalType":"uint8","name":"flag","type":"uint8"},{"internalType":"uint256","name":"deadLine","type":"uint256"}],"name":"addDSPLiquidity","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"uint256","name":"baseAdjustedInAmount","type":"uint256"},{"internalType":"uint256","name":"quoteAdjustedInAmount","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"baseToken","type":"address"},{"internalType":"address","name":"quoteToken","type":"address"},{"internalType":"uint256","name":"baseInAmount","type":"uint256"},{"internalType":"uint256","name":"quoteInAmount","type":"uint256"},{"internalType":"uint256","name":"lpFeeRate","type":"uint256"},{"internalType":"uint256","name":"i","type":"uint256"},{"internalType":"uint256","name":"k","type":"uint256"},{"internalType":"bool","name":"isOpenTWAP","type":"bool"},{"internalType":"uint256","name":"deadLine","type":"uint256"}],"name":"createDODOStablePair","outputs":[{"internalType":"address","name":"newDODOStablePair","type":"address"},{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

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

00000000000000000000000043c49f8dd240e1545f147211ec9f917376ac1e870000000000000000000000000d500b1d8e8ef31e21c99d1db9a6444d3adf127000000000000000000000000001feea29da5ae41b0b5f6b10b93ee34752ef80d7

-----Decoded View---------------
Arg [0] : dspFactory (address): 0x43c49f8dd240e1545f147211ec9f917376ac1e87
Arg [1] : weth (address): 0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270
Arg [2] : dodoApproveProxy (address): 0x01feea29da5ae41b0b5f6b10b93ee34752ef80d7

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000043c49f8dd240e1545f147211ec9f917376ac1e87
Arg [1] : 0000000000000000000000000d500b1d8e8ef31e21c99d1db9a6444d3adf1270
Arg [2] : 00000000000000000000000001feea29da5ae41b0b5f6b10b93ee34752ef80d7


Deployed ByteCode Sourcemap

20206:5818:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20415:31;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;20415:31:0;;;;;;;;;;;;;;21136:1499;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;21136:1499:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;21136:1499:0;;;;;;;;;;;;;;;;;;;;;22643:1439;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;22643:1439:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;20453:45;;;;;;;;;;;;;:::i;20505:38::-;;;;;;;;;;;;;:::i;20415:31::-;;;:::o;21136:1499::-;21525:25;13408:9;;21525:25;;13408:9;;13407:10;13399:32;;;;;-1:-1:-1;;;13399:32:0;;;;;;;;;;;;-1:-1:-1;;;13399:32:0;;;;;;;;;;;;;;;13442:9;:16;;-1:-1:-1;;13442:16:0;13454:4;13442:16;;;21497:8;20669:15:::1;20657:27:::0;::::1;;20649:61;;;::::0;;-1:-1:-1;;;20649:61:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;20649:61:0;;;;;;;;;;;;;::::1;;21599:18:::2;-1:-1:-1::0;;;;;21620:26:0;::::2;20366:42;21620:26;:47;;21658:9;21620:47;;;21649:6;21620:47;21599:68:::0;-1:-1:-1;21682:19:0::2;-1:-1:-1::0;;;;;21704:27:0;::::2;20366:42;21704:27;:49;;21743:10;21704:49;;;21734:6;21704:49;21788:218;::::0;;-1:-1:-1;;;21788:218:0;;-1:-1:-1;;;;;21788:218:0;;::::2;;::::0;::::2;::::0;;;::::2;::::0;;;;;;;;;;;;;;;;;;;;;;;::::2;;::::0;;;;;;;;-1:-1:-1;21800:13:0::2;21788:47:::0;;::::2;::::0;::::2;::::0;:218;;;;;::::2;::::0;;;;;;;;;-1:-1:-1;21788:47:0;:218;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;21788:218:0;;-1:-1:-1;22066:9:0;;-1:-1:-1;22112:10:0;;-1:-1:-1;22137:194:0::2;22164:10;21788:218:::0;22066:9;22258:12;-1:-1:-1;;;;;22289:27:0;::::2;20366:42;22289:27;22137:8;:194::i;:::-;22346:197;22373:10;22402:17:::0;22438:11;22468:13;-1:-1:-1;;;;;22500:28:0;::::2;20366:42;22500:28;22346:8;:197::i;:::-;-1:-1:-1::0;;22582:45:0::2;::::0;;-1:-1:-1;;;22582:45:0;;22616:10:::2;22582:45;::::0;::::2;::::0;;;-1:-1:-1;;;;;22582:33:0;::::2;::::0;::::2;::::0;:45;;;;;::::2;::::0;;;;;;;;-1:-1:-1;22582:33:0;:45;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;22582:45:0;13493:5;13481:17;;-1:-1:-1;;13481:17:0;;;21136:1499;;22582:45;;-1:-1:-1;21136:1499:0;;-1:-1:-1;;;;;;;;;;21136:1499:0:o;22643:1439::-;23049:14;13408:9;;23049:14;;;;13408:9;;13407:10;13399:32;;;;;-1:-1:-1;;;13399:32:0;;;;;;;;;;;;-1:-1:-1;;;13399:32:0;;;;;;;;;;;;;;;13442:9;:16;;-1:-1:-1;;13442:16:0;13454:4;13442:16;;;23007:8;20669:15:::1;20657:27:::0;::::1;;20649:61;;;::::0;;-1:-1:-1;;;20649:61:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;20649:61:0;;;;;;;;;;;;;::::1;;23193:10:::0;23262:101:::2;23193:10:::0;23312:12;23339:13;23262:16:::2;:101::i;:::-;23214:149:::0;;-1:-1:-1;23214:149:0;-1:-1:-1;23396:37:0;;::::2;::::0;::::2;::::0;:80:::2;;;23462:14;23437:21;:39;;23396:80;23374:172;;;;-1:-1:-1::0;;;23374:172:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23559:86;23568:10;23580:4;23591;-1:-1:-1::0;;;;;23586:23:0::2;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;23586:25:0;23613:20;23643:1:::2;23635:9;::::0;::::2;;23559:8;:86::i;:::-;23656:88;23665:10;23677:4;23688;-1:-1:-1::0;;;;;23683:24:0::2;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;23683:26:0;23711:21;23742:1:::2;23734:9;::::0;::::2;;23656:8;:88::i;:::-;23780:32;::::0;;-1:-1:-1;;;23780:32:0;;23801:10:::2;23780:32;::::0;::::2;::::0;;;-1:-1:-1;;;;;23780:20:0;::::2;::::0;::::2;::::0;:32;;;;;::::2;::::0;;;;;;;;-1:-1:-1;23780:20:0;:32;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;23780:32:0;;-1:-1:-1;23865:1:0::2;23857:9;::::0;::::2;;:45:::0;::::2;;;;23882:20;23870:9;:32;23857:45;23853:104;;;23904:53;::::0;:10:::2;::::0;23924:9:::2;:32:::0;;::::2;23904:53:::0;::::2;;;::::0;::::2;::::0;;;23924:32;23904:10;:53;::::2;;;;;;;;;;;;;::::0;::::2;;;;;;23853:104;23972:4;:9;;23980:1;23972:9;:46;;;;;23997:21;23985:9;:33;23972:46;23968:106;;;24020:54;::::0;:10:::2;::::0;24040:9:::2;:33:::0;;::::2;24020:54:::0;::::2;;;::::0;::::2;::::0;;;24040:33;24020:10;:54;::::2;;;;;;;;;;;;;::::0;::::2;;;;;;23968:106;-1:-1:-1::0;;13493:5:0;13481:17;;-1:-1:-1;;13481:17:0;;;22643:1439;;;;-1:-1:-1;22643:1439:0;;-1:-1:-1;22643:1439:0;-1:-1:-1;;;;;22643:1439:0:o;20453:45::-;;;:::o;20505:38::-;;;:::o;25526:495::-;25689:5;25685:329;;;25715:10;;25711:183;;25752:6;-1:-1:-1;;;;;25746:21:0;;25775:6;25746:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;25807:19:0;;25821:4;25807:19;;-1:-1:-1;25803:75:0;;25828:50;25858:6;25867:2;25871:6;25828:22;:50::i;:::-;25685:329;;;25926:76;;;-1:-1:-1;;;25926:76:0;;-1:-1:-1;;;;;25926:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25944:20;25926:51;;;;;;:76;;;;;-1:-1:-1;;25926:76:0;;;;;;;;-1:-1:-1;25926:51:0;:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25685:329;25526:495;;;;;:::o;24163:1355::-;24311:28;24341:29;24384:19;24405:20;24434:10;-1:-1:-1;;;;;24429:32:0;;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24429:34:0;;;;;;;;;-1:-1:-1;24429:34:0;-1:-1:-1;24478:17:0;;:37;;;;-1:-1:-1;24499:16:0;;24478:37;24474:393;;;24532:9;24549:10;-1:-1:-1;;;;;24544:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24544:22:0;;-1:-1:-1;24581:14:0;24614:37;24635:12;24544:22;24614:20;:37::i;:::-;24598:13;:53;:143;;24729:12;24598:143;;;24671:38;24692:13;24707:1;24671:20;:38::i;:::-;24581:160;;24779:6;24756:29;;24824:31;24845:6;24853:1;24824:20;:31::i;:::-;24800:55;;24474:393;;;24896:1;24881:12;:16;:35;;;;;24915:1;24901:11;:15;24881:35;24877:634;;;24933:25;24961:47;24982:12;24996:11;24961:20;:47::i;:::-;24933:75;;25023:26;25052:49;25073:13;25088:12;25052:20;:49::i;:::-;25023:78;;25141:18;25120:17;:39;25116:384;;25203:12;25180:35;;25258:53;25279:12;25293:17;25258:20;:53::i;:::-;25234:77;;25116:384;;;25376:13;25352:37;;25431:53;25452:11;25465:18;25431:20;:53::i;:::-;25408:76;;25116:384;24877:634;;;24163:1355;;;;;;;;:::o;9201:211::-;9345:58;;;-1:-1:-1;;;;;9345:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9345:58:0;-1:-1:-1;;;9345:58:0;;;9318:86;;9338:5;;9318:19;:86::i;:::-;9201:211;;;:::o;12150:127::-;12218:7;12262:6;12245:13;:6;12256:1;12245:13;:10;:13;:::i;:::-;:24;;;;;;12238:31;;12150:127;;;;;:::o;12424:128::-;12492:7;12519:25;12542:1;12519:18;:6;12530;12519:18;:10;:18;:::i;:::-;:22;:25;:22;:25;:::i;:::-;12512:32;12424:128;-1:-1:-1;;;12424:128:0:o;10774:1046::-;11434:12;11448:23;11483:5;-1:-1:-1;;;;;11475:19:0;11495:4;11475:25;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;11475:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11433:67;;;;11519:7;11511:52;;;;;-1:-1:-1;;;11511:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11580:17;;:21;11576:237;;11735:10;11724:30;;;;;;;;;;;;;;;-1:-1:-1;11724:30:0;11716:85;;;;-1:-1:-1;;;11716:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10774:1046;;;;:::o;7426:226::-;7484:7;7508:6;7504:47;;-1:-1:-1;7538:1:0;7531:8;;7504:47;7575:5;;;7579:1;7575;:5;:1;7599:5;;;;;:10;7591:32;;;;;-1:-1:-1;;;7591:32:0;;;;;;;;;;;;-1:-1:-1;;;7591:32:0;;;;;;;;;;;;;;7660:141;7718:7;7750:1;7746;:5;7738:32;;;;;-1:-1:-1;;;7738:32:0;;;;;;;;;;;;-1:-1:-1;;;7738:32:0;;;;;;;;;;;;;;;7792:1;7788;:5;;;

Swarm Source

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