Contract 0x48ef488054b5c570cf3a2ac0a0697b0b0d34c431

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

// SPDX-License-Identifier: MIT

pragma solidity =0.8.10;





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

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

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

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

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

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

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





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

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

    function approve(address, uint256) public virtual;

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

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

    function deposit() public payable virtual;

    function withdraw(uint256) public virtual;
}





library Address {
    //insufficient balance
    error InsufficientBalance(uint256 available, uint256 required);
    //unable to send value, recipient may have reverted
    error SendingValueFail();
    //insufficient balance for call
    error InsufficientBalanceForCall(uint256 available, uint256 required);
    //call to non-contract
    error NonContractCall();
    
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            codehash := extcodehash(account)
        }
        return (codehash != accountHash && codehash != 0x0);
    }

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

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

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

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

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

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

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

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

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




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

        return c;
    }

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

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

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

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

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

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

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







library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

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

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

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(
            value,
            "SafeERC20: decreased allowance below zero"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, newAllowance)
        );
    }

    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        bytes memory returndata = address(token).functionCall(
            data,
            "SafeERC20: low-level call failed"
        );
        if (returndata.length > 0) {
            // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}






library TokenUtils {
    using SafeERC20 for IERC20;

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

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

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

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

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

        return _amount;
    }

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

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

        return _amount;
    }

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

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

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

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

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





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

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

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

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




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

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

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

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

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

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

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

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

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




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

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

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

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




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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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





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

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

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

    function approveContractChange(bytes32 _id) public virtual;

    function cancelContractChange(bytes32 _id) public virtual;

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





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





contract AuthHelper is ArbitrumAuthAddresses {
}





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

    error SenderNotAdmin();

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

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

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

}








contract AdminAuth is AuthHelper {
    using SafeERC20 for IERC20;

    AdminVault public constant adminVault = AdminVault(ADMIN_VAULT_ADDR);

    error SenderNotOwner();
    error SenderNotAdmin();

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

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

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

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





contract ArbitrumWrapperAddresses {

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

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





contract WrapperHelper is ArbitrumWrapperAddresses {
}










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

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

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

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

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

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

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

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

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

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

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

f3f2ce72b2023e390de4e46ac7438aa78e8c014847f870b8560913ca468f440d