Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function sell(address _srcAddr, addre ...
•    - function buy(address _srcAddr, addres ...
•    - function getSellRate(address _srcAddr ...
•    - function getBuyRate(address _srcAddr, ...
• interface IUniswapV3SwapCallback
•    - function uniswapV3SwapCallback(
• interface ISwapRouter is IUniswapV3Sw ...
•    - function exactInputSingle(ExactInputS ...
•    - function exactInput(ExactInputParams ...
•    - function exactOutputSingle(ExactOutpu ...
•    - function exactOutput(ExactOutputParam ...
• interface IQuoter
•    - function quoteExactInput(bytes memory ...
•    - function quoteExactInputSingle(
•    - function quoteExactOutput(bytes memor ...
•    - function quoteExactOutputSingle(
•    - function totalSupply()
•    - function balanceOf(address _owner)
•    - function transfer(address _to, uint25 ...
•    - function transferFrom(address _from, ...
•    - function approve(address _spender, ui ...
•    - function allowance(address _owner, ad ...
•    - function decimals()
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function _functionCallWithValue(addre ...
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
•    - function safeTransfer(ERC20 token, ad ...
•    - function safeTransferFrom(ERC20 token ...
•    - function safeApprove(ERC20 token, add ...
•    - function safeIncreaseAllowance(ERC20 ...
•    - function safeDecreaseAllowance(ERC20 ...
•    - function _callOptionalReturn(ERC20 to ...
•    - function setAdminByOwner(address _adm ...
•    - function setAdminByAdmin(address _adm ...
•    - function setOwnerByAdmin(address _own ...
•    - function kill()
•    - function withdrawStuckFunds(address _ ...
•    - function add(uint256 x, uint256 y)
•    - function sub(uint256 x, uint256 y)
•    - function mul(uint256 x, uint256 y)
•    - function div(uint256 x, uint256 y)
•    - function min(uint256 x, uint256 y)
•    - function max(uint256 x, uint256 y)
•    - function imin(int256 x, int256 y)
•    - function imax(int256 x, int256 y)
•    - function wmul(uint256 x, uint256 y)
•    - function rmul(uint256 x, uint256 y)
•    - function wdiv(uint256 x, uint256 y)
•    - function rdiv(uint256 x, uint256 y)
•    - function rpow(uint256 x, uint256 n)
•  contract UniV3WrapperV3 is DSMath, ... *
•    - function sell(
•    - function buy(
•    - function getSellRate(
•    - function getBuyRate(
•    - function sendLeftOver(address _srcAdd ...
•    - function getBalance(address _tokenAdd ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;


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

    function buy(address _srcAddr, address _destAddr, uint _destAmount, bytes memory _additionalData) external payable 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 {
    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);
}


/// @title Quoter Interface
/// @notice Supports quoting the calculated amounts from exact input or exact output swaps
/// @dev These functions are not marked view because they rely on calling non-view functions and reverting
/// to compute the result. They are also not gas efficient and should not be called on-chain.
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);
} interface ERC20 {
    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);

    function decimals() external view returns (uint256 digits);

    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
} library Address {
    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 {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    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) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // 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(ERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     */
    function safeApprove(ERC20 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(ERC20 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(ERC20 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(ERC20 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");
        }
    }
} contract AdminAuth {

    using SafeERC20 for ERC20;

    address public owner;
    address public admin;

    modifier onlyOwner() {
        require(owner == msg.sender);
        _;
    }

    modifier onlyAdmin() {
        require(admin == msg.sender);
        _;
    }

    constructor() public {
        owner = 0xBc841B0dE0b93205e912CFBBd1D0c160A1ec6F00;
        admin = 0x25eFA336886C74eA8E282ac466BdCd0199f85BB9;
    }

    /// @notice Admin is set by owner first time, after that admin is super role and has permission to change owner
    /// @param _admin Address of multisig that becomes admin
    function setAdminByOwner(address _admin) public {
        require(msg.sender == owner);
        require(admin == address(0));

        admin = _admin;
    }

    /// @notice Admin is able to set new admin
    /// @param _admin Address of multisig that becomes new admin
    function setAdminByAdmin(address _admin) public {
        require(msg.sender == admin);

        admin = _admin;
    }

    /// @notice Admin is able to change owner
    /// @param _owner Address of new owner
    function setOwnerByAdmin(address _owner) public {
        require(msg.sender == admin);

        owner = _owner;
    }

    /// @notice Destroy the contract
    function kill() public onlyOwner {
        selfdestruct(payable(owner));
    }

    /// @notice  withdraw stuck funds
    function withdrawStuckFunds(address _token, uint _amount) public onlyOwner {
        if (_token == 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) {
            payable(owner).transfer(_amount);
        } else {
            ERC20(_token).safeTransfer(owner, _amount);
        }
    }
} contract DSMath {
    function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x + y) >= x);
    }

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

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

    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);
            }
        }
    }
} // SPDX-License-Identifier: MIT








/// @title DFS exchange wrapper for UniswapV3
contract UniV3WrapperV3 is DSMath, ExchangeInterfaceV3, AdminAuth {
    using SafeERC20 for ERC20;

    address public constant KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    ISwapRouter public constant router = ISwapRouter(0xE592427A0AEce92De3Edee1F18E0157C05861564);
    IQuoter public constant quoter = IQuoter(0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6);

    /// @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,
        uint256 _srcAmount,
        bytes calldata _additionalData
    ) external payable override returns (uint256) {
        ERC20(_srcAddr).safeApprove(address(router), _srcAmount);

        ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
            path: _additionalData,
            recipient: msg.sender,
            deadline: block.timestamp + 1,
            amountIn: _srcAmount,
            amountOutMinimum: 1
        });
    
        uint256 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,
        uint256 _destAmount,
        bytes calldata _additionalData
    ) external payable override returns (uint256) {
        uint256 srcAmount = getBalance(_srcAddr);

        ERC20(_srcAddr).safeApprove(address(router), srcAmount);

        ISwapRouter.ExactOutputParams memory params = ISwapRouter.ExactOutputParams({
            path: _additionalData,
            recipient: msg.sender,
            deadline: block.timestamp + 1,
            amountOut: _destAmount,
            amountInMaximum: type(uint256).max
        });

        uint256 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,
        uint256 _srcAmount,
        bytes memory _additionalData
    ) public override returns (uint256) {
        uint256 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,
        uint256 _destAmount,
        bytes memory _additionalData
    ) public override returns (uint256) {
        uint256 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 != KYBER_ETH_ADDRESS) {
            ERC20(_srcAddr).safeTransfer(msg.sender, ERC20(_srcAddr).balanceOf(address(this)));
        }
    }

    function getBalance(address _tokenAddr) internal view returns (uint256 balance) {
        if (_tokenAddr == KYBER_ETH_ADDRESS) {
            balance = address(this).balance;
        } else {
            balance = ERC20(_tokenAddr).balanceOf(address(this));
        }
    }

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"KYBER_ETH_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","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":"payable","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":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_admin","type":"address"}],"name":"setAdminByAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_admin","type":"address"}],"name":"setAdminByOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"setOwnerByAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawStuckFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

17743:4113:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14649:122;;;;;;;;;;-1:-1:-1;14649:122:0;;;;;:::i;:::-;;:::i;:::-;;17850:86;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19266:727;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;14944:285::-;;;;;;;;;;-1:-1:-1;14944:285:0;;;;;:::i;:::-;;:::i;14817:80::-;;;;;;;;;;;;;:::i;20766:302::-;;;;;;;;;;-1:-1:-1;20766:302:0;;;;;:::i;:::-;;:::i;20230:301::-;;;;;;;;;;-1:-1:-1;20230:301:0;;;;;:::i;:::-;;:::i;18378:630::-;;;;;;:::i;:::-;;:::i;13575:20::-;;;;;;;;;;;;;:::i;14428:122::-;;;;;;;;;;-1:-1:-1;14428:122:0;;;;;:::i;:::-;;:::i;18042:84::-;;;;;;;;;;;;;:::i;14145:161::-;;;;;;;;;;-1:-1:-1;14145:161:0;;;;;:::i;:::-;;:::i;13602:20::-;;;;;;;;;;;;;:::i;17943:92::-;;;;;;;;;;;;;:::i;14649:122::-;14730:5;;-1:-1:-1;;;;;14730:5:0;14716:10;:19;14708:28;;;;;;14749:5;:14;;-1:-1:-1;;;;;;14749:14:0;-1:-1:-1;;;;;14749:14:0;;;;;;;;;;14649:122::o;17850:86::-;17894:42;17850:86;:::o;19266:727::-;19437:7;19457:17;19477:20;19488:8;19477:10;:20::i;:::-;19457:40;-1:-1:-1;19510:55:0;-1:-1:-1;;;;;19510:27:0;;17992:42;19457:40;19510:27;:55::i;:::-;19578:43;;:::i;:::-;19624:244;;;;;;;;19675:15;;19624:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19624:244:0;;;-1:-1:-1;;19716:10:0;19624:244;;;;-1:-1:-1;19769:1:0;19751:15;:19;19624:244;;;;;;;;;;;;;;-1:-1:-1;;19624:244:0;;;;;;;;19900:26;;-1:-1:-1;;;19900:26:0;;19578:290;;-1:-1:-1;19624:244:0;17992:42;;19900:18;;:26;;19578:290;;19900:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19881:45;;19937:22;19950:8;19937:12;:22::i;:::-;19977:8;19266:727;-1:-1:-1;;;;;;;;19266:727:0:o;14944:285::-;13671:5;;-1:-1:-1;;;;;13671:5:0;13680:10;13671:19;13663:28;;;;;;15044:42:::1;-1:-1:-1::0;;;;;15034:52:0;::::1;;15030:192;;;15111:5;::::0;;15103:32:::1;::::0;-1:-1:-1;;;;;15111:5:0;;::::1;::::0;15103:32;::::1;;;::::0;15127:7;;15103:32;15111:5;15103:32;15127:7;15111:5;15103:32;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;15030:192;;;15195:5;::::0;15168:42:::1;::::0;-1:-1:-1;;;;;15168:26:0;;::::1;::::0;15195:5:::1;15202:7:::0;15168:26:::1;:42::i;:::-;14944:285:::0;;:::o;14817:80::-;13671:5;;-1:-1:-1;;;;;13671:5:0;13680:10;13671:19;13663:28;;;;;;14882:5:::1;::::0;-1:-1:-1;;;;;14882:5:0::1;14861:28;20766:302:::0;20962:53;;-1:-1:-1;;;20962:53:0;;20923:7;;;;18083:42;;20962:23;;:53;;20986:15;;21003:11;;20962:53;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20943:72;;21033:27;21038:11;21051:8;21033:4;:27::i;:::-;21026:34;;;20766:302;;;;;;;:::o;20230:301::-;20427:51;;-1:-1:-1;;;20427:51:0;;20387:7;;;;18083:42;;20427:22;;:51;;20450:15;;20467:10;;20427:51;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20407:71;;20496:27;20501:9;20512:10;20496:4;:27::i;18378:630::-;18549:7;18569:56;-1:-1:-1;;;;;18569:27:0;;17992:42;18614:10;18569:27;:56::i;:::-;18638:42;;:::i;:::-;18683:226;;;;;;;;18733:15;;18683:226;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18683:226:0;;;-1:-1:-1;;18774:10:0;18683:226;;;;-1:-1:-1;18827:1:0;18809:15;:19;;18683:226;;;;;;;;;;;;;;;;;;;18946:25;;-1:-1:-1;;;18946:25:0;;18638:271;;-1:-1:-1;18683:226:0;17992:42;;18946:17;;:25;;18638:271;;18946:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;13575:20::-;;;-1:-1:-1;;;;;13575:20:0;;:::o;14428:122::-;14509:5;;-1:-1:-1;;;;;14509:5:0;14495:10;:19;14487:28;;;;;;14528:5;:14;;-1:-1:-1;;;;;;14528:14:0;-1:-1:-1;;;;;14528:14:0;;;;;;;;;;14428:122::o;18042:84::-;18083:42;18042:84;:::o;14145:161::-;14226:5;;-1:-1:-1;;;;;14226:5:0;14212:10;:19;14204:28;;;;;;14251:5;;-1:-1:-1;;;;;14251:5:0;:19;14243:28;;;;;13602:20;;;-1:-1:-1;;;;;13602:20:0;;:::o;17943:92::-;17992:42;17943:92;:::o;21488:278::-;21551:15;-1:-1:-1;;;;;21583:31:0;;17894:42;21583:31;21579:180;;;-1:-1:-1;21641:21:0;21579:180;;;21705:42;;-1:-1:-1;;;21705:42:0;;-1:-1:-1;;;;;21705:27:0;;;;;:42;;21741:4;;21705:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21695:52;;21579:180;21488:278;;;:::o;12170:281::-;12256:86;12276:5;12306:22;;;12330:7;12339:1;12283:58;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;12283:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;12283:58:0;-1:-1:-1;;;;;;12283:58:0;;;;;;;;;;12256:19;:86::i;:::-;12353:90;12373:5;12403:22;;;12427:7;12436:5;12380:62;;;;;;;;;:::i;12353:90::-;12170:281;;;:::o;21205:275::-;21265:51;;21273:10;;21294:21;21265:51;;;;;;;;;21294:21;21273:10;21265:51;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;21333:29:0;;17894:42;21333:29;21329:144;;21379:82;21408:10;21426:8;-1:-1:-1;;;;;21420:25:0;;21454:4;21420:40;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;21379:28:0;;;:82;:28;:82::i;:::-;21205:275;:::o;11621:176::-;11703:86;11723:5;11753:23;;;11778:2;11782:5;11730:58;;;;;;;;;:::i;16539:120::-;16598:9;16650:1;16624:23;16628:11;16632:1;16228:6;16628:3;:11::i;:::-;16645:1;16641;:5;16624:3;:23::i;:::-;:27;;;;;;;16539:120;-1:-1:-1;;;16539:120:0:o;13090:419::-;13172:23;13198:69;13226:4;13198:69;;;;;;;;;;;;;;;;;13206:5;-1:-1:-1;;;;;13198:27:0;;;:69;;;;;:::i;:::-;13282:17;;13172:95;;-1:-1:-1;13282:21:0;13278:224;;13424:10;13413:30;;;;;;;;;;;;:::i;:::-;13405:85;;;;-1:-1:-1;;;13405:85:0;;;;;;;:::i;:::-;;;;;;;;15498:127;15556:9;15586:6;;;:30;;-1:-1:-1;;15601:5:0;;;15615:1;15610;15601:5;15610:1;15596:15;;;;;:20;15586:30;15578:39;;;;;;15498:127;;;;:::o;15256:113::-;15349:5;;;15344:16;;;;15336:25;;;;;8014:196;8117:12;8149:53;8172:6;8180:4;8186:1;8189:12;8906;8939:18;8950:6;8939:10;:18::i;:::-;8931:60;;;;-1:-1:-1;;;8931:60:0;;;;;;;:::i;:::-;9065:12;9079:23;9106:6;-1:-1:-1;;;;;9106:11:0;9126:8;9137:4;9106:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9064:78;;;;9157:7;9153:595;;;9188:10;-1:-1:-1;9181:17:0;;-1:-1:-1;9181:17:0;9153:595;9302:17;;:21;9298:439;;9565:10;9559:17;9626:15;9613:10;9609:2;9605:19;9598:44;9513:148;9708:12;9701:20;;-1:-1:-1;;;9701:20:0;;;;;;;;:::i;6801:619::-;6861:4;7329:20;;7172:66;7369:23;;;;;;:42;;-1:-1:-1;;7396:15:0;;;7361:51;-1:-1:-1;;6801:619:0:o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;5:130::-;72:20;;-1:-1;;;;;15893:54;;17807:35;;17797:2;;17856:1;;17846:12;1362:241;;1466:2;1454:9;1445:7;1441:23;1437:32;1434:2;;;-1:-1;;1472:12;1434:2;1534:53;1579:7;1555:22;1534:53;:::i;:::-;1524:63;1428:175;-1:-1;;;1428:175::o;1610:741::-;;;;;;1784:3;1772:9;1763:7;1759:23;1755:33;1752:2;;;-1:-1;;1791:12;1752:2;1853:53;1898:7;1874:22;1853:53;:::i;:::-;1843:63;;1961:53;2006:7;1943:2;1986:9;1982:22;1961:53;:::i;:::-;1951:63;;2051:2;2094:9;2090:22;1151:20;2059:63;;2187:2;2176:9;2172:18;2159:32;2211:18;;2203:6;2200:30;2197:2;;;-1:-1;;2233:12;2197:2;2318:6;2307:9;2303:22;;;405:3;398:4;390:6;386:17;382:27;372:2;;-1:-1;;413:12;372:2;456:6;443:20;2211:18;475:6;472:30;469:2;;;-1:-1;;505:12;469:2;600:3;1943:2;580:17;541:6;566:32;;563:41;560:2;;;-1:-1;;607:12;560:2;1746:605;;;;-1:-1;1746:605;;-1:-1;1943:2;537:17;;2253:82;1746:605;-1:-1;;;1746:605::o;2358:721::-;;;;;2522:3;2510:9;2501:7;2497:23;2493:33;2490:2;;;-1:-1;;2529:12;2490:2;2591:53;2636:7;2612:22;2591:53;:::i;:::-;2581:63;;2681:2;2699:53;2744:7;2681:2;2724:9;2720:22;2699:53;:::i;:::-;2689:63;;2789:2;2832:9;2828:22;1151:20;2797:63;;2925:2;2914:9;2910:18;2897:32;2949:18;;2941:6;2938:30;2935:2;;;-1:-1;;2971:12;2935:2;3046:6;3035:9;3031:22;;;737:3;730:4;722:6;718:17;714:27;704:2;;-1:-1;;745:12;704:2;792:6;779:20;2949:18;14534:6;14531:30;14528:2;;;-1:-1;;14564:12;14528:2;2789;14192:9;14637;14618:17;;-1:-1;;14614:33;14224:17;;;;14284:34;;;14320:22;;;14281:62;14278:2;;;-1:-1;;14346:12;14278:2;2789;14365:22;884:21;;;984:16;;;;;981:25;-1:-1;978:2;;;-1:-1;;1009:12;978:2;17294:6;2681:2;926:6;922:17;2681:2;960:5;956:16;17271:30;17332:16;;;;;;17325:27;;;;-1:-1;2484:595;;;;-1:-1;2484:595;;-1:-1;;2484:595::o;3086:366::-;;;3207:2;3195:9;3186:7;3182:23;3178:32;3175:2;;;-1:-1;;3213:12;3175:2;3275:53;3320:7;3296:22;3275:53;:::i;:::-;3265:63;3365:2;3404:22;;;;1151:20;;-1:-1;;;3169:283::o;3459:257::-;;3571:2;3559:9;3550:7;3546:23;3542:32;3539:2;;;-1:-1;;3577:12;3539:2;223:6;217:13;17953:5;15805:13;15798:21;17931:5;17928:32;17918:2;;-1:-1;;17964:12;3723:263;;3838:2;3826:9;3817:7;3813:23;3809:32;3806:2;;;-1:-1;;3844:12;3806:2;-1:-1;1299:13;;3800:186;-1:-1;3800:186::o;4372:323::-;;4504:5;14814:12;15089:6;15084:3;15077:19;4587:52;4632:6;15126:4;15121:3;15117:14;15126:4;4613:5;4609:16;4587:52;:::i;:::-;14637:9;17711:14;-1:-1;;17707:28;4651:39;;;;15126:4;4651:39;;4452:243;-1:-1;;4452:243::o;7055:1072::-;;7294:16;7288:23;7222:4;7331:14;7324:38;7377:71;7222:4;7217:3;7213:14;7429:12;7377:71;:::i;:::-;7538:4;7527:16;;;7521:23;-1:-1;;;;;15893:54;7598:14;;;4203:37;7696:4;7685:16;;;7679:23;7756:14;;;9359:37;7854:4;7843:16;;;7837:23;7914:14;;;9359:37;8020:4;8009:16;;;8003:23;8080:14;;;;9359:37;;;;-1:-1;7369:79;;7195:932;-1:-1;7195:932::o;9528:271::-;;5212:5;14814:12;5323:52;5368:6;5363:3;5356:4;5349:5;5345:16;5323:52;:::i;:::-;5387:16;;;;;9662:137;-1:-1;;9662:137::o;9806:222::-;-1:-1;;;;;15893:54;;;;4203:37;;9933:2;9918:18;;9904:124::o;10280:345::-;-1:-1;;;;;15893:54;;;;4203:37;;16109:4;16098:16;10611:2;10596:18;;5826:56;10441:2;10426:18;;10412:213::o;10632:333::-;-1:-1;;;;;15893:54;;;;4203:37;;10951:2;10936:18;;9359:37;10787:2;10772:18;;10758:207::o;10972:417::-;;11145:2;11166:17;11159:47;11220:76;11145:2;11134:9;11130:18;11282:6;11220:76;:::i;:::-;11212:84;;9389:5;11375:2;11364:9;11360:18;9359:37;11116:273;;;;;:::o;11922:310::-;;12069:2;12090:17;12083:47;12144:78;12069:2;12058:9;12054:18;12208:6;12144:78;:::i;12239:416::-;12439:2;12453:47;;;6473:2;12424:18;;;15077:19;6509:31;15117:14;;;6489:52;6560:12;;;12410:245::o;12662:416::-;12862:2;12876:47;;;6811:2;12847:18;;;15077:19;6847:34;15117:14;;;6827:55;-1:-1;;;6902:12;;;6895:34;6948:12;;;12833:245::o;13085:402::-;;13278:2;13299:17;13292:47;13353:124;13278:2;13267:9;13263:18;13463:6;13353:124;:::i;13907:222::-;9359:37;;;14034:2;14019:18;;14005:124::o;17367:268::-;17432:1;17439:101;17453:6;17450:1;17447:13;17439:101;;;17520:11;;;17514:18;17501:11;;;17494:39;17475:2;17468:10;17439:101;;;17555:6;17552:1;17549:13;17546:2;;;17432:1;17611:6;17606:3;17602:16;17595:27;17546:2;;17416:219;;;:::o

ipfs://4133af5a4376436c92d20afe196496525df87bd1b4aab023471eefa8c2247d71