Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IExchangeV3
•    - function sell(address _srcAddr, addre ...
•    - function buy(address _srcAddr, addres ...
•    - function getSellRate(address _srcAddr ...
•    - function getBuyRate(address _srcAddr, ...
• interface ISwaps
•    - function exchange_with_best_rate(
•    - function exchange(
•    - function get_best_rate(
•    - function get_exchange_amount(
•    - function get_input_amount(
•    - function get_exchange_amounts(
•    - function get_calculator(address _pool ...
•    - function exchange_multiple(
•    - function exchange_multiple(
•    - function get_exchange_multiple_amount ...
• interface IAddressProvider
•    - function admin()
•    - function get_registry()
•    - function get_address(uint256 _id)
• interface IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address _owner)
•    - function transfer(address _to, uint25 ...
•    - function transferFrom(
•    - function approve(address _spender, ui ...
•    - function allowance(address _owner, ad ...
•  contract DSMath
•    - 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)
•    - function getAddr(bytes4 _id)
•    - function addNewContract(
•    - function startContractChange(bytes32 ...
•    - function approveContractChange(bytes3 ...
•    - function cancelContractChange(bytes32 ...
•    - function changeWaitPeriod(bytes32 _id ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
• functionCallWithValue(target, data, v ...
•    - function functionCallWithValue(
•    - function _functionCallWithValue(
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(
•    - function mod(uint256 a, uint256 b)
•    - function mod(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function _callOptionalReturn(IERC20 t ...
•  contract MainnetAuthAddresses
•  contract AuthHelper is MainnetAuth ...
•  contract AdminVault is AuthHelper
•    - function changeOwner(address _owner)
•    - function changeAdmin(address _admin)
•  contract AdminAuth is AuthHelper
•    - function withdrawStuckFunds(address _ ...
•    - function kill()
•  contract MainnetWrapperAddresses
•  contract WrapperHelper is MainnetW ...
•  contract CurveWrapperV3 is DSMath, ... *
•    - function sell(address _srcAddr, addre ...
•    - function buy(address, address, uint, ...
•    - function getSellRate(address, address ...
•    - function getBuyRate(address, address, ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-05-18
*/

// SPDX-License-Identifier: MIT

pragma solidity =0.8.10;





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 ISwaps {

    ///@notice Perform an exchange using the pool that offers the best rate
    ///@dev Prior to calling this function, the caller must approve
    ///        this contract to transfer `_amount` coins from `_from`
    ///        Does NOT check rates in factory-deployed pools
    ///@param _from Address of coin being sent
    ///@param _to Address of coin being received
    ///@param _amount Quantity of `_from` being sent
    ///@param _expected Minimum quantity of `_from` received
    ///        in order for the transaction to succeed
    ///@param _receiver Address to transfer the received tokens to
    ///@return uint256 Amount received
    function exchange_with_best_rate(
        address _from,
        address _to,
        uint256 _amount,
        uint256 _expected,
        address _receiver
    ) external payable returns (uint256);


    ///@notice Perform an exchange using a specific pool
    ///@dev Prior to calling this function, the caller must approve
    ///        this contract to transfer `_amount` coins from `_from`
    ///        Works for both regular and factory-deployed pools
    ///@param _pool Address of the pool to use for the swap
    ///@param _from Address of coin being sent
    ///@param _to Address of coin being received
    ///@param _amount Quantity of `_from` being sent
    ///@param _expected Minimum quantity of `_from` received
    ///        in order for the transaction to succeed
    ///@param _receiver Address to transfer the received tokens to
    ///@return uint256 Amount received
    function exchange(
        address _pool,
        address _from,
        address _to,
        uint256 _amount,
        uint256 _expected,
        address _receiver
    ) external payable returns (uint256);



    ///@notice Find the pool offering the best rate for a given swap.
    ///@dev Checks rates for regular and factory pools
    ///@param _from Address of coin being sent
    ///@param _to Address of coin being received
    ///@param _amount Quantity of `_from` being sent
    ///@param _exclude_pools A list of up to 8 addresses which shouldn't be returned
    ///@return Pool address, amount received
    function get_best_rate(
        address _from,
        address _to,
        uint256 _amount,
        address[8] memory _exclude_pools
    ) external view returns (address, uint256);


    ///@notice Get the current number of coins received in an exchange
    ///@dev Works for both regular and factory-deployed pools
    ///@param _pool Pool address
    ///@param _from Address of coin to be sent
    ///@param _to Address of coin to be received
    ///@param _amount Quantity of `_from` to be sent
    ///@return Quantity of `_to` to be received
    function get_exchange_amount(
        address _pool,
        address _from,
        address _to,
        uint256 _amount
    ) external view returns (uint256);


    ///@notice Get the current number of coins required to receive the given amount in an exchange
    ///@param _pool Pool address
    ///@param _from Address of coin to be sent
    ///@param _to Address of coin to be received
    ///@param _amount Quantity of `_to` to be received
    ///@return Quantity of `_from` to be sent
    function get_input_amount(
        address _pool,
        address _from,
        address _to,
        uint256 _amount
    ) external view returns (uint256);


    ///@notice Get the current number of coins required to receive the given amount in an exchange
    ///@param _pool Pool address
    ///@param _from Address of coin to be sent
    ///@param _to Address of coin to be received
    ///@param _amounts Quantity of `_to` to be received
    ///@return Quantity of `_from` to be sent
    function get_exchange_amounts(
        address _pool,
        address _from,
        address _to,
        uint256[] memory _amounts
    ) external view returns (uint256[] memory);


    ///@notice Set calculator contract
    ///@dev Used to calculate `get_dy` for a pool
    ///@param _pool Pool address
    ///@return `CurveCalc` address
    function get_calculator(address _pool) external view returns (address);


    /// @notice Perform up to four swaps in a single transaction
    /// @dev Routing and swap params must be determined off-chain. This
    ///     functionality is designed for gas efficiency over ease-of-use.
    /// @param _route Array of [initial token, pool, token, pool, token, ...]
    ///     The array is iterated until a pool address of 0x00, then the last
    ///     given token is transferred to `_receiver`
    /// @param _swap_params Multidimensional array of [i, j, swap type] where i and j are the correct
    ///     values for the n'th pool in `_route`. The swap type should be 1 for
    ///     a stableswap `exchange`, 2 for stableswap `exchange_underlying`, 3
    ///     for a cryptoswap `exchange`, 4 for a cryptoswap `exchange_underlying`,
    ///     5 for Polygon factory metapools `exchange_underlying`, 6-8 for
    ///     underlying coin -> LP token "exchange" (actually `add_liquidity`), 9 and 10
    ///     for LP token -> underlying coin "exchange" (actually `remove_liquidity_one_coin`)
    /// @param _amount The amount of `_route[0]` token being sent.
    /// @param _expected The minimum amount received after the final swap.
    /// @param _pools Array of pools for swaps via zap contracts. This parameter is only needed for
    ///     Polygon meta-factories underlying swaps.
    /// @param _receiver Address to transfer the final output token to.
    /// @return Received amount of the final output token
    function exchange_multiple(
        address[9] memory _route,
        uint256[3][4] memory _swap_params,
        uint256 _amount,
        uint256 _expected,
        address[4] memory _pools,
        address _receiver
    ) external payable returns (uint256);

    function exchange_multiple(
        address[9] memory _route,
        uint256[3][4] memory _swap_params,
        uint256 _amount,
        uint256 _expected
    ) external payable returns (uint256);

    function get_exchange_multiple_amount(
        address[9] memory _route,
        uint256[3][4] memory _swap_params,
        uint256 _amount
    ) external view returns (uint256);
}




interface IAddressProvider {
    function admin() external view returns (address);
    function get_registry() external view returns (address);
    function get_address(uint256 _id) external view returns (address);
}





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




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





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





contract MainnetAuthAddresses {
    address internal constant ADMIN_VAULT_ADDR = 0xCCf3d848e08b94478Ed8f46fFead3008faF581fD;
    address internal constant FACTORY_ADDRESS = 0x5a15566417e6C1c9546523066500bDDBc53F88C7;
    address internal constant ADMIN_ADDR = 0x25eFA336886C74eA8E282ac466BdCd0199f85BB9; // USED IN ADMIN VAULT CONSTRUCTOR
}





contract AuthHelper is MainnetAuthAddresses {
}





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 MainnetWrapperAddresses {

    address internal constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    address internal constant KYBER_INTERFACE = 0x9AAb3f75489902f3a48495025729a0AF77d4b11e;
    address payable internal constant WALLET_ID = payable(0x322d58b9E75a6918f7e7849AEe0fF09369977e08);
    address internal constant UNI_V2_ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    address internal constant UNI_V3_ROUTER = 0xE592427A0AEce92De3Edee1F18E0157C05861564;
    address internal constant UNI_V3_QUOTER = 0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6;
    address internal constant CURVE_ADDRESS_PROVIDER = 0x0000000022D53366457F9d5E68Ec105046FC4383;
}





contract WrapperHelper is MainnetWrapperAddresses {
}











contract CurveWrapperV3 is DSMath, IExchangeV3, AdminAuth, WrapperHelper {
    using SafeERC20 for IERC20;

    IAddressProvider addressProvider = IAddressProvider(CURVE_ADDRESS_PROVIDER);

    /// @notice Sells _srcAmount of tokens on Curve
    /// @param _srcAddr From token
    /// @param _srcAmount From amount
    /// @param _additionalData Route and swap params
    /// @return uint256 amount of tokens received from selling
    function sell(address _srcAddr, address, uint256 _srcAmount, bytes calldata _additionalData) external override returns (uint) {    
        ISwaps exchangeContract = ISwaps(
                addressProvider.get_address(2)
        );
        IERC20(_srcAddr).safeApprove(address(exchangeContract), _srcAmount);

        (
            address[9] memory _route, uint256[3][4] memory _swap_params
        ) = abi.decode(_additionalData, (address[9], uint256[3][4]));

        address[4] memory pools;
        uint256 amountOut = exchangeContract.exchange_multiple(
            _route,
            _swap_params,
            _srcAmount,
            1,   // _expected
            pools,
            msg.sender
        );

        return amountOut;
    }

    /// @dev deprecated function
    function buy(address, address, uint, bytes calldata) external override returns(uint) {
        return 0;
    }

    /// @notice Return a rate for which we can sell an amount of tokens
    /// @param _srcAmount From amount
    /// @param _additionalData Route and swap params
    /// @return uint256 Rate (price)
    function getSellRate(address, address, uint256 _srcAmount, bytes memory _additionalData) public override returns (uint) {
        ISwaps exchangeContract = ISwaps(
                addressProvider.get_address(2)
        );
        (
            address[9] memory _route, uint256[3][4] memory _swap_params
        ) = abi.decode(_additionalData, (address[9], uint256[3][4]));

        uint256 amountOut = exchangeContract.get_exchange_multiple_amount(
            _route,
            _swap_params,
            _srcAmount
        );
        return wdiv(amountOut, _srcAmount);
    }

    /// @dev deprecated function
    function getBuyRate(address, address, uint, bytes memory) public override returns (uint) {
        return 0;
    }

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"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":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","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":"","type":"uint256"},{"internalType":"bytes","name":"","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":[{"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"}]

6080604052600080546001600160a01b0319166f22d53366457f9d5e68ec105046fc438317905534801561003257600080fd5b5061132c806100426000396000f3fe6080604052600436106100745760003560e01c806354123c121161004e57806354123c12146100f05780635b6f36fc146101105780638cedca7114610130578063c579d4901461017d57600080fd5b80633924db661461008057806341c0e1b5146100b957806349d66644146100d057600080fd5b3661007b57005b600080fd5b34801561008c57600080fd5b506100a661009b366004610b54565b600095945050505050565b6040519081526020015b60405180910390f35b3480156100c557600080fd5b506100ce61019d565b005b3480156100dc57600080fd5b506100a66100eb366004610ce1565b610287565b3480156100fc57600080fd5b506100a661010b366004610ce1565b610292565b34801561011c57600080fd5b506100a661012b366004610b54565b6103dc565b34801561013c57600080fd5b5061015873ccf3d848e08b94478ed8f46ffead3008faf581fd81565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020016100b0565b34801561018957600080fd5b506100ce610198366004610dc3565b610560565b3373ffffffffffffffffffffffffffffffffffffffff1673ccf3d848e08b94478ed8f46ffead3008faf581fd73ffffffffffffffffffffffffffffffffffffffff1663f851a4406040518163ffffffff1660e01b8152600401602060405180830381865afa158015610213573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906102379190610e04565b73ffffffffffffffffffffffffffffffffffffffff1614610284576040517fa6c827a900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b33ff5b60005b949350505050565b600080546040517f493f4f7400000000000000000000000000000000000000000000000000000000815260026004820152829173ffffffffffffffffffffffffffffffffffffffff169063493f4f7490602401602060405180830381865afa158015610302573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103269190610e04565b90506000808480602001905181019061033f9190610e21565b9150915060008373ffffffffffffffffffffffffffffffffffffffff16637b3d22cf84848a6040518463ffffffff1660e01b815260040161038293929190610faf565b602060405180830381865afa15801561039f573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103c39190610fdb565b90506103cf81886106e8565b9998505050505050505050565b600080546040517f493f4f7400000000000000000000000000000000000000000000000000000000815260026004820152829173ffffffffffffffffffffffffffffffffffffffff169063493f4f7490602401602060405180830381865afa15801561044c573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104709190610e04565b905061049373ffffffffffffffffffffffffffffffffffffffff88168287610721565b6000806104a285870187610ff4565b915091506104ae610b11565b6040517f0651cb3500000000000000000000000000000000000000000000000000000000815260009073ffffffffffffffffffffffffffffffffffffffff861690630651cb359061050e90879087908e90600190899033906004016110e8565b6020604051808303816000875af115801561052d573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906105519190610fdb565b9b9a5050505050505050505050565b3373ffffffffffffffffffffffffffffffffffffffff1673ccf3d848e08b94478ed8f46ffead3008faf581fd73ffffffffffffffffffffffffffffffffffffffff16638da5cb5b6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156105d6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906105fa9190610e04565b73ffffffffffffffffffffffffffffffffffffffff1614610647576040517f19494c8a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee73ffffffffffffffffffffffffffffffffffffffff841614156106c25760405173ffffffffffffffffffffffffffffffffffffffff83169082156108fc029083906000818181858888f193505050501580156106bc573d6000803e3d6000fd5b50505050565b6106e373ffffffffffffffffffffffffffffffffffffffff8416838361084b565b505050565b60008161071061070085670de0b6b3a76400006108a1565b61070b6002866111ab565b6108ad565b61071a91906111ab565b9392505050565b60405173ffffffffffffffffffffffffffffffffffffffff83166024820152600060448201526107f59084907f095ea7b300000000000000000000000000000000000000000000000000000000906064015b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff00000000000000000000000000000000000000000000000000000000909316929092179091526108b9565b60405173ffffffffffffffffffffffffffffffffffffffff83166024820152604481018290526106e39084907f095ea7b30000000000000000000000000000000000000000000000000000000090606401610773565b60405173ffffffffffffffffffffffffffffffffffffffff83166024820152604481018290526106e39084907fa9059cbb0000000000000000000000000000000000000000000000000000000090606401610773565b600061071a82846111e6565b600061071a8284611223565b600061091b826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166109ca9092919063ffffffff16565b8051909150156106e35780806020019051810190610939919061123b565b6106e3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f7420737563636565640000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b606061028a848460008560606109df85610ad8565b610a15576040517f304619b500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff168587604051610a3e9190611289565b60006040518083038185875af1925050503d8060008114610a7b576040519150601f19603f3d011682016040523d82523d6000602084013e610a80565b606091505b50915091508115610a9457915061028a9050565b805115610aa45780518082602001fd5b836040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109c191906112a5565b6000813f7fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47081811480159061028a575050151592915050565b60405180608001604052806004906020820280368337509192915050565b73ffffffffffffffffffffffffffffffffffffffff81168114610b5157600080fd5b50565b600080600080600060808688031215610b6c57600080fd5b8535610b7781610b2f565b94506020860135610b8781610b2f565b935060408601359250606086013567ffffffffffffffff80821115610bab57600080fd5b818801915088601f830112610bbf57600080fd5b813581811115610bce57600080fd5b896020828501011115610be057600080fd5b9699959850939650602001949392505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b604051610120810167ffffffffffffffff81118282101715610c4657610c46610bf3565b60405290565b6040516080810167ffffffffffffffff81118282101715610c4657610c46610bf3565b6040516060810167ffffffffffffffff81118282101715610c4657610c46610bf3565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff81118282101715610cd957610cd9610bf3565b604052919050565b60008060008060808587031215610cf757600080fd5b8435610d0281610b2f565b9350602085810135610d1381610b2f565b935060408601359250606086013567ffffffffffffffff80821115610d3757600080fd5b818801915088601f830112610d4b57600080fd5b813581811115610d5d57610d5d610bf3565b610d8d847fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f84011601610c92565b91508082528984828501011115610da357600080fd5b808484018584013760008482840101525080935050505092959194509250565b600080600060608486031215610dd857600080fd5b8335610de381610b2f565b92506020840135610df381610b2f565b929592945050506040919091013590565b600060208284031215610e1657600080fd5b815161071a81610b2f565b6000806102a0808486031215610e3657600080fd5b601f8581860112610e4657600080fd5b610e4e610c22565b80610120870188811115610e6157600080fd5b875b81811015610e84578051610e7681610b2f565b845260209384019301610e63565b508196508861013f890112610e9857600080fd5b610ea0610c4c565b94880194925082915088851115610eb657600080fd5b84811015610f15578884820112610ecd5760008081fd5b610ed5610c6f565b80606083018b811115610ee85760008081fd5b835b81811015610f02578051845260209384019301610eea565b5050845250602090920191606001610eb6565b50809450505050509250929050565b8060005b60098110156106bc57815173ffffffffffffffffffffffffffffffffffffffff16845260209384019390910190600101610f28565b806000805b6004811015610fa857825185835b6003811015610f8f578251825260209283019290910190600101610f70565b5050506060949094019360209290920191600101610f62565b5050505050565b6102c08101610fbe8286610f24565b610fcc610120830185610f5d565b826102a0830152949350505050565b600060208284031215610fed57600080fd5b5051919050565b6000806102a080848603121561100957600080fd5b601f858186011261101957600080fd5b611021610c22565b8061012087018881111561103457600080fd5b875b8181101561105757803561104981610b2f565b845260209384019301611036565b508196508861013f89011261106b57600080fd5b611073610c4c565b9488019492508291508885111561108957600080fd5b84811015610f155788848201126110a05760008081fd5b6110a8610c6f565b80606083018b8111156110bb5760008081fd5b835b818110156110d55780358452602093840193016110bd565b5050845250602090920191606001611089565b61038081016110f78289610f24565b611105610120830188610f5d565b856102a0830152846102c08301526102e082018460005b600481101561115157815173ffffffffffffffffffffffffffffffffffffffff1683526020928301929091019060010161111c565b50505073ffffffffffffffffffffffffffffffffffffffff8316610360830152979650505050505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6000826111e1577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b500490565b6000817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048311821515161561121e5761121e61117c565b500290565b600082198211156112365761123661117c565b500190565b60006020828403121561124d57600080fd5b8151801515811461071a57600080fd5b60005b83811015611278578181015183820152602001611260565b838111156106bc5750506000910152565b6000825161129b81846020870161125d565b9190910192915050565b60208152600082518060208401526112c481604085016020870161125d565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016919091016040019291505056fea2646970667358221220dd567d20997ab5affc3ab3be4cd60fc09b3a0a4793278fe5c0c6ed20448bb12464736f6c634300080a0033

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