Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at optimistic.etherscan.io on 2023-04-20
*/

// 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/external/uniswap/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/external/uniswap/PoolAddress.sol



/// @title Provides functions for deriving a pool address from the factory, tokens, and the fee
library PoolAddress {
    bytes32 internal constant POOL_INIT_CODE_HASH = 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54;

    /// @notice The identifying key of the pool
    struct PoolKey {
        address token0;
        address token1;
        uint24 fee;
    }

    /// @notice Returns PoolKey: the ordered tokens with the matched fee levels
    /// @param tokenA The first token of a pool, unsorted
    /// @param tokenB The second token of a pool, unsorted
    /// @param fee The fee level of the pool
    /// @return Poolkey The pool details with ordered token0 and token1 assignments
    function getPoolKey(
        address tokenA,
        address tokenB,
        uint24 fee
    ) internal pure returns (PoolKey memory) {
        if (tokenA > tokenB) (tokenA, tokenB) = (tokenB, tokenA);
        return PoolKey({token0: tokenA, token1: tokenB, fee: fee});
    }

    /// @notice Deterministically computes the pool address given the factory and PoolKey
    /// @param factory The Uniswap V3 factory contract address
    /// @param key The PoolKey
    /// @return pool The contract address of the V3 pool
    function computeAddress(address factory, PoolKey memory key) internal pure returns (address pool) {
        require(key.token0 < key.token1);
        pool = address(
            uint256(
                keccak256(
                    abi.encodePacked(
                        hex'ff',
                        factory,
                        keccak256(abi.encode(key.token0, key.token1, key.fee)),
                        POOL_INIT_CODE_HASH
                    )
                )
            )
        );
    }
}

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













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

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

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

    constructor (
        address payable weth,
        address factory
    ) public {
        _WETH_ = weth;
        _V3_FACTORY_ = factory;
        initOwner(msg.sender);
    }

    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;

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

        // check if use all from tokem
        uint256 leftSellAmount = IERC20(fromToken).balanceOf(address(this));
        if(leftSellAmount > 0) {
            SafeERC20.safeTransfer(IERC20(fromToken), tx.origin, leftSellAmount);
        }
    }

    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));
        // verifyCallback
        address poolAddress = PoolAddress.computeAddress(_V3_FACTORY_, PoolAddress.getPoolKey(tokenIn, tokenOut, fee));
        require(msg.sender == poolAddress || msg.sender == _OWNER_, "not available call address");

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address payable","name":"weth","type":"address"},{"internalType":"address","name":"factory","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferPrepared","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"_NEW_OWNER_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_OWNER_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_V3_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":[],"name":"claimOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"initOwner","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":"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":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","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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

00000000000000000000000042000000000000000000000000000000000000060000000000000000000000001f98431c8ad98523631ae4a59f267346ea31f984

-----Decoded View---------------
Arg [0] : weth (address): 0x4200000000000000000000000000000000000006
Arg [1] : factory (address): 0x1F98431c8aD98523631AE4a59f267346ea31F984

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000004200000000000000000000000000000000000006
Arg [1] : 0000000000000000000000001f98431c8ad98523631ae4a59f267346ea31f984

23377:3969:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22726:127;;;;;;;;;:::i;:::-;;23626:31;;;:::i;:::-;;;;;;;;;;;;;;;;22093:22;;;:::i;23664:37::-;;;:::i;24793:227::-;;;;;;;;;:::i;23032:228::-;;;:::i;22122:26::-;;;:::i;22861:163::-;;;;;;;;;:::i;25293:1130::-;;;;;;;;;:::i;22726:127::-;22515:13;;-1:-1:-1;;;22515:13:0;;;;22514:14;22506:43;;;;-1:-1:-1;;;22506:43:0;;;;;;;;;;;;;;;;;22812:4:::1;22796:20:::0;;-1:-1:-1;;;;22796:20:0::1;-1:-1:-1::0;;;22796:20:0::1;::::0;;;22827:18;;-1:-1:-1;;;;;22827:18:0;;::::1;-1:-1:-1::0;;;;;;22827:18:0;;::::1;::::0;;;::::1;::::0;;22726:127::o;23626:31::-;;;:::o;22093:22::-;;;-1:-1:-1;;;;;22093:22:0;;:::o;23664:37::-;;;:::o;24793:227::-;24890:15;24907:17;24939:8;24928:38;;;;;;;;;;;;;;24889:77;;;;24977:35;24988:2;24992:4;24998:7;25007:4;24977:10;:35::i;:::-;24793:227;;;;;:::o;23032:228::-;23098:11;;-1:-1:-1;;;;;23098:11:0;23084:10;:25;23076:51;;;;-1:-1:-1;;;23076:51:0;;;;;;;;;23173:11;;;23164:7;;23143:42;;-1:-1:-1;;;;;23173:11:0;;;;23164:7;;;;23143:42;;;23206:11;;;;23196:21;;-1:-1:-1;;;;;;23196:21:0;;;-1:-1:-1;;;;;23206:11:0;;23196:21;;;;23228:24;;;23032:228::o;22122:26::-;;;-1:-1:-1;;;;;22122:26:0;;:::o;22861:163::-;22631:7;;-1:-1:-1;;;;;22631:7:0;22617:10;:21;22609:43;;;;-1:-1:-1;;;22609:43:0;;;;;;;;;22965:7:::1;::::0;;22939:44:::1;::::0;-1:-1:-1;;;;;22939:44:0;;::::1;::::0;22965:7;::::1;::::0;22939:44:::1;::::0;::::1;22994:11;:22:::0;;-1:-1:-1;;;;;;22994:22:0::1;-1:-1:-1::0;;;;;22994:22:0;;;::::1;::::0;;;::::1;::::0;;22861:163::o;25293:1130::-;25474:1;25459:12;:16;:36;;;;25494:1;25479:12;:16;25459:36;25451:45;;;;;;25571:15;;;25620:45;;;;25631:5;25620:45;;;25570:95;;;;;;25703:19;25725:88;25752:12;25766:46;25789:7;25798:8;25808:3;25766:22;:46::i;:::-;25725:26;:88::i;:::-;25703:110;-1:-1:-1;25832:10:0;-1:-1:-1;;;;;25832:25:0;;;;:50;;-1:-1:-1;25875:7:0;;-1:-1:-1;;;;;25875:7:0;25861:10;:21;25832:50;25824:89;;;;-1:-1:-1;;;25824:89:0;;;;;;;;;25927:17;25946:19;25997:1;25982:12;:16;:142;;26093:7;-1:-1:-1;;;;;26082:18:0;:8;-1:-1:-1;;;;;26082:18:0;;26110:12;25982:142;;;26029:8;-1:-1:-1;;;;;26019:18:0;:7;-1:-1:-1;;;;;26019:18:0;;26047:12;25982:142;25926:198;;;;26139:12;26135:281;;;26168:52;26172:7;26189:4;26196:10;26208:11;26168:3;:52::i;:::-;26135:281;;;26274:8;26264:18;;26352:52;26356:7;26373:4;26380:10;26392:11;26352:3;:52::i;:::-;25293:1130;;;;;;;;;;:::o;23899:886::-;24002:17;24021:15;24038:10;24063:4;24052:44;;;;;;;;;;;;;;24001:95;;;;;;24117:18;24145:9;-1:-1:-1;;;;;24138:27:0;;24174:4;24138:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24117:63;;24191:15;24221:7;-1:-1:-1;;;;;24209:19:0;:9;-1:-1:-1;;;;;24209:19:0;;24191:37;;24265:4;-1:-1:-1;;;;;24258:17:0;;24290:2;24308:10;24341;24368:7;-1:-1:-1;;;;;24368:12:0;24379:1;24368:12;:131;;24492:7;24368:131;;;24401:10;:70;;24444:27;24401:70;;;24414:27;24401:70;24514:4;24258:271;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;24607:42:0;;-1:-1:-1;;;24607:42:0;;24582:22;;-1:-1:-1;;;;;24607:27:0;;;;;:42;;24643:4;;24607:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24582:67;-1:-1:-1;24663:18:0;;24660:118;;24698:68;24728:9;24740;24751:14;24698:22;:68::i;20838:281::-;20959:14;;:::i;:::-;20999:6;-1:-1:-1;;;;;20990:15:0;:6;-1:-1:-1;;;;;20990:15:0;;20986:56;;;21027:6;;21035;20986:56;-1:-1:-1;21060:51:0;;;;;;;;-1:-1:-1;;;;;21060:51:0;;;;;;;;;;;;;;;;;;;;;;;20838:281::o;21372:526::-;21456:12;21502:3;:10;;;-1:-1:-1;;;;;21489:23:0;:3;:10;;;-1:-1:-1;;;;;21489:23:0;;21481:32;;;;;;21688:7;21743:3;:10;;;21755:3;:10;;;21767:3;:7;;;21732:43;;;;;;;;;;;;;;;-1:-1:-1;;21732:43:0;;;;;;;;;;21722:54;;21732:43;21722:54;;;;21611:234;;;21722:54;;20281:66;;21611:234;;;;;;;-1:-1:-1;;21611:234:0;;;;;;;;;21579:285;;21611:234;21579:285;;;;;21372:526;-1:-1:-1;;;21372:526:0:o;26620:723::-;26773:6;-1:-1:-1;;;;;26764:15:0;:5;-1:-1:-1;;;;;26764:15:0;;:49;;;;;26808:5;26783:21;:30;;26764:49;26760:576;;;26867:6;-1:-1:-1;;;;;26861:21:0;;26890:5;26861:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;26948:40:0;;-1:-1:-1;;;26948:40:0;;-1:-1:-1;;;;;26954:6:0;26948:22;;-1:-1:-1;26948:22:0;;-1:-1:-1;26948:40:0;;-1:-1:-1;26971:9:0;;26982:5;;26948:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26760:576;;;-1:-1:-1;;;;;27010:22:0;;27027:4;27010:22;27006:330;;;27141:55;27171:5;27179:9;27190:5;27141:22;:55::i;:::-;27006:330;;;27258:66;27292:5;27300;27307:9;27318:5;27258:26;:66::i;:::-;26620:723;;;;:::o;6466:211::-;6583:86;6603:5;6633:23;;;6658:2;6662:5;6610:58;;;;;;;;;;;;;;-1:-1:-1;;6610:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;6610:58:0;-1:-1:-1;;;;;;6610:58:0;;;;;;;;;;6583:19;:86::i;:::-;6466:211;;;:::o;6685:285::-;6829:133;6863:5;6906:27;;;6935:4;6941:2;6945:5;6883:68;;;;;;;;;;;8039:1046;8699:12;8713:23;8748:5;-1:-1:-1;;;;;8740:19:0;8760:4;8740:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8698:67;;;;8784:7;8776:52;;;;-1:-1:-1;;;8776:52:0;;;;;;;;;8845:17;;:21;8841:237;;9000:10;8989:30;;;;;;;;;;;;;;8981:85;;;;-1:-1:-1;;;8981:85:0;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2675:241::-;;2779:2;2767:9;2758:7;2754:23;2750:32;2747:2;;;-1:-1;;2785:12;2747:2;85:6;72:20;97:33;124:5;97:33;;;2837:63;2741:175;-1:-1;;;2741:175;2923:521;;;;3076:2;3064:9;3055:7;3051:23;3047:32;3044:2;;;-1:-1;;3082:12;3044:2;230:6;217:20;242:41;277:5;242:41;;;3134:71;-1:-1;3242:2;3289:22;;217:20;242:41;217:20;242:41;;;3250:71;-1:-1;3358:2;3396:22;;2326:20;2351:32;2326:20;2351:32;;;3366:62;;;;3038:406;;;;;;3451:565;;;;3615:2;3603:9;3594:7;3590:23;3586:32;3583:2;;;-1:-1;;3621:12;3583:2;387:6;381:13;399:41;434:5;399:41;;;3792:2;3850:22;;381:13;3673:82;;-1:-1;399:41;381:13;399:41;;;3919:2;3968:22;;2472:13;3800:82;;-1:-1;2490:32;2472:13;2490:32;;4023:595;;;;4170:2;4158:9;4149:7;4145:23;4141:32;4138:2;;;-1:-1;;4176:12;4138:2;85:6;72:20;97:33;124:5;97:33;;;4228:63;-1:-1;4328:2;4367:22;;72:20;97:33;72:20;97:33;;;4336:63;-1:-1;4464:2;4449:18;;4436:32;4488:18;4477:30;;4474:2;;;-1:-1;;4510:12;4474:2;4585:6;4574:9;4570: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;4328:2;1303:6;1236;1294:16;;1291:25;1288:2;;;-1:-1;;1319:12;1288:2;18888:6;4328:2;1236:6;1232:17;4328:2;1270:5;1266:16;18865:30;-1:-1;4328:2;18935:6;1270:5;18926:16;;18919:27;4530:72;;;;;;4132:486;;;;;;4625:257;;4737:2;4725:9;4716:7;4712:23;4708:32;4705:2;;;-1:-1;;4743:12;4705:2;533:6;527:13;20068:5;18323:13;18316:21;20046:5;20043:32;20033:2;;-1:-1;;20079:12;4889:395;;;5019:2;5007:9;4998:7;4994:23;4990:32;4987:2;;;-1:-1;;5025:12;4987:2;-1:-1;;2057:13;;5187:2;5236:22;;;2057:13;;;;;-1:-1;4981:303;5291:611;;;;;5446:2;5434:9;5425:7;5421:23;5417:32;5414:2;;;-1:-1;;5452:12;5414:2;1924:6;1911:20;5504:62;;5603:2;5645:9;5641:22;1911:20;5611:62;;5738:2;5727:9;5723:18;5710:32;5762:18;;5754:6;5751:30;5748:2;;;-1:-1;;5784:12;5748:2;5869:6;5858:9;5854: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;;5762:18;785:6;782:30;779:2;;;-1:-1;;815:12;779:2;910:3;5603:2;890:17;851:6;876:32;;873:41;870:2;;;-1:-1;;917:12;870:2;5408:494;;;;-1:-1;;5603:2;847:17;;;;-1:-1;;;5408:494;5909:496;;;6050:2;6038:9;6029:7;6025:23;6021:32;6018:2;;;-1:-1;;6056:12;6018:2;2203:6;2197:13;2215:33;2242:5;2215:33;;;6240:2;6225:18;;6219:25;6108:74;;-1:-1;6264:18;6253:30;;6250:2;;;-1:-1;;6286:12;6250:2;6372:6;6361:9;6357: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;6240:2;1756:6;1689;1747:16;;1744:25;1741:2;;;-1:-1;;1772:12;1741:2;1792:39;1824:6;6240:2;1723:5;1719:16;6240:2;1689:6;1685:17;1792:39;;;6306:83;;;;;;6012:393;;;;;;6412:263;;6527:2;6515:9;6506:7;6502:23;6498:32;6495:2;;;-1:-1;;6533:12;6495:2;-1:-1;2612:13;;6489:186;-1:-1;6489:186;10853:271;;7741:5;17362:12;7852:52;7897:6;7892:3;7885:4;7878:5;7874:16;7852:52;;;7916:16;;;;;10987:137;-1:-1;;10987:137;11131:798;-1:-1;;;;;;9335:87;;19695:2;19691:14;;;;-1:-1;;19691:14;9320:1;9441:11;;6891:58;11670:12;;;7161:58;;;;11781:12;;;7161:58;11892:12;;;11404:525;11936:222;-1:-1;;;;;18568:54;;;;6753:37;;12063:2;12048:18;;12034:124;12165:440;-1:-1;;;;;18568:54;;;6753:37;;18568:54;;;;12510:2;12495:18;;6753:37;18706:8;18695:20;;;12591:2;12576:18;;10685:36;12346:2;12331:18;;12317:288;12612:444;-1:-1;;;;;18568:54;;;6753:37;;18568:54;;;;12959:2;12944:18;;6753:37;13042:2;13027:18;;7161:58;;;;12795:2;12780:18;;12766:290;13063:736;;4488:18;;19691:14;;;18579:42;18572:5;18568:54;6760:3;6753:37;7053:5;18323:13;18316:21;13471:2;13460:9;13456:18;7026:34;7211:5;13552:2;13541:9;13537:18;7161:58;18579:42;10597:5;18568:54;13635:2;13624:9;13620:18;10567:37;;13312:3;13672;13661:9;13657:19;13650:49;7373:5;17362:12;17518:6;13312:3;13301:9;13297:19;17506;7466:52;7511:6;17546:14;13301:9;17546:14;13471:2;7492:5;7488:16;7466:52;;;19600:7;19584:14;-1:-1;;19580:28;7530:39;;;;17546:14;7530:39;;13283:516;-1:-1;;;;;;13283:516;13806:333;-1:-1;;;;;18568:54;;;;6753:37;;14125:2;14110:18;;7161:58;13961:2;13946:18;;13932:207;14146:416;14346:2;14360:47;;;8286:2;14331:18;;;17506:19;8322:28;17546:14;;;8302:49;8370:12;;;14317:245;14569:416;14769:2;14783:47;;;8621:2;14754:18;;;17506:19;-1:-1;;;17546:14;;;8637:36;8692:12;;;14740:245;14992:416;15192:2;15206:47;;;15177:18;;;17506:19;8979:34;17546:14;;;8959:55;9033:12;;;15163:245;15415:416;15615:2;15629:47;;;9691:2;15600:18;;;17506:19;-1:-1;;;17546:14;;;9707:39;9765:12;;;15586:245;15838:416;16038:2;16052:47;;;10016:1;16023:18;;;17506:19;-1:-1;;;17546:14;;;10031:32;10082:12;;;16009:245;16261:416;16461:2;16475:47;;;10333:2;16446:18;;;17506:19;10369:34;17546:14;;;10349:55;-1:-1;;;10424:12;;;10417:34;10470:12;;;16432:245;16684:256;16746:2;16740:9;16772:17;;;16847:18;16832:34;;16868:22;;;16829:62;16826:2;;;16904:1;;16894:12;16826:2;16746;16913:22;16724:216;;-1:-1;16724:216;16947:321;;17090:18;17082:6;17079:30;17076:2;;;-1:-1;;17112:12;17076:2;-1:-1;19600:7;17166:17;-1:-1;;17162:33;17253:4;17243:15;;17013:255;18961:268;19026:1;19033:101;19047:6;19044:1;19041:13;19033:101;;;19114:11;;;19108:18;19095:11;;;19088:39;19069:2;19062:10;19033:101;;;19149:6;19146:1;19143:13;19140:2;;;-1:-1;;19026:1;19196:16;;19189:27;19010:219;19723:117;-1:-1;;;;;18568:54;;19782:35;;19772:2;;19831:1;;19821:12;19772:2;19766:74;;20351:115;18706:8;20436:5;18695:20;20412:5;20409:34;20399:2;;20457:1;;20447:12

ipfs://55a1ace247482b66072bbc089a3be425302505b833978509f26b77f763665f32