Contract 0x003b18357460e789e711849749a793c430d14f97 2

 

Contract Overview

Balance:
0 ETH

ETH Value:
$0.00

Token:
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xcf83bd7b5494ad25694bcc456a120f1da62ba0ac6399511f7176ccfffda7accb0x60a060404998542021-09-12 6:49:08449 days 17 hrs ago0x1dc662d3d7de14a57cd369e3a9e774f8f80d4214 IN  Create: UniV3Adapter0 ETH0.016974143829 ETH
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0xc7ac3357c198f00b616652724642f865f9d8e35936c1f9408a8705c58f69e2e3439376892022-12-05 23:56:3914 mins ago 0x003b18357460e789e711849749a793c430d14f97 Tether: USDT Token0 ETH
0xc7ac3357c198f00b616652724642f865f9d8e35936c1f9408a8705c58f69e2e3439376892022-12-05 23:56:3914 mins ago 0x641c00a822e8b671738d32a431a4fb6074e5c79d 0x003b18357460e789e711849749a793c430d14f970 ETH
0xc7ac3357c198f00b616652724642f865f9d8e35936c1f9408a8705c58f69e2e3439376892022-12-05 23:56:3914 mins ago 0x003b18357460e789e711849749a793c430d14f970x641c00a822e8b671738d32a431a4fb6074e5c79d0 ETH
0xc7ac3357c198f00b616652724642f865f9d8e35936c1f9408a8705c58f69e2e3439376892022-12-05 23:56:3914 mins ago 0x003b18357460e789e711849749a793c430d14f97 Tether: USDT Token0 ETH
0xc7ac3357c198f00b616652724642f865f9d8e35936c1f9408a8705c58f69e2e3439376892022-12-05 23:56:3914 mins ago DODO: Proxy Route 0x003b18357460e789e711849749a793c430d14f970 ETH
0x409a125d2d21396dcb46060373043028c47b62b6150a09324dd51940b9a6e418439358642022-12-05 23:42:0929 mins ago 0x003b18357460e789e711849749a793c430d14f97 0x82af49447d8a07e3bd95bd0d56f35241523fbab10 ETH
0x409a125d2d21396dcb46060373043028c47b62b6150a09324dd51940b9a6e418439358642022-12-05 23:42:0929 mins ago 0x2f5e87c9312fa29aed5c179e456625d79015299c 0x003b18357460e789e711849749a793c430d14f970 ETH
0x409a125d2d21396dcb46060373043028c47b62b6150a09324dd51940b9a6e418439358642022-12-05 23:42:0929 mins ago 0x003b18357460e789e711849749a793c430d14f97 0x2f5e87c9312fa29aed5c179e456625d79015299c0 ETH
0x409a125d2d21396dcb46060373043028c47b62b6150a09324dd51940b9a6e418439358642022-12-05 23:42:0929 mins ago 0x003b18357460e789e711849749a793c430d14f97 0x82af49447d8a07e3bd95bd0d56f35241523fbab10 ETH
0x409a125d2d21396dcb46060373043028c47b62b6150a09324dd51940b9a6e418439358642022-12-05 23:42:0929 mins ago DODO: Proxy Route 0x003b18357460e789e711849749a793c430d14f970 ETH
0xf1d739de3de74c1330d6042249dd9f6af36ca033d35e212474f4575b145ab45f439344742022-12-05 23:31:4339 mins ago 0x003b18357460e789e711849749a793c430d14f97 Dopex: rDPX Token0 ETH
0xf1d739de3de74c1330d6042249dd9f6af36ca033d35e212474f4575b145ab45f439344742022-12-05 23:31:4339 mins ago 0x310a09b51501d893988401fba75c47dc59f1b42a 0x003b18357460e789e711849749a793c430d14f970 ETH
0xf1d739de3de74c1330d6042249dd9f6af36ca033d35e212474f4575b145ab45f439344742022-12-05 23:31:4339 mins ago 0x003b18357460e789e711849749a793c430d14f97 0x310a09b51501d893988401fba75c47dc59f1b42a0 ETH
0xf1d739de3de74c1330d6042249dd9f6af36ca033d35e212474f4575b145ab45f439344742022-12-05 23:31:4339 mins ago 0x003b18357460e789e711849749a793c430d14f97 Dopex: rDPX Token0 ETH
0xf1d739de3de74c1330d6042249dd9f6af36ca033d35e212474f4575b145ab45f439344742022-12-05 23:31:4339 mins ago DODO: Proxy Route 0x003b18357460e789e711849749a793c430d14f970 ETH
0xdadbc66ba5bac9f2222f73eaddba1fe2fe04849b92169c68d0dc5fa6c5a09198439333612022-12-05 23:23:1947 mins ago 0x003b18357460e789e711849749a793c430d14f97 Tether: USDT Token0 ETH
0xdadbc66ba5bac9f2222f73eaddba1fe2fe04849b92169c68d0dc5fa6c5a09198439333612022-12-05 23:23:1947 mins ago 0x641c00a822e8b671738d32a431a4fb6074e5c79d 0x003b18357460e789e711849749a793c430d14f970 ETH
0xdadbc66ba5bac9f2222f73eaddba1fe2fe04849b92169c68d0dc5fa6c5a09198439333612022-12-05 23:23:1947 mins ago 0x003b18357460e789e711849749a793c430d14f970x641c00a822e8b671738d32a431a4fb6074e5c79d0 ETH
0xdadbc66ba5bac9f2222f73eaddba1fe2fe04849b92169c68d0dc5fa6c5a09198439333612022-12-05 23:23:1947 mins ago 0x003b18357460e789e711849749a793c430d14f97 Tether: USDT Token0 ETH
0xdadbc66ba5bac9f2222f73eaddba1fe2fe04849b92169c68d0dc5fa6c5a09198439333612022-12-05 23:23:1947 mins ago DODO: Proxy Route 0x003b18357460e789e711849749a793c430d14f970 ETH
0x3b7edda6e071391ad75f0ce6e2793efeed9458c80995fd01d182e12367ba0c11439284452022-12-05 22:49:381 hr 21 mins ago 0x003b18357460e789e711849749a793c430d14f97 0x82af49447d8a07e3bd95bd0d56f35241523fbab10 ETH
0x3b7edda6e071391ad75f0ce6e2793efeed9458c80995fd01d182e12367ba0c11439284452022-12-05 22:49:381 hr 21 mins ago 0xb7c9609cc9083e135d9315c355db4334c07e7c2c 0x003b18357460e789e711849749a793c430d14f970 ETH
0x3b7edda6e071391ad75f0ce6e2793efeed9458c80995fd01d182e12367ba0c11439284452022-12-05 22:49:381 hr 21 mins ago 0x003b18357460e789e711849749a793c430d14f97 0xb7c9609cc9083e135d9315c355db4334c07e7c2c0 ETH
0x3b7edda6e071391ad75f0ce6e2793efeed9458c80995fd01d182e12367ba0c11439284452022-12-05 22:49:381 hr 21 mins ago 0x003b18357460e789e711849749a793c430d14f97 0x82af49447d8a07e3bd95bd0d56f35241523fbab10 ETH
0x3b7edda6e071391ad75f0ce6e2793efeed9458c80995fd01d182e12367ba0c11439284452022-12-05 22:49:381 hr 21 mins ago DODO: Proxy Route 0x003b18357460e789e711849749a793c430d14f970 ETH
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
UniV3Adapter

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 Arbiscan on 2021-09-12
*/

/**
 *Submitted for verification at Etherscan.io on 2021-07-07
*/

// File: contracts/SmartRoute/intf/IDODOAdapter.sol

/*

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

*/

pragma solidity 0.6.9;
pragma experimental ABIEncoderV2;

interface IDODOAdapter {
    
    function sellBase(address to, address pool, bytes memory data) external;

    function sellQuote(address to, address pool, bytes memory data) external;
}

// File: contracts/SmartRoute/intf/IUniswapV3SwapCallback.sol



/// @title Callback for IUniswapV3PoolActions#swap
/// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface
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;
}

// File: contracts/SmartRoute/intf/IUniV3.sol



interface IUniV3 {
    function swap(
        address recipient,
        bool zeroForOne,
        int256 amountSpecified,
        uint160 sqrtPriceLimitX96,
        bytes calldata data
    ) external returns (int256 amount0, int256 amount1);

}

// 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/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/SmartRoute/lib/UniversalERC20.sol






library UniversalERC20 {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    IERC20 private constant ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);

    function universalTransfer(
        IERC20 token,
        address payable to,
        uint256 amount
    ) internal {
        if (amount > 0) {
            if (isETH(token)) {
                to.transfer(amount);
            } else {
                token.safeTransfer(to, amount);
            }
        }
    }

    function universalApproveMax(
        IERC20 token,
        address to,
        uint256 amount
    ) internal {
        uint256 allowance = token.allowance(address(this), to);
        if (allowance < amount) {
            if (allowance > 0) {
                token.safeApprove(to, 0);
            }
            token.safeApprove(to, uint256(-1));
        }
    }

    function universalBalanceOf(IERC20 token, address who) internal view returns (uint256) {
        if (isETH(token)) {
            return who.balance;
        } else {
            return token.balanceOf(who);
        }
    }

    function tokenBalanceOf(IERC20 token, address who) internal view returns (uint256) {
        return token.balanceOf(who);
    }

    function isETH(IERC20 token) internal pure returns (bool) {
        return token == ETH_ADDRESS;
    }
}

// File: contracts/lib/TickMath.sol



/// @title Math library for computing sqrt prices from ticks and vice versa
/// @notice Computes sqrt price for ticks of size 1.0001, i.e. sqrt(1.0001^tick) as fixed point Q64.96 numbers. Supports
/// prices between 2**-128 and 2**128
library TickMath {
    /// @dev The minimum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**-128
    int24 internal constant MIN_TICK = -887272;
    /// @dev The maximum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**128
    int24 internal constant MAX_TICK = -MIN_TICK;

    /// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK)
    uint160 internal constant MIN_SQRT_RATIO = 4295128739;
    /// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK)
    uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;

    /// @notice Calculates sqrt(1.0001^tick) * 2^96
    /// @dev Throws if |tick| > max tick
    /// @param tick The input tick for the above formula
    /// @return sqrtPriceX96 A Fixed point Q64.96 number representing the sqrt of the ratio of the two assets (token1/token0)
    /// at the given tick
    function getSqrtRatioAtTick(int24 tick) internal pure returns (uint160 sqrtPriceX96) {
        uint256 absTick = tick < 0 ? uint256(-int256(tick)) : uint256(int256(tick));
        require(absTick <= uint256(MAX_TICK), 'T');

        uint256 ratio = absTick & 0x1 != 0 ? 0xfffcb933bd6fad37aa2d162d1a594001 : 0x100000000000000000000000000000000;
        if (absTick & 0x2 != 0) ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
        if (absTick & 0x4 != 0) ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
        if (absTick & 0x8 != 0) ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
        if (absTick & 0x10 != 0) ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
        if (absTick & 0x20 != 0) ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
        if (absTick & 0x40 != 0) ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
        if (absTick & 0x80 != 0) ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
        if (absTick & 0x100 != 0) ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
        if (absTick & 0x200 != 0) ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
        if (absTick & 0x400 != 0) ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
        if (absTick & 0x800 != 0) ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
        if (absTick & 0x1000 != 0) ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
        if (absTick & 0x2000 != 0) ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
        if (absTick & 0x4000 != 0) ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
        if (absTick & 0x8000 != 0) ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
        if (absTick & 0x10000 != 0) ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
        if (absTick & 0x20000 != 0) ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
        if (absTick & 0x40000 != 0) ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
        if (absTick & 0x80000 != 0) ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;

        if (tick > 0) ratio = type(uint256).max / ratio;

        // this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
        // we then downcast because we know the result always fits within 160 bits due to our tick input constraint
        // we round up in the division so getTickAtSqrtRatio of the output price is always consistent
        sqrtPriceX96 = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1));
    }

    /// @notice Calculates the greatest tick value such that getRatioAtTick(tick) <= ratio
    /// @dev Throws in case sqrtPriceX96 < MIN_SQRT_RATIO, as MIN_SQRT_RATIO is the lowest value getRatioAtTick may
    /// ever return.
    /// @param sqrtPriceX96 The sqrt ratio for which to compute the tick as a Q64.96
    /// @return tick The greatest tick for which the ratio is less than or equal to the input ratio
    function getTickAtSqrtRatio(uint160 sqrtPriceX96) internal pure returns (int24 tick) {
        // second inequality must be < because the price can never reach the price at the max tick
        require(sqrtPriceX96 >= MIN_SQRT_RATIO && sqrtPriceX96 < MAX_SQRT_RATIO, 'R');
        uint256 ratio = uint256(sqrtPriceX96) << 32;

        uint256 r = ratio;
        uint256 msb = 0;

        assembly {
            let f := shl(7, gt(r, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
            msb := or(msb, f)
            r := shr(f, r)
        }
        assembly {
            let f := shl(6, gt(r, 0xFFFFFFFFFFFFFFFF))
            msb := or(msb, f)
            r := shr(f, r)
        }
        assembly {
            let f := shl(5, gt(r, 0xFFFFFFFF))
            msb := or(msb, f)
            r := shr(f, r)
        }
        assembly {
            let f := shl(4, gt(r, 0xFFFF))
            msb := or(msb, f)
            r := shr(f, r)
        }
        assembly {
            let f := shl(3, gt(r, 0xFF))
            msb := or(msb, f)
            r := shr(f, r)
        }
        assembly {
            let f := shl(2, gt(r, 0xF))
            msb := or(msb, f)
            r := shr(f, r)
        }
        assembly {
            let f := shl(1, gt(r, 0x3))
            msb := or(msb, f)
            r := shr(f, r)
        }
        assembly {
            let f := gt(r, 0x1)
            msb := or(msb, f)
        }

        if (msb >= 128) r = ratio >> (msb - 127);
        else r = ratio << (127 - msb);

        int256 log_2 = (int256(msb) - 128) << 64;

        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(63, f))
            r := shr(f, r)
        }
        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(62, f))
            r := shr(f, r)
        }
        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(61, f))
            r := shr(f, r)
        }
        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(60, f))
            r := shr(f, r)
        }
        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(59, f))
            r := shr(f, r)
        }
        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(58, f))
            r := shr(f, r)
        }
        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(57, f))
            r := shr(f, r)
        }
        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(56, f))
            r := shr(f, r)
        }
        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(55, f))
            r := shr(f, r)
        }
        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(54, f))
            r := shr(f, r)
        }
        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(53, f))
            r := shr(f, r)
        }
        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(52, f))
            r := shr(f, r)
        }
        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(51, f))
            r := shr(f, r)
        }
        assembly {
            r := shr(127, mul(r, r))
            let f := shr(128, r)
            log_2 := or(log_2, shl(50, f))
        }

        int256 log_sqrt10001 = log_2 * 255738958999603826347141; // 128.128 number

        int24 tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);
        int24 tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);

        tick = tickLow == tickHi ? tickLow : getSqrtRatioAtTick(tickHi) <= sqrtPriceX96 ? tickHi : tickLow;
    }
}

// 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/SmartRoute/adapter/UniV3Adapter.sol











//import {TickMath} from '@uniswap/v3-core/contracts/libraries/TickMath.sol';

// to adapter like dodo V1
contract UniV3Adapter is IDODOAdapter, IUniswapV3SwapCallback {
    using SafeMath for uint;

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

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

    constructor (
        address payable weth
    ) public {
        _WETH_ = weth;
    }

    function _uniV3Swap(address to, address pool, uint160 sqrtX96, bytes memory data) internal {
        (address fromToken, address toToken, uint24 fee) = abi.decode(data, (address, address, uint24));
        
        uint256 sellAmount = IERC20(fromToken).balanceOf(address(this));
        bool zeroForOne = fromToken < toToken;

        // transfer
        //IERC20(fromToken).transfer(pool, sellAmount);
        // swap
        IUniV3(pool).swap(
            to, 
            zeroForOne, 
            int256(sellAmount), 
            sqrtX96 == 0
                ? (zeroForOne ? TickMath.MIN_SQRT_RATIO + 1 : TickMath.MAX_SQRT_RATIO - 1)
                : sqrtX96,
            data
        );
    }

    function sellBase(address to, address pool, bytes memory moreInfo) external override {
        (uint160 sqrtX96, bytes memory data) = abi.decode(moreInfo, (uint160, bytes));
        _uniV3Swap(to, pool, sqrtX96, data);
    }

    function sellQuote(address to, address pool, bytes memory moreInfo) external override {
        (uint160 sqrtX96, bytes memory data) = abi.decode(moreInfo, (uint160, bytes));
        _uniV3Swap(to, pool, sqrtX96, data);
    }


    // for uniV3 callback

    function uniswapV3SwapCallback(
        int256 amount0Delta,
        int256 amount1Delta,
        bytes calldata _data
    ) external override {
        require(amount0Delta > 0 || amount1Delta > 0); // swaps entirely within 0-liquidity regions are not supported
        (address tokenIn, address tokenOut, uint24 fee) = abi.decode(_data, (address, address, uint24));

        (bool isExactInput, uint256 amountToPay) =
            amount0Delta > 0
                ? (tokenIn < tokenOut, uint256(amount0Delta))
                : (tokenOut < tokenIn, uint256(amount1Delta));
        if (isExactInput) {
            pay(tokenIn, address(this), msg.sender, amountToPay);
        } else {           
            tokenIn = tokenOut; // swap in/out because exact output swaps are reversed
            pay(tokenIn, address(this), msg.sender, amountToPay);
        }
    }

    /// @param token The token to pay
    /// @param payer The entity that must pay
    /// @param recipient The entity that will receive payment
    /// @param value The amount to pay
    function pay(
        address token,
        address payer,
        address recipient,
        uint256 value
    ) internal {
        if (token == _WETH_ && address(this).balance >= value) {
            // pay with WETH9
            IWETH(_WETH_).deposit{value: value}(); // wrap only what is needed to pay
            IWETH(_WETH_).transfer(recipient, value);
        } else if (payer == address(this)) {
            // pay with tokens already in the contract (for the exact input multihop case)
            SafeERC20.safeTransfer(IERC20(token), recipient, value);
        } else {
            // pull payment
            SafeERC20.safeTransferFrom(IERC20(token), payer, recipient, value);
        }
    }

}

Contract ABI

[{"inputs":[{"internalType":"address payable","name":"weth","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"_WETH_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"bytes","name":"moreInfo","type":"bytes"}],"name":"sellBase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"bytes","name":"moreInfo","type":"bytes"}],"name":"sellQuote","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"uniswapV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

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

00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1

-----Decoded View---------------
Arg [0] : weth (address): 0x82af49447d8a07e3bd95bd0d56f35241523fbab1

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000082af49447d8a07e3bd95bd0d56f35241523fbab1


Deployed ByteCode Sourcemap

20311:3398:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20538:31;;;:::i;:::-;;;;;;;;;;;;;;;;21400:227;;;;;;;;;:::i;:::-;;21902:882;;;;;;;;;:::i;20538:31::-;;;:::o;21400:227::-;21497:15;21514:17;21546:8;21535:38;;;;;;;;;;;;;;21496:77;;;;21584:35;21595:2;21599:4;21605:7;21614:4;21584:10;:35::i;:::-;21400:227;;;;;:::o;21902:882::-;22083:1;22068:12;:16;:36;;;;22103:1;22088:12;:16;22068:36;22060:45;;;;;;22180:15;;;22229:45;;;;22240:5;22229:45;;;22179:95;;;;;;22288:17;22307:19;22358:1;22343:12;:16;:142;;22454:7;-1:-1:-1;;;;;22443:18:0;:8;-1:-1:-1;;;;;22443:18:0;;22471:12;22343:142;;;22390:8;-1:-1:-1;;;;;22380:18:0;:7;-1:-1:-1;;;;;22380:18:0;;22408:12;22343:142;22287:198;;;;22500:12;22496:281;;;22529:52;22533:7;22550:4;22557:10;22569:11;22529:3;:52::i;:::-;22496:281;;;22635:8;22625:18;;22713:52;22717:7;22734:4;22741:10;22753:11;22713:3;:52::i;:::-;21902:882;;;;;;;;;:::o;20676:716::-;20779:17;20798:15;20815:10;20840:4;20829:44;;;;;;;;;;;;;;20778:95;;;;;;20894:18;20922:9;-1:-1:-1;;;;;20915:27:0;;20951:4;20915:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20894:63;;20968:15;20998:7;-1:-1:-1;;;;;20986:19:0;:9;-1:-1:-1;;;;;20986:19:0;;20968:37;;21120:4;-1:-1:-1;;;;;21113:17:0;;21145:2;21163:10;21196;21223:7;-1:-1:-1;;;;;21223:12:0;21234:1;21223:12;:131;;21347:7;21223:131;;;21256:10;:70;;21299:27;21256:70;;;21269:27;21256:70;21369:4;21113:271;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20676:716;;;;;;;;;:::o;22981:723::-;23134:6;-1:-1:-1;;;;;23125:15:0;:5;-1:-1:-1;;;;;23125:15:0;;:49;;;;;23169:5;23144:21;:30;;23125:49;23121:576;;;23228:6;-1:-1:-1;;;;;23222:21:0;;23251:5;23222:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;23309:40:0;;-1:-1:-1;;;23309:40:0;;-1:-1:-1;;;;;23315:6:0;23309:22;;-1:-1:-1;23309:22:0;;-1:-1:-1;23309:40:0;;-1:-1:-1;23332:9:0;;23343:5;;23309:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23121:576;;;-1:-1:-1;;;;;23371:22:0;;23388:4;23371:22;23367:330;;;23502:55;23532:5;23540:9;23551:5;23502:22;:55::i;:::-;23367:330;;;23619:66;23653:5;23661;23668:9;23679:5;23619:26;:66::i;:::-;22981:723;;;;:::o;6547:211::-;6664:86;6684:5;6714:23;;;6739:2;6743:5;6691:58;;;;;;;;;;;;;;-1:-1:-1;;6691:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;6691:58:0;-1:-1:-1;;;;;;6691:58:0;;;;;;;;;;6664:19;:86::i;:::-;6547:211;;;:::o;6766:285::-;6910:133;6944:5;6987:27;;;7016:4;7022:2;7026:5;6964:68;;;;;;;;;;;8120:1046;8780:12;8794:23;8829:5;-1:-1:-1;;;;;8821:19:0;8841:4;8821:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8779:67;;;;8865:7;8857:52;;;;-1:-1:-1;;;8857:52:0;;;;;;;;;;;;;;;;;8926:17;;:21;8922:237;;9081:10;9070:30;;;;;;;;;;;;;;9062:85;;;;-1:-1:-1;;;9062:85:0;;;;;;;;2675:521:-1;;;;2828:2;2816:9;2807:7;2803:23;2799:32;2796:2;;;-1:-1;;2834:12;2796:2;230:6;217:20;242:41;277:5;242:41;;;2886:71;-1:-1;2994:2;3041:22;;217:20;242:41;217:20;242:41;;;3002:71;-1:-1;3110:2;3148:22;;2326:20;2351:32;2326:20;2351:32;;;3118:62;;;;2790:406;;;;;;3203:565;;;;3367:2;3355:9;3346:7;3342:23;3338:32;3335:2;;;-1:-1;;3373:12;3335:2;387:6;381:13;399:41;434:5;399:41;;;3544:2;3602:22;;381:13;3425:82;;-1:-1;399:41;381:13;399:41;;;3671:2;3720:22;;2472:13;3552:82;;-1:-1;2490:32;2472:13;2490:32;;3775:595;;;;3922:2;3910:9;3901:7;3897:23;3893:32;3890:2;;;-1:-1;;3928:12;3890:2;85:6;72:20;97:33;124:5;97:33;;;3980:63;-1:-1;4080:2;4119:22;;72:20;97:33;72:20;97:33;;;4088:63;-1:-1;4216:2;4201:18;;4188:32;4240:18;4229:30;;4226:2;;;-1:-1;;4262:12;4226:2;4337:6;4326:9;4322:22;1047:3;1040:4;1032:6;1028:17;1024:27;1014:2;;-1:-1;;1055:12;1014:2;1102:6;1089:20;1075:34;;1124:64;1139:48;1180:6;1139:48;;;1124:64;;;1208:6;1201:5;1194:21;1312:3;4080:2;1303:6;1236;1294:16;;1291:25;1288:2;;;-1:-1;;1319:12;1288:2;13322:6;4080:2;1236:6;1232:17;4080:2;1270:5;1266:16;13299:30;-1:-1;4080:2;13369:6;1270:5;13360:16;;13353:27;4282:72;;;;;;3884:486;;;;;;4377:257;;4489:2;4477:9;4468:7;4464:23;4460:32;4457:2;;;-1:-1;;4495:12;4457:2;533:6;527:13;14121:5;12836:13;12829:21;14099:5;14096:32;14086:2;;-1:-1;;14132:12;14086:2;4547:71;4451:183;-1:-1;;;4451:183;4641:395;;;4771:2;4759:9;4750:7;4746:23;4742:32;4739:2;;;-1:-1;;4777:12;4739:2;-1:-1;;2057:13;;4939:2;4988:22;;;2057:13;;;;;-1:-1;4733:303;5043:611;;;;;5198:2;5186:9;5177:7;5173:23;5169:32;5166:2;;;-1:-1;;5204:12;5166:2;1924:6;1911:20;5256:62;;5355:2;5397:9;5393:22;1911:20;5363:62;;5490:2;5479:9;5475:18;5462:32;5514:18;;5506:6;5503:30;5500:2;;;-1:-1;;5536:12;5500:2;5621:6;5610:9;5606:22;715:3;708:4;700:6;696:17;692:27;682:2;;-1:-1;;723:12;682:2;766:6;753:20;743:30;;5514:18;785:6;782:30;779:2;;;-1:-1;;815:12;779:2;910:3;5355:2;890:17;851:6;876:32;;873:41;870:2;;;-1:-1;;917:12;870:2;5160:494;;;;-1:-1;;5355:2;847:17;;;;-1:-1;;;5160:494;5661:496;;;5802:2;5790:9;5781:7;5777:23;5773:32;5770:2;;;-1:-1;;5808:12;5770:2;2203:6;2197:13;2215:33;2242:5;2215:33;;;5992:2;5977:18;;5971:25;5860:74;;-1:-1;6016:18;6005:30;;6002:2;;;-1:-1;;6038:12;6002:2;6124:6;6113:9;6109:22;1507:3;1500:4;1492:6;1488:17;1484:27;1474:2;;-1:-1;;1515:12;1474:2;1555:6;1549:13;1535:27;;1577:64;1592:48;1633:6;1592:48;;1577:64;1661:6;1654:5;1647:21;1765:3;5992:2;1756:6;1689;1747:16;;1744:25;1741:2;;;-1:-1;;1772:12;1741:2;1792:39;1824:6;5992:2;1723:5;1719:16;5992:2;1689:6;1685:17;1792:39;;;6058:83;;;;;;5764:393;;;;;;6164:263;;6279:2;6267:9;6258:7;6254:23;6250:32;6247:2;;;-1:-1;;6285:12;6247:2;-1:-1;2612:13;;6241:186;-1:-1;6241:186;8464:271;;7175:5;12029:12;7286:52;7331:6;7326:3;7319:4;7312:5;7308:16;7286:52;;;7350:16;;;;;8598:137;-1:-1;;8598:137;8742:222;-1:-1;;;;;13002:54;;;;6505:37;;8869:2;8854:18;;8840:124;8971:444;-1:-1;;;;;13002:54;;;6505:37;;13002:54;;;;9318:2;9303:18;;6505:37;9401:2;9386:18;;7447:36;;;;9154:2;9139:18;;9125:290;9422:736;;4240:18;;13013:42;;;;13006:5;13002:54;6512:3;6505:37;6646:5;12836:13;12829:21;9830:2;9819:9;9815:18;6619:34;7476:5;9911:2;9900:9;9896:18;7447:36;13013:42;8325:5;13002:54;9994:2;9983:9;9979:18;8295:37;;9671:3;10031;10020:9;10016:19;10009:49;6807:5;12029:12;12185:6;9671:3;9660:9;9656:19;12173;6900:52;6945:6;12213:14;9660:9;12213:14;9830:2;6926:5;6922:16;6900:52;;;13755:7;13739:14;-1:-1;;13735:28;6964:39;;;;12213:14;6964:39;;9642:516;-1:-1;;;;;;9642:516;10165:333;-1:-1;;;;;13002:54;;;;6505:37;;10484:2;10469:18;;7447:36;10320:2;10305:18;;10291:207;10505:416;10705:2;10719:47;;;10690:18;;;12173:19;7756:34;12213:14;;;7736:55;7810:12;;;10676:245;10928:416;11128:2;11142:47;;;8061:2;11113:18;;;12173:19;8097:34;12213:14;;;8077:55;-1:-1;;;8152:12;;;8145:34;8198:12;;;11099:245;11351:256;11413:2;11407:9;11439:17;;;11514:18;11499:34;;11535:22;;;11496:62;11493:2;;;11571:1;;11561:12;11493:2;11413;11580:22;11391:216;;-1:-1;11391:216;11614:321;;11757:18;11749:6;11746:30;11743:2;;;-1:-1;;11779:12;11743:2;-1:-1;13755:7;11833:17;-1:-1;;11829:33;11920:4;11910:15;;11680:255;13395:268;13460:1;13467:101;13481:6;13478:1;13475:13;13467:101;;;13548:11;;;13542:18;13529:11;;;13522:39;13503:2;13496:10;13467:101;;;13583:6;13580:1;13577:13;13574:2;;;-1:-1;;13460:1;13630:16;;13623:27;13444:219;13776:117;-1:-1;;;;;13002:54;;13835:35;;13825:2;;13884:1;;13874:12;13825:2;13819:74;;14404:115;13140:8;14489:5;13129:20;14465:5;14462:34;14452:2;;14510:1;;14500:12

Metadata Hash

7f6d02cc7d3f962618c3fac9c7ee47d6241157aa562c6925186de8e49c3c186d
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.