Contract 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x4fdfebc9a28f47a3e164d43300c8881142dedd4458a00edb27853aba89f299440x60806040123084012022-05-17 11:22:37256 days 2 hrs ago0x8f8c780dbc3ef64e86352a1198b58f98c8fa51a6 IN  Create: UniV3WrapperV30 ETH0.003575806092 ETH
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x312bbbd0b44a1c58da1e449744c613ac3e4637be3f979525bbba2407e6219883555304132023-01-26 5:22:302 days 8 hrs ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 Uniswap V3: Router0 ETH
0x312bbbd0b44a1c58da1e449744c613ac3e4637be3f979525bbba2407e6219883555304132023-01-26 5:22:302 days 8 hrs ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0x312bbbd0b44a1c58da1e449744c613ac3e4637be3f979525bbba2407e6219883555304132023-01-26 5:22:302 days 8 hrs ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0x312bbbd0b44a1c58da1e449744c613ac3e4637be3f979525bbba2407e6219883555304132023-01-26 5:22:302 days 8 hrs ago 0x3573dbe0f8cc75d99c23ea7ed03391aca1abd0d1 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c4310 ETH
0xad3b67f915929e989815b73c10a24a4e1e6bd8bc2452deab401b28c859ac2c12551316082023-01-24 12:34:064 days 1 hr ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 Uniswap V3: Router0 ETH
0xad3b67f915929e989815b73c10a24a4e1e6bd8bc2452deab401b28c859ac2c12551316082023-01-24 12:34:064 days 1 hr ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c4310x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f0 ETH
0xad3b67f915929e989815b73c10a24a4e1e6bd8bc2452deab401b28c859ac2c12551316082023-01-24 12:34:064 days 1 hr ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c4310x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f0 ETH
0xad3b67f915929e989815b73c10a24a4e1e6bd8bc2452deab401b28c859ac2c12551316082023-01-24 12:34:064 days 1 hr ago 0x7c26f5566e14c5dcfbd6aa649f69b0d7019ebd63 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c4310 ETH
0xcbae09e92e0674f57a61600ed50e196bfaa545edae11401f2d538cd27c6daa9f549144512023-01-23 12:41:565 days 1 hr ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 Uniswap V3: Router0 ETH
0xcbae09e92e0674f57a61600ed50e196bfaa545edae11401f2d538cd27c6daa9f549144512023-01-23 12:41:565 days 1 hr ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 0xda10009cbd5d07dd0cecc66161fc93d7c9000da10 ETH
0xcbae09e92e0674f57a61600ed50e196bfaa545edae11401f2d538cd27c6daa9f549144512023-01-23 12:41:565 days 1 hr ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 0xda10009cbd5d07dd0cecc66161fc93d7c9000da10 ETH
0xcbae09e92e0674f57a61600ed50e196bfaa545edae11401f2d538cd27c6daa9f549144512023-01-23 12:41:565 days 1 hr ago 0x4ce0b14e7f5a0a5983903c380d9d21e7db38c161 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c4310 ETH
0x6ac1c9b5ead128658cc346596a0c070a6880327231939a968da63c8d13f3219a549040992023-01-23 11:38:285 days 2 hrs ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 Uniswap V3: Router0 ETH
0x6ac1c9b5ead128658cc346596a0c070a6880327231939a968da63c8d13f3219a549040992023-01-23 11:38:285 days 2 hrs ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0x6ac1c9b5ead128658cc346596a0c070a6880327231939a968da63c8d13f3219a549040992023-01-23 11:38:285 days 2 hrs ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0x6ac1c9b5ead128658cc346596a0c070a6880327231939a968da63c8d13f3219a549040992023-01-23 11:38:285 days 2 hrs ago 0xad38df1c34b5e0e57de2cbb4e48c7588d4f6548d 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c4310 ETH
0xb8fe4367654c43ad01b68e552d196edd111d217f0b69c38ee96cd494094021cd547878822023-01-22 20:29:575 days 17 hrs ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 Uniswap V3: Router0 ETH
0xb8fe4367654c43ad01b68e552d196edd111d217f0b69c38ee96cd494094021cd547878822023-01-22 20:29:575 days 17 hrs ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431Treasure DAO: Magic Token0 ETH
0xb8fe4367654c43ad01b68e552d196edd111d217f0b69c38ee96cd494094021cd547878822023-01-22 20:29:575 days 17 hrs ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431Treasure DAO: Magic Token0 ETH
0xb8fe4367654c43ad01b68e552d196edd111d217f0b69c38ee96cd494094021cd547878822023-01-22 20:29:575 days 17 hrs ago 0xbf90127c6bba7990fbbb30bf628198ef60b8cd7e 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c4310 ETH
0x821b5a81d25811fe1855203b9aeb8748d1ba908aa6fa82b7361ab5cace26ee0f547327732023-01-22 14:52:485 days 23 hrs ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 Uniswap V3: Router0 ETH
0x821b5a81d25811fe1855203b9aeb8748d1ba908aa6fa82b7361ab5cace26ee0f547327732023-01-22 14:52:485 days 23 hrs ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0x821b5a81d25811fe1855203b9aeb8748d1ba908aa6fa82b7361ab5cace26ee0f547327732023-01-22 14:52:485 days 23 hrs ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 0xff970a61a04b1ca14834a43f5de4533ebddb5cc80 ETH
0x821b5a81d25811fe1855203b9aeb8748d1ba908aa6fa82b7361ab5cace26ee0f547327732023-01-22 14:52:485 days 23 hrs ago 0x503d8448399fc6bca604b6e59d20f7fbb0bbd428 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c4310 ETH
0xee657991376b0f3e08d00c910d0c100db57763523a55e5ab5bcb8484e72e5a95547322792023-01-22 14:50:035 days 23 hrs ago 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431 Uniswap V3: Router0 ETH
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
UniV3WrapperV3

Compiler Version
v0.8.10+commit.fc410830

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Arbiscan on 2022-05-17
*/

// SPDX-License-Identifier: MIT

pragma solidity =0.8.10;





interface IERC20 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint256 digits);
    function totalSupply() external view returns (uint256 supply);

    function balanceOf(address _owner) external view returns (uint256 balance);

    function transfer(address _to, uint256 _value) external returns (bool success);

    function transferFrom(
        address _from,
        address _to,
        uint256 _value
    ) external returns (bool success);

    function approve(address _spender, uint256 _value) external returns (bool success);

    function allowance(address _owner, address _spender) external view returns (uint256 remaining);

    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}





abstract contract IWETH {
    function allowance(address, address) public virtual view returns (uint256);

    function balanceOf(address) public virtual view returns (uint256);

    function approve(address, uint256) public virtual;

    function transfer(address, uint256) public virtual returns (bool);

    function transferFrom(
        address,
        address,
        uint256
    ) public virtual returns (bool);

    function deposit() public payable virtual;

    function withdraw(uint256) public virtual;
}





library Address {
    //insufficient balance
    error InsufficientBalance(uint256 available, uint256 required);
    //unable to send value, recipient may have reverted
    error SendingValueFail();
    //insufficient balance for call
    error InsufficientBalanceForCall(uint256 available, uint256 required);
    //call to non-contract
    error NonContractCall();
    
    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);
    }

    function sendValue(address payable recipient, uint256 amount) internal {
        uint256 balance = address(this).balance;
        if (balance < amount){
            revert InsufficientBalance(balance, amount);
        }

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{value: amount}("");
        if (!(success)){
            revert SendingValueFail();
        }
    }

    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        uint256 balance = address(this).balance;
        if (balance < value){
            revert InsufficientBalanceForCall(balance, value);
        }
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 weiValue,
        string memory errorMessage
    ) private returns (bytes memory) {
        if (!(isContract(target))){
            revert NonContractCall();
        }

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{value: weiValue}(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}




library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

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

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        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;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}







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

    /// @dev Edited so it always first approves 0 and then the value, because of non standard tokens
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
        _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)
        );
    }

    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        bytes memory returndata = address(token).functionCall(
            data,
            "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");
        }
    }
}






library TokenUtils {
    using SafeERC20 for IERC20;

    address public constant WETH_ADDR = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;
    address public constant ETH_ADDR = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;

    function approveToken(
        address _tokenAddr,
        address _to,
        uint256 _amount
    ) internal {
        if (_tokenAddr == ETH_ADDR) return;

        if (IERC20(_tokenAddr).allowance(address(this), _to) < _amount) {
            IERC20(_tokenAddr).safeApprove(_to, _amount);
        }
    }

    function pullTokensIfNeeded(
        address _token,
        address _from,
        uint256 _amount
    ) internal returns (uint256) {
        // handle max uint amount
        if (_amount == type(uint256).max) {
            _amount = getBalance(_token, _from);
        }

        if (_from != address(0) && _from != address(this) && _token != ETH_ADDR && _amount != 0) {
            IERC20(_token).safeTransferFrom(_from, address(this), _amount);
        }

        return _amount;
    }

    function withdrawTokens(
        address _token,
        address _to,
        uint256 _amount
    ) internal returns (uint256) {
        if (_amount == type(uint256).max) {
            _amount = getBalance(_token, address(this));
        }

        if (_to != address(0) && _to != address(this) && _amount != 0) {
            if (_token != ETH_ADDR) {
                IERC20(_token).safeTransfer(_to, _amount);
            } else {
                (bool success, ) = _to.call{value: _amount}("");
                require(success, "Eth send fail");
            }
        }

        return _amount;
    }

    function depositWeth(uint256 _amount) internal {
        IWETH(WETH_ADDR).deposit{value: _amount}();
    }

    function withdrawWeth(uint256 _amount) internal {
        IWETH(WETH_ADDR).withdraw(_amount);
    }

    function getBalance(address _tokenAddr, address _acc) internal view returns (uint256) {
        if (_tokenAddr == ETH_ADDR) {
            return _acc.balance;
        } else {
            return IERC20(_tokenAddr).balanceOf(_acc);
        }
    }

    function getTokenDecimals(address _token) internal view returns (uint256) {
        if (_token == ETH_ADDR) return 18;

        return IERC20(_token).decimals();
    }
}





interface IExchangeV3 {
    function sell(address _srcAddr, address _destAddr, uint _srcAmount, bytes memory _additionalData) external returns (uint);

    function buy(address _srcAddr, address _destAddr, uint _destAmount, bytes memory _additionalData) external returns(uint);

    function getSellRate(address _srcAddr, address _destAddr, uint _srcAmount, bytes memory _additionalData) external returns (uint);

    function getBuyRate(address _srcAddr, address _destAddr, uint _srcAmount, bytes memory _additionalData) external returns (uint);
}




interface IUniswapV3SwapCallback {
    /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap.
    /// @dev In the implementation you must pay the pool tokens owed for the swap.
    /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
    /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
    /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by
    /// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
    /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by
    /// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
    /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call
    function uniswapV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata data
    ) external;
}

interface ISwapRouter is IUniswapV3SwapCallback {
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Swaps `amountIn` of one token for as much as possible of another token
    /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
    /// @return amountOut The amount of the received token
    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);

    struct ExactInputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
    }

    /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
    /// @return amountOut The amount of the received token
    function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);

    struct ExactOutputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
        uint160 sqrtPriceLimitX96;
    }

    /// @notice Swaps as little as possible of one token for `amountOut` of another token
    /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
    /// @return amountIn The amount of the input token
    function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);

    struct ExactOutputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountOut;
        uint256 amountInMaximum;
    }

    /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
    /// @return amountIn The amount of the input token
    function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
}




interface IQuoter {
    /// @notice Returns the amount out received for a given exact input swap without executing the swap
    /// @param path The path of the swap, i.e. each token pair and the pool fee
    /// @param amountIn The amount of the first token to swap
    /// @return amountOut The amount of the last token that would be received
    function quoteExactInput(bytes memory path, uint256 amountIn) external returns (uint256 amountOut);

    /// @notice Returns the amount out received for a given exact input but for a swap of a single pool
    /// @param tokenIn The token being swapped in
    /// @param tokenOut The token being swapped out
    /// @param fee The fee of the token pool to consider for the pair
    /// @param amountIn The desired input amount
    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
    /// @return amountOut The amount of `tokenOut` that would be received
    function quoteExactInputSingle(
        address tokenIn,
        address tokenOut,
        uint24 fee,
        uint256 amountIn,
        uint160 sqrtPriceLimitX96
    ) external returns (uint256 amountOut);

    /// @notice Returns the amount in required for a given exact output swap without executing the swap
    /// @param path The path of the swap, i.e. each token pair and the pool fee
    /// @param amountOut The amount of the last token to receive
    /// @return amountIn The amount of first token required to be paid
    function quoteExactOutput(bytes memory path, uint256 amountOut) external returns (uint256 amountIn);

    /// @notice Returns the amount in required to receive the given exact output amount but for a swap of a single pool
    /// @param tokenIn The token being swapped in
    /// @param tokenOut The token being swapped out
    /// @param fee The fee of the token pool to consider for the pair
    /// @param amountOut The desired output amount
    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
    /// @return amountIn The amount required as the input for the swap in order to receive `amountOut`
    function quoteExactOutputSingle(
        address tokenIn,
        address tokenOut,
        uint24 fee,
        uint256 amountOut,
        uint160 sqrtPriceLimitX96
    ) external returns (uint256 amountIn);
}




contract DSMath {
    function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = x + y;
    }

    function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = x - y;
    }

    function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = x * y;
    }

    function div(uint256 x, uint256 y) internal pure returns (uint256 z) {
        return x / y;
    }

    function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
        return x <= y ? x : y;
    }

    function max(uint256 x, uint256 y) internal pure returns (uint256 z) {
        return x >= y ? x : y;
    }

    function imin(int256 x, int256 y) internal pure returns (int256 z) {
        return x <= y ? x : y;
    }

    function imax(int256 x, int256 y) internal pure returns (int256 z) {
        return x >= y ? x : y;
    }

    uint256 constant WAD = 10**18;
    uint256 constant RAY = 10**27;

    function wmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = add(mul(x, y), WAD / 2) / WAD;
    }

    function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = add(mul(x, y), RAY / 2) / RAY;
    }

    function wdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = add(mul(x, WAD), y / 2) / y;
    }

    function rdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = add(mul(x, RAY), y / 2) / y;
    }

    // This famous algorithm is called "exponentiation by squaring"
    // and calculates x^n with x as fixed-point and n as regular unsigned.
    //
    // It's O(log n), instead of O(n) for naive repeated multiplication.
    //
    // These facts are why it works:
    //
    //  If n is even, then x^n = (x^2)^(n/2).
    //  If n is odd,  then x^n = x * x^(n-1),
    //   and applying the equation for even x gives
    //    x^n = x * (x^2)^((n-1) / 2).
    //
    //  Also, EVM division is flooring and
    //    floor[(n-1) / 2] = floor[n / 2].
    //
    function rpow(uint256 x, uint256 n) internal pure returns (uint256 z) {
        z = n % 2 != 0 ? x : RAY;

        for (n /= 2; n != 0; n /= 2) {
            x = rmul(x, x);

            if (n % 2 != 0) {
                z = rmul(z, x);
            }
        }
    }
}





abstract contract IDFSRegistry {
 
    function getAddr(bytes4 _id) public view virtual returns (address);

    function addNewContract(
        bytes32 _id,
        address _contractAddr,
        uint256 _waitPeriod
    ) public virtual;

    function startContractChange(bytes32 _id, address _newContractAddr) public virtual;

    function approveContractChange(bytes32 _id) public virtual;

    function cancelContractChange(bytes32 _id) public virtual;

    function changeWaitPeriod(bytes32 _id, uint256 _newWaitPeriod) public virtual;
}





contract ArbitrumAuthAddresses {
    address internal constant ADMIN_VAULT_ADDR = 0xd47D8D97cAd12A866900eEc6Cde1962529F25351;
    address internal constant FACTORY_ADDRESS = 0x5261abC3a94a6475D0A1171daE94A5f84fbaEcD2;
    address internal constant ADMIN_ADDR = 0x6AFEA85cFAB61e3a55Ad2e4537252Ec05796BEfa;
}





contract AuthHelper is ArbitrumAuthAddresses {
}





contract AdminVault is AuthHelper {
    address public owner;
    address public admin;

    error SenderNotAdmin();

    constructor() {
        owner = msg.sender;
        admin = ADMIN_ADDR;
    }

    /// @notice Admin is able to change owner
    /// @param _owner Address of new owner
    function changeOwner(address _owner) public {
        if (admin != msg.sender){
            revert SenderNotAdmin();
        }
        owner = _owner;
    }

    /// @notice Admin is able to set new admin
    /// @param _admin Address of multisig that becomes new admin
    function changeAdmin(address _admin) public {
        if (admin != msg.sender){
            revert SenderNotAdmin();
        }
        admin = _admin;
    }

}








contract AdminAuth is AuthHelper {
    using SafeERC20 for IERC20;

    AdminVault public constant adminVault = AdminVault(ADMIN_VAULT_ADDR);

    error SenderNotOwner();
    error SenderNotAdmin();

    modifier onlyOwner() {
        if (adminVault.owner() != msg.sender){
            revert SenderNotOwner();
        }
        _;
    }

    modifier onlyAdmin() {
        if (adminVault.admin() != msg.sender){
            revert SenderNotAdmin();
        }
        _;
    }

    /// @notice withdraw stuck funds
    function withdrawStuckFunds(address _token, address _receiver, uint256 _amount) public onlyOwner {
        if (_token == 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) {
            payable(_receiver).transfer(_amount);
        } else {
            IERC20(_token).safeTransfer(_receiver, _amount);
        }
    }

    /// @notice Destroy the contract
    function kill() public onlyAdmin {
        selfdestruct(payable(msg.sender));
    }
}





contract ArbitrumWrapperAddresses {

    address internal constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    address payable internal constant WALLET_ID = payable(0x322d58b9E75a6918f7e7849AEe0fF09369977e08);
    address internal constant UNI_V3_ROUTER = 0xE592427A0AEce92De3Edee1F18E0157C05861564;
    address internal constant UNI_V3_QUOTER = 0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6;

    //TODO set this?
    address internal constant KYBER_INTERFACE = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    address internal constant UNI_V2_ROUTER = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    address internal constant CURVE_ADDRESS_PROVIDER = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
}





contract WrapperHelper is ArbitrumWrapperAddresses {
}










contract UniV3WrapperV3 is DSMath, IExchangeV3, AdminAuth, WrapperHelper {
    
    using TokenUtils for address;
    using SafeERC20 for IERC20;

    ISwapRouter public constant router = ISwapRouter(UNI_V3_ROUTER);
    IQuoter public constant quoter = IQuoter(UNI_V3_QUOTER);
    /// @notice Sells _srcAmount of tokens at UniswapV3
    /// @param _srcAddr From token
    /// @param _srcAmount From amount
    /// @param _additionalData Path for swapping
    /// @return uint amount of tokens received from selling
    function sell(address _srcAddr, address, uint _srcAmount, bytes calldata _additionalData) external override returns (uint) {
        IERC20(_srcAddr).safeApprove(address(router), _srcAmount);

        ISwapRouter.ExactInputParams memory params = 
            ISwapRouter.ExactInputParams({
                path: _additionalData,
                recipient: msg.sender,
                deadline: block.timestamp + 1,
                amountIn: _srcAmount,
                amountOutMinimum: 1
            });
        uint amountOut = router.exactInput(params);
        return amountOut;
    }
    /// @notice Buys _destAmount of tokens at UniswapV3
    /// @param _srcAddr From token
    /// @param _destAmount To amount
    /// @param _additionalData Path for swapping
    /// @return uint amount of _srcAddr tokens sent for transaction
    function buy(address _srcAddr, address, uint _destAmount, bytes calldata _additionalData) external override returns(uint) {
        uint srcAmount = _srcAddr.getBalance(address(this));
        IERC20(_srcAddr).safeApprove(address(router), srcAmount);
        ISwapRouter.ExactOutputParams memory params = 
            ISwapRouter.ExactOutputParams({
                path: _additionalData,
                recipient: msg.sender,
                deadline: block.timestamp + 1,
                amountOut: _destAmount,
                amountInMaximum: type(uint).max
            });
        uint amountIn = router.exactOutput(params);
        sendLeftOver(_srcAddr);
        return amountIn;
    }

    /// @notice Return a rate for which we can sell an amount of tokens
    /// @param _srcAmount From amount
    /// @param _additionalData path object (encoded path_fee_path_fee_path etc.)
    /// @return uint Rate (price)
    function getSellRate(address, address, uint _srcAmount, bytes memory _additionalData) public override returns (uint) {
        uint amountOut = quoter.quoteExactInput(_additionalData, _srcAmount);
        return wdiv(amountOut, _srcAmount);
    }

    /// @notice Return a rate for which we can buy an amount of tokens
    /// @param _destAmount To amount
    /// @param _additionalData path object (encoded path_fee_path_fee_path etc.)
    /// @return uint Rate (price)
    function getBuyRate(address, address, uint _destAmount, bytes memory _additionalData) public override returns (uint) {
        uint amountIn = quoter.quoteExactOutput(_additionalData, _destAmount);
        return wdiv(_destAmount, amountIn);
    }

    /// @notice Send any leftover tokens, we use to clear out srcTokens after buy
    /// @param _srcAddr Source token address
    function sendLeftOver(address _srcAddr) internal {
        payable(msg.sender).transfer(address(this).balance);

        if (_srcAddr != ETH_ADDRESS) {
            IERC20(_srcAddr).safeTransfer(msg.sender, IERC20(_srcAddr).balanceOf(address(this)));
        }
    }

    // solhint-disable-next-line no-empty-blocks
    receive() external payable {}
}

Contract ABI

[{"inputs":[],"name":"NonContractCall","type":"error"},{"inputs":[],"name":"SenderNotAdmin","type":"error"},{"inputs":[],"name":"SenderNotOwner","type":"error"},{"inputs":[],"name":"adminVault","outputs":[{"internalType":"contract AdminVault","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_srcAddr","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"_destAmount","type":"uint256"},{"internalType":"bytes","name":"_additionalData","type":"bytes"}],"name":"buy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"_destAmount","type":"uint256"},{"internalType":"bytes","name":"_additionalData","type":"bytes"}],"name":"getBuyRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"_srcAmount","type":"uint256"},{"internalType":"bytes","name":"_additionalData","type":"bytes"}],"name":"getSellRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"kill","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"quoter","outputs":[{"internalType":"contract IQuoter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract ISwapRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_srcAddr","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"_srcAmount","type":"uint256"},{"internalType":"bytes","name":"_additionalData","type":"bytes"}],"name":"sell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawStuckFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Deployed ByteCode Sourcemap

24221:3564:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25609:707;;;;;;;;;;-1:-1:-1;25609:707:0;;;;;:::i;:::-;;:::i;:::-;;;1237:25:1;;;1225:2;1210:18;25609:707:0;;;;;;;;23309:85;;;;;;;;;;;;;:::i;:::-;;27037:250;;;;;;;;;;-1:-1:-1;27037:250:0;;;;;:::i;:::-;;:::i;26553:249::-;;;;;;;;;;-1:-1:-1;26553:249:0;;;;;:::i;:::-;;:::i;24752:601::-;;;;;;;;;;-1:-1:-1;24752:601:0;;;;;:::i;:::-;;:::i;22480:68::-;;;;;;;;;;;;21331:42;22480:68;;;;;-1:-1:-1;;;;;2859:32:1;;;2841:51;;2829:2;2814:18;22480:68:0;2676:222:1;22947:316:0;;;;;;;;;;-1:-1:-1;22947:316:0;;;;;:::i;:::-;;:::i;24447:55::-;;;;;;;;;;;;23778:42;24447:55;;24377:63;;;;;;;;;;;;23687:42;24377:63;;25609:707;25725:4;;25759:34;-1:-1:-1;;;;;25759:19:0;;25787:4;25759:19;:34::i;:::-;25742:51;-1:-1:-1;25804:56:0;-1:-1:-1;;;;;25804:28:0;;23687:42;25742:51;25804:28;:56::i;:::-;25931:265;;;;;;;;;;;;;;;;;;;;;;;;;25871:43;;25931:265;;;25986:15;;;;;;25931:265;;25986:15;;;;25931:265;;;;;;;;;-1:-1:-1;;;25931:265:0;;;-1:-1:-1;26031:10:0;25931:265;;;;;;26070:19;:15;26088:1;26070:19;:::i;:::-;25931:265;;;;;;;;-1:-1:-1;;25931:265:0;;;;;26223:26;-1:-1:-1;;;26223:26:0;;25871:325;;-1:-1:-1;;;23687:42:0;;26223:18;;:26;;25871:325;;26223:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;26207:42;;26260:22;26273:8;26260:12;:22::i;:::-;26300:8;25609:707;-1:-1:-1;;;;;;;;25609:707:0:o;23309:85::-;22821:10;-1:-1:-1;;;;;22799:32:0;21331:42;-1:-1:-1;;;;;22799:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;22799:32:0;;22795:87;;22854:16;;-1:-1:-1;;;22854:16:0;;;;;;;;;;;22795:87;23374:10:::1;23353:33;27037:250:::0;27181:53;;-1:-1:-1;;;27181:53:0;;27148:4;;;;23778:42;;27181:23;;:53;;27205:15;;27222:11;;27181:53;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;27165:69;;27252:27;27257:11;27270:8;27252:4;:27::i;:::-;27245:34;;;27037:250;;;;;;;:::o;26553:249::-;26698:51;;-1:-1:-1;;;26698:51:0;;26664:4;;;;23778:42;;26698:22;;:51;;26721:15;;26738:10;;26698:51;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;26681:68;;26767:27;26772:9;26783:10;26767:4;:27::i;24752:601::-;24869:4;24886:57;-1:-1:-1;;;;;24886:28:0;;23687:42;24932:10;24886:28;:57::i;:::-;25015:250;;;;;;;;;;;;;;;;;;;;;;;;;24956:42;;25015:250;;;25069:15;;;;;;25015:250;;25069:15;;;;25015:250;;;;;;;;;-1:-1:-1;;;25015:250:0;;;-1:-1:-1;25114:10:0;25015:250;;;;;;25153:19;:15;25171:1;25153:19;:::i;:::-;25015:250;;;;;;;;25248:1;25015:250;;;;;25293:25;-1:-1:-1;;;25293:25:0;;24956:309;;-1:-1:-1;;;23687:42:0;;25293:17;;:25;;24956:309;;25293:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;22947:316::-;22675:10;-1:-1:-1;;;;;22653:32:0;21331:42;-1:-1:-1;;;;;22653:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;22653:32:0;;22649:87;;22708:16;;-1:-1:-1;;;22708:16:0;;;;;;;;;;;22649:87;23069:42:::1;-1:-1:-1::0;;;;;23059:52:0;::::1;;23055:201;;;23128:36;::::0;-1:-1:-1;;;;;23128:27:0;::::1;::::0;:36;::::1;;;::::0;23156:7;;23128:36:::1;::::0;;;23156:7;23128:27;:36;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;22947:316:::0;;;:::o;23055:201::-:1;23197:47;-1:-1:-1::0;;;;;23197:27:0;::::1;23225:9:::0;23236:7;23197:27:::1;:47::i;:::-;22947:316:::0;;;:::o;11308:252::-;11385:7;-1:-1:-1;;;;;11409:22:0;;9569:42;11409:22;11405:148;;;-1:-1:-1;;;;;;11455:12:0;;;11448:19;;11405:148;11507:34;;-1:-1:-1;;;11507:34:0;;-1:-1:-1;;;;;2859:32:1;;;11507:34:0;;;2841:51:1;11507:28:0;;;;;2814:18:1;;11507:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11500:41;;11405:148;11308:252;;;;:::o;7767:316::-;7915:58;;-1:-1:-1;;;;;6818:32:1;;7915:58:0;;;6800:51:1;7971:1:0;6867:18:1;;;6860:45;7888:86:0;;7908:5;;-1:-1:-1;;;7938:22:0;6773:18:1;;7915:58:0;;;;-1:-1:-1;;7915:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;7915:58:0;-1:-1:-1;;;;;;7915:58:0;;;;;;;;;;7888:19;:86::i;:::-;8012:62;;-1:-1:-1;;;;;7108:32:1;;8012:62:0;;;7090:51:1;7157:18;;;7150:34;;;7985:90:0;;8005:5;;-1:-1:-1;;;8035:22:0;7063:18:1;;8012:62:0;6916:274:1;27424:271:0;27484:51;;27492:10;;27513:21;27484:51;;;;;;;;;27513:21;27492:10;27484:51;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;27552:23:0;;23492:42;27552:23;27548:140;;27634:41;;-1:-1:-1;;;27634:41:0;;27669:4;27634:41;;;2841:51:1;27592:84:0;;27622:10;;-1:-1:-1;;;;;27634:26:0;;;;;2814:18:1;;27634:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;27592:29:0;;;:84;:29;:84::i;:::-;27424:271;:::o;19558:120::-;19617:9;19669:1;19643:23;19647:11;19651:1;19247:6;19647:3;:11::i;:::-;19660:5;19664:1;19660;:5;:::i;:::-;19643:3;:23::i;:::-;:27;;;;:::i;:::-;19639:31;19558:120;-1:-1:-1;;;19558:120:0:o;7153:211::-;7297:58;;-1:-1:-1;;;;;7108:32:1;;7297:58:0;;;7090:51:1;7157:18;;;7150:34;;;7270:86:0;;7290:5;;-1:-1:-1;;;7320:23:0;7063:18:1;;7297:58:0;6916:274:1;8903:468:0;8984:23;9010:106;9052:4;9010:106;;;;;;;;;;;;;;;;;9018:5;-1:-1:-1;;;;;9010:27:0;;;:106;;;;;:::i;:::-;9131:17;;8984:132;;-1:-1:-1;9131:21:0;9127:237;;9286:10;9275:30;;;;;;;;;;;;:::i;:::-;9267:85;;;;-1:-1:-1;;;9267:85:0;;7901:2:1;9267:85:0;;;7883:21:1;7940:2;7920:18;;;7913:30;7979:34;7959:18;;;7952:62;-1:-1:-1;;;8030:18:1;;;8023:40;8080:19;;9267:85:0;;;;;;;;18547:97;18605:9;18631:5;18635:1;18631;:5;:::i;18337:97::-;18395:9;18421:5;18425:1;18421;:5;:::i;3175:230::-;3312:12;3344:53;3367:6;3375:4;3381:1;3384:12;4298;4329:18;4340:6;4329:10;:18::i;:::-;4323:77;;4371:17;;-1:-1:-1;;;4371:17:0;;;;;;;;;;;4323:77;4473:12;4487:23;4514:6;-1:-1:-1;;;;;4514:11:0;4533:8;4543:4;4514:34;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4472:76;;;;4563:7;4559:595;;;4594:10;-1:-1:-1;4587:17:0;;-1:-1:-1;4587:17:0;4559:595;4708:17;;:21;4704:439;;4971:10;4965:17;5032:15;5019:10;5015:2;5011:19;5004:44;4704:439;5114:12;5107:20;;-1:-1:-1;;;5107:20:0;;;;;;;;:::i;1885:641::-;1945:4;2426:20;;2256:66;2475:23;;;;;;:42;;-1:-1:-1;;2502:15:0;;;2467:51;-1:-1:-1;;1885:641:0:o;14:131:1:-;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;150:936;247:6;255;263;271;279;332:3;320:9;311:7;307:23;303:33;300:53;;;349:1;346;339:12;300:53;388:9;375:23;407:31;432:5;407:31;:::i;:::-;457:5;-1:-1:-1;514:2:1;499:18;;486:32;527:33;486:32;527:33;:::i;:::-;579:7;-1:-1:-1;633:2:1;618:18;;605:32;;-1:-1:-1;688:2:1;673:18;;660:32;711:18;741:14;;;738:34;;;768:1;765;758:12;738:34;806:6;795:9;791:22;781:32;;851:7;844:4;840:2;836:13;832:27;822:55;;873:1;870;863:12;822:55;913:2;900:16;939:2;931:6;928:14;925:34;;;955:1;952;945:12;925:34;1000:7;995:2;986:6;982:2;978:15;974:24;971:37;968:57;;;1021:1;1018;1011:12;968:57;150:936;;;;-1:-1:-1;150:936:1;;-1:-1:-1;1052:2:1;1044:11;;1074:6;150:936;-1:-1:-1;;;150:936:1:o;1273:127::-;1334:10;1329:3;1325:20;1322:1;1315:31;1365:4;1362:1;1355:15;1389:4;1386:1;1379:15;1405:1266;1500:6;1508;1516;1524;1577:3;1565:9;1556:7;1552:23;1548:33;1545:53;;;1594:1;1591;1584:12;1545:53;1633:9;1620:23;1652:31;1677:5;1652:31;:::i;:::-;1702:5;-1:-1:-1;1759:2:1;1744:18;;1731:32;1772:33;1731:32;1772:33;:::i;:::-;1824:7;-1:-1:-1;1878:2:1;1863:18;;1850:32;;-1:-1:-1;1933:2:1;1918:18;;1905:32;1956:18;1986:14;;;1983:34;;;2013:1;2010;2003:12;1983:34;2051:6;2040:9;2036:22;2026:32;;2096:7;2089:4;2085:2;2081:13;2077:27;2067:55;;2118:1;2115;2108:12;2067:55;2154:2;2141:16;2176:2;2172;2169:10;2166:36;;;2182:18;;:::i;:::-;2257:2;2251:9;2225:2;2311:13;;-1:-1:-1;;2307:22:1;;;2331:2;2303:31;2299:40;2287:53;;;2355:18;;;2375:22;;;2352:46;2349:72;;;2401:18;;:::i;:::-;2441:10;2437:2;2430:22;2476:2;2468:6;2461:18;2516:7;2511:2;2506;2502;2498:11;2494:20;2491:33;2488:53;;;2537:1;2534;2527:12;2488:53;2593:2;2588;2584;2580:11;2575:2;2567:6;2563:15;2550:46;2638:1;2633:2;2628;2620:6;2616:15;2612:24;2605:35;2659:6;2649:16;;;;;;;1405:1266;;;;;;;:::o;2903:456::-;2980:6;2988;2996;3049:2;3037:9;3028:7;3024:23;3020:32;3017:52;;;3065:1;3062;3055:12;3017:52;3104:9;3091:23;3123:31;3148:5;3123:31;:::i;:::-;3173:5;-1:-1:-1;3230:2:1;3215:18;;3202:32;3243:33;3202:32;3243:33;:::i;:::-;2903:456;;3295:7;;-1:-1:-1;;;3349:2:1;3334:18;;;;3321:32;;2903:456::o;3816:127::-;3877:10;3872:3;3868:20;3865:1;3858:31;3908:4;3905:1;3898:15;3932:4;3929:1;3922:15;3948:128;3988:3;4019:1;4015:6;4012:1;4009:13;4006:39;;;4025:18;;:::i;:::-;-1:-1:-1;4061:9:1;;3948:128::o;4081:258::-;4153:1;4163:113;4177:6;4174:1;4171:13;4163:113;;;4253:11;;;4247:18;4234:11;;;4227:39;4199:2;4192:10;4163:113;;;4294:6;4291:1;4288:13;4285:48;;;-1:-1:-1;;4329:1:1;4311:16;;4304:27;4081:258::o;4344:257::-;4385:3;4423:5;4417:12;4450:6;4445:3;4438:19;4466:63;4522:6;4515:4;4510:3;4506:14;4499:4;4492:5;4488:16;4466:63;:::i;:::-;4583:2;4562:15;-1:-1:-1;;4558:29:1;4549:39;;;;4590:4;4545:50;;4344:257;-1:-1:-1;;4344:257:1:o;4606:479::-;4666:3;4710:5;4704:12;4737:4;4732:3;4725:17;4763:46;4803:4;4798:3;4794:14;4780:12;4763:46;:::i;:::-;4862:4;4851:16;;;4845:23;-1:-1:-1;;;;;4841:49:1;4825:14;;;4818:73;4940:4;4929:16;;;4923:23;4907:14;;;4900:47;4996:4;4985:16;;;4979:23;4963:14;;;4956:47;5052:4;5041:16;;;5035:23;5019:14;;;;5012:47;;;;-1:-1:-1;4751:58:1;;4606:479;-1:-1:-1;4606:479:1:o;5090:288::-;5289:2;5278:9;5271:21;5252:4;5309:63;5368:2;5357:9;5353:18;5345:6;5309:63;:::i;5383:184::-;5453:6;5506:2;5494:9;5485:7;5481:23;5477:32;5474:52;;;5522:1;5519;5512:12;5474:52;-1:-1:-1;5545:16:1;;5383:184;-1:-1:-1;5383:184:1:o;5572:251::-;5642:6;5695:2;5683:9;5674:7;5670:23;5666:32;5663:52;;;5711:1;5708;5701:12;5663:52;5743:9;5737:16;5762:31;5787:5;5762:31;:::i;5828:288::-;6003:2;5992:9;5985:21;5966:4;6023:44;6063:2;6052:9;6048:18;6040:6;6023:44;:::i;:::-;6015:52;;6103:6;6098:2;6087:9;6083:18;6076:34;5828:288;;;;;:::o;7195:217::-;7235:1;7261;7251:132;;7305:10;7300:3;7296:20;7293:1;7286:31;7340:4;7337:1;7330:15;7368:4;7365:1;7358:15;7251:132;-1:-1:-1;7397:9:1;;7195:217::o;7417:277::-;7484:6;7537:2;7525:9;7516:7;7512:23;7508:32;7505:52;;;7553:1;7550;7543:12;7505:52;7585:9;7579:16;7638:5;7631:13;7624:21;7617:5;7614:32;7604:60;;7660:1;7657;7650:12;8110:168;8150:7;8216:1;8212;8208:6;8204:14;8201:1;8198:21;8193:1;8186:9;8179:17;8175:45;8172:71;;;8223:18;;:::i;:::-;-1:-1:-1;8263:9:1;;8110:168::o;8283:274::-;8412:3;8450:6;8444:13;8466:53;8512:6;8507:3;8500:4;8492:6;8488:17;8466:53;:::i;:::-;8535:16;;;;;8283:274;-1:-1:-1;;8283:274:1:o;8562:219::-;8711:2;8700:9;8693:21;8674:4;8731:44;8771:2;8760:9;8756:18;8748:6;8731:44;:::i

Metadata Hash

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