Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - 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 free(uint256 value)
•    - function freeUpTo(uint256 value)
•    - function freeFrom(address from, uint2 ...
•    - function freeFromUpTo(address from, u ...
•    - 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 allowance(address, address)
•    - function balanceOf(address)
•    - function approve(address, uint256)
•    - function transfer(address, uint256)
•    - function transferFrom(address, addres ...
•    - function deposit()
•    - function withdraw(uint256)
•    - function sell(address _srcAddr, addre ...
•    - function buy(address _srcAddr, addres ...
•    - function getSellRate(address _srcAddr ...
•    - function getBuyRate(address _srcAddr, ...
•    - function setAllowlistAddr(address _zr ...
•    - function isZrxAddr(address _zrxAddr)
•    - function addNonPayableAddr(address _n ...
•    - function removeNonPayableAddr(address ...
•    - function isNonPayableAddr(address _ad ...
•  contract DFSExchangeData
•    - function packExchangeData(ExchangeDat ...
•    - function unpackExchangeData(bytes mem ...
•    - function isCustomFeeSet(address _user ...
•    - function getCustomServiceFee(address ...
•    - function setServiceFee(address _user, ...
•    - function disableServiceFee(address _u ...
•    - function getFeeAddr()
•    - function changeWalletAddr(address _ne ...
•    - function getDecimals(address _token)
•    - function getBalance(address _tokenAdd ...
•    - function sendLeftover(address _srcAdd ...
•    - function getFee(uint256 _amount, addr ...
•    - function sliceUint(bytes memory bs, u ...
•    - function writeUint256(bytes memory _b ...
•    - function ethToWethAddr(address _src)
•    - function addWrapper(address _wrapper)
•    - function removeWrapper(address _wrapp ...
•    - function isWrapper(address _wrapper)
•    - function takeOrder(
•  contract DFSExchangeCore is DFSExc ...
•    - function _sell(ExchangeData memory ex ...
•    - function _buy(ExchangeData memory exD ...
•    - function takeOrder(
•    - function saverSwap(ExchangeData memor ...
•    - function Log(address _contract, addre ...
•  contract DFSExchange is DFSExchang ...
•    - function sell(ExchangeData memory exD ...
•    - function buy(ExchangeData memory exDa ...
•    - function changeBurnAmount(uint _newBu ...
•  contract AllowanceProxy is AdminAu ... *
•    - function callSell(DFSExchangeCore.Exc ...
•    - function callBuy(DFSExchangeCore.Exch ...
•    - function pullAndSendTokens(address _t ...
•    - function ownerChangeExchange(address ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

pragma solidity ^0.6.0; 
pragma experimental ABIEncoderV2;

  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);
        }
    }
}   abstract contract GasTokenInterface is ERC20 {
    function free(uint256 value) public virtual returns (bool success);

    function freeUpTo(uint256 value) public virtual returns (uint256 freed);

    function freeFrom(address from, uint256 value) public virtual returns (bool success);

    function freeFromUpTo(address from, uint256 value) public virtual returns (uint256 freed);
}   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);
            }
        }
    }
}   abstract contract TokenInterface {
	address public constant WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
    
    function allowance(address, address) public virtual returns (uint256);

    function balanceOf(address) public virtual 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 virtual payable;

    function withdraw(uint256) public virtual;
}   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 view returns (uint);

    function getBuyRate(address _srcAddr, address _destAddr, uint _srcAmount, bytes memory _additionalData) external view returns (uint);
}   contract ZrxAllowlist is AdminAuth {

    mapping (address => bool) public zrxAllowlist;
    mapping(address => bool) private nonPayableAddrs;

    constructor() public {
        zrxAllowlist[0x6958F5e95332D93D21af0D7B9Ca85B8212fEE0A5] = true;
        zrxAllowlist[0x61935CbDd02287B511119DDb11Aeb42F1593b7Ef] = true;
        zrxAllowlist[0xDef1C0ded9bec7F1a1670819833240f027b25EfF] = true;
        zrxAllowlist[0x080bf510FCbF18b91105470639e9561022937712] = true;

        nonPayableAddrs[0x080bf510FCbF18b91105470639e9561022937712] = true;
    }

    function setAllowlistAddr(address _zrxAddr, bool _state) public onlyOwner {
        zrxAllowlist[_zrxAddr] = _state;
    }

    function isZrxAddr(address _zrxAddr) public view returns (bool) {
        return zrxAllowlist[_zrxAddr];
    }

    function addNonPayableAddr(address _nonPayableAddr) public onlyOwner {
		nonPayableAddrs[_nonPayableAddr] = true;
	}

	function removeNonPayableAddr(address _nonPayableAddr) public onlyOwner {
		nonPayableAddrs[_nonPayableAddr] = false;
	}

	function isNonPayableAddr(address _addr) public view returns(bool) {
		return nonPayableAddrs[_addr];
	}
}      

contract DFSExchangeData {

    // first is empty to keep the legacy order in place
    enum ExchangeType { _, OASIS, KYBER, UNISWAP, ZEROX }

    enum ActionType { SELL, BUY }

    struct OffchainData {
        address wrapper;
        address exchangeAddr;
        address allowanceTarget;
        uint256 price;
        uint256 protocolFee;
        bytes callData;
    }

    struct ExchangeData {
        address srcAddr;
        address destAddr;
        uint256 srcAmount;
        uint256 destAmount;
        uint256 minPrice;
        uint256 dfsFeeDivider; // service fee divider
        address user; // user to check special fee
        address wrapper;
        bytes wrapperData;
        OffchainData offchainData;
    }

    function packExchangeData(ExchangeData memory _exData) public pure returns(bytes memory) {
        return abi.encode(_exData);
    }

    function unpackExchangeData(bytes memory _data) public pure returns(ExchangeData memory _exData) {
        _exData = abi.decode(_data, (ExchangeData));
    }
}   contract Discount {
    address public owner;
    mapping(address => CustomServiceFee) public serviceFees;

    uint256 constant MAX_SERVICE_FEE = 400;

    struct CustomServiceFee {
        bool active;
        uint256 amount;
    }

    constructor() public {
        owner = msg.sender;
    }

    function isCustomFeeSet(address _user) public view returns (bool) {
        return serviceFees[_user].active;
    }

    function getCustomServiceFee(address _user) public view returns (uint256) {
        return serviceFees[_user].amount;
    }

    function setServiceFee(address _user, uint256 _fee) public {
        require(msg.sender == owner, "Only owner");
        require(_fee >= MAX_SERVICE_FEE || _fee == 0);

        serviceFees[_user] = CustomServiceFee({active: true, amount: _fee});
    }

    function disableServiceFee(address _user) public {
        require(msg.sender == owner, "Only owner");

        serviceFees[_user] = CustomServiceFee({active: false, amount: 0});
    }
}   // SPDX-License-Identifier: MIT



abstract contract IFeeRecipient {
    function getFeeAddr() public view virtual returns (address);
    function changeWalletAddr(address _newWallet) public virtual;
}   contract DFSExchangeHelper {

    string public constant ERR_OFFCHAIN_DATA_INVALID = "Offchain data invalid";

    using SafeERC20 for ERC20;

    address public constant KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    address public constant EXCHANGE_WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;

    IFeeRecipient public constant _feeRecipient = IFeeRecipient(0x39C4a92Dc506300c3Ea4c67ca4CA611102ee6F2A);

    address public constant DISCOUNT_ADDRESS = 0x1b14E8D511c9A4395425314f849bD737BAF8208F;
    address public constant SAVER_EXCHANGE_REGISTRY = 0x25dd3F51e0C3c3Ff164DDC02A8E4D65Bb9cBB12D;

    address public constant ZRX_ALLOWLIST_ADDR = 0x4BA1f38427b33B8ab7Bb0490200dAE1F1C36823F;


    function getDecimals(address _token) internal view returns (uint256) {
        if (_token == KYBER_ETH_ADDRESS) return 18;

        return ERC20(_token).decimals();
    }

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

    function sendLeftover(address _srcAddr, address _destAddr, address payable _to) internal {
        // send back any leftover ether or tokens
        if (address(this).balance > 0) {
            _to.transfer(address(this).balance);
        }

        if (getBalance(_srcAddr) > 0) {
            ERC20(_srcAddr).safeTransfer(_to, getBalance(_srcAddr));
        }

        if (getBalance(_destAddr) > 0) {
            ERC20(_destAddr).safeTransfer(_to, getBalance(_destAddr));
        }
    }

    /// @notice Takes a feePercentage and sends it to wallet
    /// @param _amount Dai amount of the whole trade
    /// @param _user Address of the user
    /// @param _token Address of the token
    /// @param _dfsFeeDivider Dfs fee divider
    /// @return feeAmount Amount in Dai owner earned on the fee
    function getFee(uint256 _amount, address _user, address _token, uint256 _dfsFeeDivider) internal returns (uint256 feeAmount) {
        if (_dfsFeeDivider != 0 && Discount(DISCOUNT_ADDRESS).isCustomFeeSet(_user)) {
            _dfsFeeDivider = Discount(DISCOUNT_ADDRESS).getCustomServiceFee(_user);
        }

        if (_dfsFeeDivider == 0) {
            feeAmount = 0;
        } else {
            feeAmount = _amount / _dfsFeeDivider;

            // fee can't go over 10% of the whole amount
            if (feeAmount > (_amount / 10)) {
                feeAmount = _amount / 10;
            }

            address walletAddr = _feeRecipient.getFeeAddr();

            if (_token == KYBER_ETH_ADDRESS) {
                payable(walletAddr).transfer(feeAmount);
            } else {
                ERC20(_token).safeTransfer(walletAddr, feeAmount);
            }
        }
    }

    function sliceUint(bytes memory bs, uint256 start) internal pure returns (uint256) {
        require(bs.length >= start + 32, "slicing out of range");

        uint256 x;
        assembly {
            x := mload(add(bs, add(0x20, start)))
        }

        return x;
    }

        function writeUint256(bytes memory _b, uint256 _index, uint _input) internal pure {
        if (_b.length < _index + 32) {
            revert(ERR_OFFCHAIN_DATA_INVALID);
        }

        bytes32 input = bytes32(_input);

        _index += 32;

        // Read the bytes32 from array memory
        assembly {
            mstore(add(_b, _index), input)
        }
    }

    /// @notice Converts Kybers Eth address -> Weth
    /// @param _src Input address
    function ethToWethAddr(address _src) internal pure returns (address) {
        return _src == KYBER_ETH_ADDRESS ? EXCHANGE_WETH_ADDRESS : _src;
    }
}   contract SaverExchangeRegistry is AdminAuth {

	mapping(address => bool) private wrappers;

	constructor() public {
		wrappers[0x880A845A85F843a5c67DB2061623c6Fc3bB4c511] = true;
		wrappers[0x4c9B55f2083629A1F7aDa257ae984E03096eCD25] = true;
		wrappers[0x42A9237b872368E1bec4Ca8D26A928D7d39d338C] = true;
	}

	function addWrapper(address _wrapper) public onlyOwner {
		wrappers[_wrapper] = true;
	}

	function removeWrapper(address _wrapper) public onlyOwner {
		wrappers[_wrapper] = false;
	}

	function isWrapper(address _wrapper) public view returns(bool) {
		return wrappers[_wrapper];
	}
}      



abstract contract OffchainWrapperInterface is DFSExchangeData {
    function takeOrder(
        ExchangeData memory _exData,
        ActionType _type
    ) virtual public payable returns (bool success, uint256);
}      










contract DFSExchangeCore is DFSExchangeHelper, DSMath, DFSExchangeData {

    string public constant ERR_SLIPPAGE_HIT = "Slippage hit";
    string public constant ERR_DEST_AMOUNT_MISSING = "Dest amount missing";
    string public constant ERR_WRAPPER_INVALID = "Wrapper invalid";
    string public constant ERR_NOT_ZEROX_EXCHANGE = "Zerox exchange invalid";

    /// @notice Internal method that preforms a sell on 0x/on-chain
    /// @dev Usefull for other DFS contract to integrate for exchanging
    /// @param exData Exchange data struct
    /// @return (address, uint) Address of the wrapper used and destAmount
    function _sell(ExchangeData memory exData) internal returns (address, uint) {

        address wrapper;
        uint swapedTokens;
        bool success;

        // if selling eth, convert to weth
        if (exData.srcAddr == KYBER_ETH_ADDRESS) {
            exData.srcAddr = ethToWethAddr(exData.srcAddr);
            TokenInterface(EXCHANGE_WETH_ADDRESS).deposit{value: exData.srcAmount}();
        }

        exData.srcAmount -= getFee(exData.srcAmount, exData.user, exData.srcAddr, exData.dfsFeeDivider);

        // Try 0x first and then fallback on specific wrapper
        if (exData.offchainData.price > 0) {
            (success, swapedTokens) = takeOrder(exData, ActionType.SELL);

            if (success) {
                wrapper = exData.offchainData.exchangeAddr;
            }
        }

        // fallback to desired wrapper if 0x failed
        if (!success) {
            swapedTokens = saverSwap(exData, ActionType.SELL);
            wrapper = exData.wrapper;
        }

        // if anything is left in weth, pull it to user as eth
        if (getBalance(EXCHANGE_WETH_ADDRESS) > 0) {
            TokenInterface(EXCHANGE_WETH_ADDRESS).withdraw(
                TokenInterface(EXCHANGE_WETH_ADDRESS).balanceOf(address(this))
            );
        }

        if (exData.destAddr == EXCHANGE_WETH_ADDRESS) {
            require(getBalance(KYBER_ETH_ADDRESS) >= wmul(exData.minPrice, exData.srcAmount), ERR_SLIPPAGE_HIT);
        } else {
            require(getBalance(exData.destAddr) >= wmul(exData.minPrice, exData.srcAmount), ERR_SLIPPAGE_HIT);
        }

        return (wrapper, swapedTokens);
    }

    /// @notice Internal method that preforms a buy on 0x/on-chain
    /// @dev Usefull for other DFS contract to integrate for exchanging
    /// @param exData Exchange data struct
    /// @return (address, uint) Address of the wrapper used and srcAmount
    function _buy(ExchangeData memory exData) internal returns (address, uint) {

        address wrapper;
        uint swapedTokens;
        bool success;

        require(exData.destAmount != 0, ERR_DEST_AMOUNT_MISSING);

        exData.srcAmount -= getFee(exData.srcAmount, exData.user, exData.srcAddr, exData.dfsFeeDivider);

        // if selling eth, convert to weth
        if (exData.srcAddr == KYBER_ETH_ADDRESS) {
            exData.srcAddr = ethToWethAddr(exData.srcAddr);
            TokenInterface(EXCHANGE_WETH_ADDRESS).deposit{value: exData.srcAmount}();
        }

        if (exData.offchainData.price > 0) {
            (success, swapedTokens) = takeOrder(exData, ActionType.BUY);

            if (success) {
                wrapper = exData.offchainData.exchangeAddr;
            }
        }

        // fallback to desired wrapper if 0x failed
        if (!success) {
            swapedTokens = saverSwap(exData, ActionType.BUY);
            wrapper = exData.wrapper;
        }

        // if anything is left in weth, pull it to user as eth
        if (getBalance(EXCHANGE_WETH_ADDRESS) > 0) {
            TokenInterface(EXCHANGE_WETH_ADDRESS).withdraw(
                TokenInterface(EXCHANGE_WETH_ADDRESS).balanceOf(address(this))
            );
        }

        if (exData.destAddr == EXCHANGE_WETH_ADDRESS) {
            require(getBalance(KYBER_ETH_ADDRESS) >= exData.destAmount, ERR_SLIPPAGE_HIT);
        } else {
            require(getBalance(exData.destAddr) >= exData.destAmount, ERR_SLIPPAGE_HIT);
        }

        return (wrapper, getBalance(exData.destAddr));
    }

    /// @notice Takes order from 0x and returns bool indicating if it is successful
    /// @param _exData Exchange data
    function takeOrder(
        ExchangeData memory _exData,
        ActionType _type
    ) private returns (bool success, uint256) {
        if (!ZrxAllowlist(ZRX_ALLOWLIST_ADDR).isZrxAddr(_exData.offchainData.exchangeAddr)) {
            return (false, 0);
        }

        if (!SaverExchangeRegistry(SAVER_EXCHANGE_REGISTRY).isWrapper(_exData.offchainData.wrapper)) {
            return (false, 0);
        }

        // send src amount
        ERC20(_exData.srcAddr).safeTransfer(_exData.offchainData.wrapper, _exData.srcAmount);

        return OffchainWrapperInterface(_exData.offchainData.wrapper).takeOrder{value: _exData.offchainData.protocolFee}(_exData, _type);
    }

    /// @notice Calls wraper contract for exchage to preform an on-chain swap
    /// @param _exData Exchange data struct
    /// @param _type Type of action SELL|BUY
    /// @return swapedTokens For Sell that the destAmount, for Buy thats the srcAmount
    function saverSwap(ExchangeData memory _exData, ActionType _type) internal returns (uint swapedTokens) {
        require(SaverExchangeRegistry(SAVER_EXCHANGE_REGISTRY).isWrapper(_exData.wrapper), ERR_WRAPPER_INVALID);

        ERC20(_exData.srcAddr).safeTransfer(_exData.wrapper, _exData.srcAmount);

        if (_type == ActionType.SELL) {
            swapedTokens = ExchangeInterfaceV3(_exData.wrapper).
                    sell(_exData.srcAddr, _exData.destAddr, _exData.srcAmount, _exData.wrapperData);
        } else {
            swapedTokens = ExchangeInterfaceV3(_exData.wrapper).
                    buy(_exData.srcAddr, _exData.destAddr, _exData.destAmount, _exData.wrapperData);
        }
    }

    // solhint-disable-next-line no-empty-blocks
    receive() external virtual payable {}
}   contract DefisaverLogger {
    event LogEvent(
        address indexed contractAddress,
        address indexed caller,
        string indexed logName,
        bytes data
    );

    // solhint-disable-next-line func-name-mixedcase
    function Log(address _contract, address _caller, string memory _logName, bytes memory _data)
        public
    {
        emit LogEvent(_contract, _caller, _logName, _data);
    }
}   contract GasBurner {
    // solhint-disable-next-line const-name-snakecase
    GasTokenInterface public constant gasToken = GasTokenInterface(0x0000000000b3F879cb30FE243b4Dfee438691c04);

    modifier burnGas(uint _amount) {
        if (gasToken.balanceOf(address(this)) >= _amount) {
            gasToken.free(_amount);
        }

        _;
    }
}      









contract DFSExchange is DFSExchangeCore, AdminAuth, GasBurner {

    using SafeERC20 for ERC20;

    uint256 public constant SERVICE_FEE = 800; // 0.125% Fee

    // solhint-disable-next-line const-name-snakecase
    DefisaverLogger public constant logger = DefisaverLogger(0x5c55B921f590a89C1Ebe84dF170E655a82b62126);

    uint public burnAmount = 10;

    /// @notice Takes a src amount of tokens and converts it into the dest token
    /// @dev Takes fee from the _srcAmount before the exchange
    /// @param exData [srcAddr, destAddr, srcAmount, destAmount, minPrice, exchangeType, exchangeAddr, callData, price0x]
    /// @param _user User address who called the exchange
    function sell(ExchangeData memory exData, address payable _user) public payable burnGas(burnAmount) {

        exData.dfsFeeDivider = SERVICE_FEE;
        exData.user = _user;

        // Perform the exchange
        (address wrapper, uint destAmount) = _sell(exData);

        // send back any leftover ether or tokens
        sendLeftover(exData.srcAddr, exData.destAddr, _user);

        // log the event
        logger.Log(address(this), msg.sender, "ExchangeSell", abi.encode(wrapper, exData.srcAddr, exData.destAddr, exData.srcAmount, destAmount));
    }

    /// @notice Takes a dest amount of tokens and converts it from the src token
    /// @dev Send always more than needed for the swap, extra will be returned
    /// @param exData [srcAddr, destAddr, srcAmount, destAmount, minPrice, exchangeType, exchangeAddr, callData, price0x]
    /// @param _user User address who called the exchange
    function buy(ExchangeData memory exData, address payable _user) public payable burnGas(burnAmount){

        exData.dfsFeeDivider = SERVICE_FEE;
        exData.user = _user;

        // Perform the exchange
        (address wrapper, uint srcAmount) = _buy(exData);

        // send back any leftover ether or tokens
        sendLeftover(exData.srcAddr, exData.destAddr, _user);

        // log the event
        logger.Log(address(this), msg.sender, "ExchangeBuy", abi.encode(wrapper, exData.srcAddr, exData.destAddr, srcAmount, exData.destAmount));

    }

    /// @notice Changes the amount of gas token we burn for each call
    /// @dev Only callable by the owner
    /// @param _newBurnAmount New amount of gas tokens to be burned
    function changeBurnAmount(uint _newBurnAmount) public {
        require(owner == msg.sender);

        burnAmount = _newBurnAmount;
    }

}      





contract AllowanceProxy is AdminAuth {

    using SafeERC20 for ERC20;

    address public constant KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;

    DFSExchange dfsExchange = DFSExchange(0xc2Ce04e2FB4DD20964b4410FcE718b95963a1587);

    function callSell(DFSExchangeCore.ExchangeData memory exData) public payable {
        pullAndSendTokens(exData.srcAddr, exData.srcAmount);

        dfsExchange.sell{value: msg.value}(exData, msg.sender);
    }

    function callBuy(DFSExchangeCore.ExchangeData memory exData) public payable {
        pullAndSendTokens(exData.srcAddr, exData.srcAmount);

        dfsExchange.buy{value: msg.value}(exData, msg.sender);
    }

    function pullAndSendTokens(address _tokenAddr, uint _amount) internal {
        if (_tokenAddr == KYBER_ETH_ADDRESS) {
            require(msg.value >= _amount, "msg.value smaller than amount");
        } else {
            ERC20(_tokenAddr).safeTransferFrom(msg.sender, address(dfsExchange), _amount);
        }
    }

    function ownerChangeExchange(address payable _newExchange) public onlyOwner {
        dfsExchange = DFSExchange(_newExchange);
    }
}

• 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":[{"components":[{"internalType":"address","name":"srcAddr","type":"address"},{"internalType":"address","name":"destAddr","type":"address"},{"internalType":"uint256","name":"srcAmount","type":"uint256"},{"internalType":"uint256","name":"destAmount","type":"uint256"},{"internalType":"uint256","name":"minPrice","type":"uint256"},{"internalType":"uint256","name":"dfsFeeDivider","type":"uint256"},{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"wrapper","type":"address"},{"internalType":"bytes","name":"wrapperData","type":"bytes"},{"components":[{"internalType":"address","name":"wrapper","type":"address"},{"internalType":"address","name":"exchangeAddr","type":"address"},{"internalType":"address","name":"allowanceTarget","type":"address"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"uint256","name":"protocolFee","type":"uint256"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct DFSExchangeData.OffchainData","name":"offchainData","type":"tuple"}],"internalType":"struct DFSExchangeData.ExchangeData","name":"exData","type":"tuple"}],"name":"callBuy","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"srcAddr","type":"address"},{"internalType":"address","name":"destAddr","type":"address"},{"internalType":"uint256","name":"srcAmount","type":"uint256"},{"internalType":"uint256","name":"destAmount","type":"uint256"},{"internalType":"uint256","name":"minPrice","type":"uint256"},{"internalType":"uint256","name":"dfsFeeDivider","type":"uint256"},{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"wrapper","type":"address"},{"internalType":"bytes","name":"wrapperData","type":"bytes"},{"components":[{"internalType":"address","name":"wrapper","type":"address"},{"internalType":"address","name":"exchangeAddr","type":"address"},{"internalType":"address","name":"allowanceTarget","type":"address"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"uint256","name":"protocolFee","type":"uint256"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct DFSExchangeData.OffchainData","name":"offchainData","type":"tuple"}],"internalType":"struct DFSExchangeData.ExchangeData","name":"exData","type":"tuple"}],"name":"callSell","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"kill","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"_newExchange","type":"address"}],"name":"ownerChangeExchange","outputs":[],"stateMutability":"nonpayable","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"}]

6080604052600280546001600160a01b03191673c2ce04e2fb4dd20964b4410fce718b95963a158717905534801561003657600080fd5b50600080546001600160a01b031990811673bc841b0de0b93205e912cfbbd1d0c160a1ec6f0017909155600180549091167325efa336886c74ea8e282ac466bdcd0199f85bb9179055610cae8061008e6000396000f3fe60806040526004361061009c5760003560e01c80638da5cb5b116100645780638da5cb5b14610136578063917993721461014b578063a707fe111461015e578063a7304bf71461017e578063deca5f881461019e578063f851a440146101be5761009c565b80631e48907b146100a157806329f7fc9e146100c35780633a128322146100ee57806341c0e1b51461010e5780635604e33814610123575b600080fd5b3480156100ad57600080fd5b506100c16100bc366004610810565b6101d3565b005b3480156100cf57600080fd5b506100d861020c565b6040516100e59190610a29565b60405180910390f35b3480156100fa57600080fd5b506100c161010936600461082c565b610224565b34801561011a57600080fd5b506100c16102bd565b6100c1610131366004610877565b6102e2565b34801561014257600080fd5b506100d861035d565b6100c1610159366004610877565b61036c565b34801561016a57600080fd5b506100c1610179366004610810565b6103b2565b34801561018a57600080fd5b506100c1610199366004610810565b6103eb565b3480156101aa57600080fd5b506100c16101b9366004610810565b610424565b3480156101ca57600080fd5b506100d8610451565b6001546001600160a01b031633146101ea57600080fd5b600080546001600160a01b0319166001600160a01b0392909216919091179055565b73eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee81565b6000546001600160a01b0316331461023b57600080fd5b73eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee6001600160a01b038316141561029f57600080546040516001600160a01b039091169183156108fc02918491818181858888f19350505050158015610299573d6000803e3d6000fd5b506102b9565b6000546102b9906001600160a01b03848116911683610460565b5050565b6000546001600160a01b031633146102d457600080fd5b6000546001600160a01b0316ff5b6102f4816000015182604001516104bb565b600254604051630f7379b760e01b81526001600160a01b0390911690630f7379b79034906103289085903390600401610b45565b6000604051808303818588803b15801561034157600080fd5b505af1158015610355573d6000803e3d6000fd5b505050505050565b6000546001600160a01b031681565b61037e816000015182604001516104bb565b60025460405163195f8d4160e11b81526001600160a01b03909116906332bf1a829034906103289085903390600401610b45565b6000546001600160a01b031633146103c957600080fd5b600280546001600160a01b0319166001600160a01b0392909216919091179055565b6001546001600160a01b0316331461040257600080fd5b600180546001600160a01b0319166001600160a01b0392909216919091179055565b6000546001600160a01b0316331461043b57600080fd5b6001546001600160a01b03161561040257600080fd5b6001546001600160a01b031681565b6104b68363a9059cbb60e01b848460405160240161047f929190610a61565b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b03199093169290921790915261052a565b505050565b6001600160a01b03821673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee141561050e57803410156105095760405162461bcd60e51b815260040161050090610a8d565b60405180910390fd5b6102b9565b6002546102b9906001600160a01b0384811691339116846105b9565b606061057f826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166105e09092919063ffffffff16565b8051909150156104b6578080602001905181019061059d9190610857565b6104b65760405162461bcd60e51b815260040161050090610afb565b6105da846323b872dd60e01b85858560405160240161047f93929190610a3d565b50505050565b60606105ef84846000856105f9565b90505b9392505050565b6060610604856106c5565b6106205760405162461bcd60e51b815260040161050090610ac4565b60006060866001600160a01b0316858760405161063d9190610a0d565b60006040518083038185875af1925050503d806000811461067a576040519150601f19603f3d011682016040523d82523d6000602084013e61067f565b606091505b509150915081156106935791506106bd9050565b8051156106a35780518082602001fd5b8360405162461bcd60e51b81526004016105009190610a7a565b949350505050565b6000813f7fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a4708181148015906106bd575050151592915050565b803561070981610c60565b92915050565b600082601f83011261071f578081fd5b813567ffffffffffffffff811115610735578182fd5b610748601f8201601f1916602001610c0d565b915080825283602082850101111561075f57600080fd5b8060208401602084013760009082016020015292915050565b600060c08284031215610789578081fd5b61079360c0610c0d565b905081356107a081610c60565b815260208201356107b081610c60565b602082015260408201356107c381610c60565b80604083015250606082013560608201526080820135608082015260a082013567ffffffffffffffff8111156107f857600080fd5b6108048482850161070f565b60a08301525092915050565b600060208284031215610821578081fd5b81356105f281610c60565b6000806040838503121561083e578081fd5b823561084981610c60565b946020939093013593505050565b600060208284031215610868578081fd5b815180151581146105f2578182fd5b600060208284031215610888578081fd5b813567ffffffffffffffff8082111561089f578283fd5b81840191506101408083870312156108b5578384fd5b6108be81610c0d565b90506108ca86846106fe565b81526108d986602085016106fe565b602082015260408301356040820152606083013560608201526080830135608082015260a083013560a08201526109138660c085016106fe565b60c08201526109258660e085016106fe565b60e0820152610100808401358381111561093d578586fd5b6109498882870161070f565b8284015250506101208084013583811115610962578586fd5b61096e88828701610778565b918301919091525095945050505050565b6001600160a01b03169052565b600081518084526109a4816020860160208601610c34565b601f01601f19169290920160200192915050565b600060018060a01b0380835116845280602084015116602085015280604084015116604085015250606082015160608401526080820151608084015260a082015160c060a08501526106bd60c085018261098c565b60008251610a1f818460208701610c34565b9190910192915050565b6001600160a01b0391909116815260200190565b6001600160a01b039384168152919092166020820152604081019190915260600190565b6001600160a01b03929092168252602082015260400190565b6000602082526105f2602083018461098c565b6020808252601d908201527f6d73672e76616c756520736d616c6c6572207468616e20616d6f756e74000000604082015260600190565b6020808252601d908201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604082015260600190565b6020808252602a908201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6040820152691bdd081cdd58d8d9595960b21b606082015260800190565b600060408252610b5960408301855161097f565b6020840151610b6b606084018261097f565b5060408401516080830152606084015160a0830152608084015160c083015260a084015160e083015260c0840151610100610ba88185018361097f565b60e08601519150610120610bbe8186018461097f565b81870151925061014091508182860152610bdc61018086018461098c565b90870151858203603f19016101608701529092509050610bfc82826109b8565b925050506105f2602083018461097f565b60405181810167ffffffffffffffff81118282101715610c2c57600080fd5b604052919050565b60005b83811015610c4f578181015183820152602001610c37565b838111156105da5750506000910152565b6001600160a01b0381168114610c7557600080fd5b5056fea26469706673582212200c455f6e8a3c7bd303da34aeb176d3a9438164375afa21ce23f514b5c47d06fe64736f6c634300060c0033

0x60806040526004361061009c5760003560e01c80638da5cb5b116100645780638da5cb5b14610136578063917993721461014b578063a707fe111461015e578063a7304bf71461017e578063deca5f881461019e578063f851a440146101be5761009c565b80631e48907b146100a157806329f7fc9e146100c35780633a128322146100ee57806341c0e1b51461010e5780635604e33814610123575b600080fd5b3480156100ad57600080fd5b506100c16100bc366004610810565b6101d3565b005b3480156100cf57600080fd5b506100d861020c565b6040516100e59190610a29565b60405180910390f35b3480156100fa57600080fd5b506100c161010936600461082c565b610224565b34801561011a57600080fd5b506100c16102bd565b6100c1610131366004610877565b6102e2565b34801561014257600080fd5b506100d861035d565b6100c1610159366004610877565b61036c565b34801561016a57600080fd5b506100c1610179366004610810565b6103b2565b34801561018a57600080fd5b506100c1610199366004610810565b6103eb565b3480156101aa57600080fd5b506100c16101b9366004610810565b610424565b3480156101ca57600080fd5b506100d8610451565b6001546001600160a01b031633146101ea57600080fd5b600080546001600160a01b0319166001600160a01b0392909216919091179055565b73eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee81565b6000546001600160a01b0316331461023b57600080fd5b73eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee6001600160a01b038316141561029f57600080546040516001600160a01b039091169183156108fc02918491818181858888f19350505050158015610299573d6000803e3d6000fd5b506102b9565b6000546102b9906001600160a01b03848116911683610460565b5050565b6000546001600160a01b031633146102d457600080fd5b6000546001600160a01b0316ff5b6102f4816000015182604001516104bb565b600254604051630f7379b760e01b81526001600160a01b0390911690630f7379b79034906103289085903390600401610b45565b6000604051808303818588803b15801561034157600080fd5b505af1158015610355573d6000803e3d6000fd5b505050505050565b6000546001600160a01b031681565b61037e816000015182604001516104bb565b60025460405163195f8d4160e11b81526001600160a01b03909116906332bf1a829034906103289085903390600401610b45565b6000546001600160a01b031633146103c957600080fd5b600280546001600160a01b0319166001600160a01b0392909216919091179055565b6001546001600160a01b0316331461040257600080fd5b600180546001600160a01b0319166001600160a01b0392909216919091179055565b6000546001600160a01b0316331461043b57600080fd5b6001546001600160a01b03161561040257600080fd5b6001546001600160a01b031681565b6104b68363a9059cbb60e01b848460405160240161047f929190610a61565b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b03199093169290921790915261052a565b505050565b6001600160a01b03821673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee141561050e57803410156105095760405162461bcd60e51b815260040161050090610a8d565b60405180910390fd5b6102b9565b6002546102b9906001600160a01b0384811691339116846105b9565b606061057f826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166105e09092919063ffffffff16565b8051909150156104b6578080602001905181019061059d9190610857565b6104b65760405162461bcd60e51b815260040161050090610afb565b6105da846323b872dd60e01b85858560405160240161047f93929190610a3d565b50505050565b60606105ef84846000856105f9565b90505b9392505050565b6060610604856106c5565b6106205760405162461bcd60e51b815260040161050090610ac4565b60006060866001600160a01b0316858760405161063d9190610a0d565b60006040518083038185875af1925050503d806000811461067a576040519150601f19603f3d011682016040523d82523d6000602084013e61067f565b606091505b509150915081156106935791506106bd9050565b8051156106a35780518082602001fd5b8360405162461bcd60e51b81526004016105009190610a7a565b949350505050565b6000813f7fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a4708181148015906106bd575050151592915050565b803561070981610c60565b92915050565b600082601f83011261071f578081fd5b813567ffffffffffffffff811115610735578182fd5b610748601f8201601f1916602001610c0d565b915080825283602082850101111561075f57600080fd5b8060208401602084013760009082016020015292915050565b600060c08284031215610789578081fd5b61079360c0610c0d565b905081356107a081610c60565b815260208201356107b081610c60565b602082015260408201356107c381610c60565b80604083015250606082013560608201526080820135608082015260a082013567ffffffffffffffff8111156107f857600080fd5b6108048482850161070f565b60a08301525092915050565b600060208284031215610821578081fd5b81356105f281610c60565b6000806040838503121561083e578081fd5b823561084981610c60565b946020939093013593505050565b600060208284031215610868578081fd5b815180151581146105f2578182fd5b600060208284031215610888578081fd5b813567ffffffffffffffff8082111561089f578283fd5b81840191506101408083870312156108b5578384fd5b6108be81610c0d565b90506108ca86846106fe565b81526108d986602085016106fe565b602082015260408301356040820152606083013560608201526080830135608082015260a083013560a08201526109138660c085016106fe565b60c08201526109258660e085016106fe565b60e0820152610100808401358381111561093d578586fd5b6109498882870161070f565b8284015250506101208084013583811115610962578586fd5b61096e88828701610778565b918301919091525095945050505050565b6001600160a01b03169052565b600081518084526109a4816020860160208601610c34565b601f01601f19169290920160200192915050565b600060018060a01b0380835116845280602084015116602085015280604084015116604085015250606082015160608401526080820151608084015260a082015160c060a08501526106bd60c085018261098c565b60008251610a1f818460208701610c34565b9190910192915050565b6001600160a01b0391909116815260200190565b6001600160a01b039384168152919092166020820152604081019190915260600190565b6001600160a01b03929092168252602082015260400190565b6000602082526105f2602083018461098c565b6020808252601d908201527f6d73672e76616c756520736d616c6c6572207468616e20616d6f756e74000000604082015260600190565b6020808252601d908201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604082015260600190565b6020808252602a908201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6040820152691bdd081cdd58d8d9595960b21b606082015260800190565b600060408252610b5960408301855161097f565b6020840151610b6b606084018261097f565b5060408401516080830152606084015160a0830152608084015160c083015260a084015160e083015260c0840151610100610ba88185018361097f565b60e08601519150610120610bbe8186018461097f565b81870151925061014091508182860152610bdc61018086018461098c565b90870151858203603f19016101608701529092509050610bfc82826109b8565b925050506105f2602083018461097f565b60405181810167ffffffffffffffff81118282101715610c2c57600080fd5b604052919050565b60005b83811015610c4f578181015183820152602001610c37565b838111156105da5750506000910152565b6001600160a01b0381168114610c7557600080fd5b5056fea26469706673582212200c455f6e8a3c7bd303da34aeb176d3a9438164375afa21ce23f514b5c47d06fe64736f6c634300060c0033

31006:1176:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8677:122;;;;;;;;;;-1:-1:-1;8677:122:0;;;;;:::i;:::-;;:::i;:::-;;31086:86;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8972:285;;;;;;;;;;-1:-1:-1;8972:285:0;;;;;:::i;:::-;;:::i;8845:80::-;;;;;;;;;;;;;:::i;31493:212::-;;;;;;:::i;:::-;;:::i;7603:20::-;;;;;;;;;;;;;:::i;31271:214::-;;;;;;:::i;:::-;;:::i;32045:134::-;;;;;;;;;;-1:-1:-1;32045:134:0;;;;;:::i;:::-;;:::i;8456:122::-;;;;;;;;;;-1:-1:-1;8456:122:0;;;;;:::i;:::-;;:::i;8173:161::-;;;;;;;;;;-1:-1:-1;8173:161:0;;;;;:::i;:::-;;:::i;7630:20::-;;;;;;;;;;;;;:::i;8677:122::-;8758:5;;-1:-1:-1;;;;;8758:5:0;8744:10;:19;8736:28;;;;;;8777:5;:14;;-1:-1:-1;;;;;;8777:14:0;-1:-1:-1;;;;;8777:14:0;;;;;;;;;;8677:122::o;31086:86::-;31130:42;31086:86;:::o;8972:285::-;7699:5;;-1:-1:-1;;;;;7699:5:0;7708:10;7699:19;7691:28;;;;;;9072:42:::1;-1:-1:-1::0;;;;;9062:52:0;::::1;;9058:192;;;9139:5;::::0;;9131:32:::1;::::0;-1:-1:-1;;;;;9139:5:0;;::::1;::::0;9131:32;::::1;;;::::0;9155:7;;9131:32;9139:5;9131:32;9155:7;9139:5;9131:32;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;9058:192;;;9223:5;::::0;9196:42:::1;::::0;-1:-1:-1;;;;;9196:26:0;;::::1;::::0;9223:5:::1;9230:7:::0;9196:26:::1;:42::i;:::-;8972:285:::0;;:::o;8845:80::-;7699:5;;-1:-1:-1;;;;;7699:5:0;7708:10;7699:19;7691:28;;;;;;8910:5:::1;::::0;-1:-1:-1;;;;;8910:5:0::1;8889:28;31493:212:::0;31580:51;31598:6;:14;;;31614:6;:16;;;31580:17;:51::i;:::-;31644:11;;:53;;-1:-1:-1;;;31644:53:0;;-1:-1:-1;;;;;31644:11:0;;;;:15;;31667:9;;31644:53;;31678:6;;31686:10;;31644:53;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31493:212;:::o;7603:20::-;;;-1:-1:-1;;;;;7603:20:0;;:::o;31271:214::-;31359:51;31377:6;:14;;;31393:6;:16;;;31359:17;:51::i;:::-;31423:11;;:54;;-1:-1:-1;;;31423:54:0;;-1:-1:-1;;;;;31423:11:0;;;;:16;;31447:9;;31423:54;;31458:6;;31466:10;;31423:54;;;:::i;32045:134::-;7699:5;;-1:-1:-1;;;;;7699:5:0;7708:10;7699:19;7691:28;;;;;;32132:11:::1;:39:::0;;-1:-1:-1;;;;;;32132:39:0::1;-1:-1:-1::0;;;;;32132:39:0;;;::::1;::::0;;;::::1;::::0;;32045:134::o;8456:122::-;8537:5;;-1:-1:-1;;;;;8537:5:0;8523:10;:19;8515:28;;;;;;8556:5;:14;;-1:-1:-1;;;;;;8556:14:0;-1:-1:-1;;;;;8556:14:0;;;;;;;;;;8456:122::o;8173:161::-;8254:5;;-1:-1:-1;;;;;8254:5:0;8240:10;:19;8232:28;;;;;;8279:5;;-1:-1:-1;;;;;8279:5:0;:19;8271:28;;;;;7630:20;;;-1:-1:-1;;;;;7630:20:0;;:::o;5647:176::-;5729:86;5749:5;5779:23;;;5804:2;5808:5;5756:58;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;5756:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;5756:58:0;-1:-1:-1;;;;;;5756:58:0;;;;;;;;;;5729:19;:86::i;:::-;5647:176;;;:::o;31713:324::-;-1:-1:-1;;;;;31798:31:0;;31130:42;31798:31;31794:236;;;31867:7;31854:9;:20;;31846:62;;;;-1:-1:-1;;;31846:62:0;;;;;;;:::i;:::-;;;;;;;;;31794:236;;;31996:11;;31941:77;;-1:-1:-1;;;;;31941:34:0;;;;31976:10;;31996:11;32010:7;31941:34;:77::i;7116:419::-;7198:23;7224:69;7252:4;7224:69;;;;;;;;;;;;;;;;;7232:5;-1:-1:-1;;;;;7224:27:0;;;:69;;;;;:::i;:::-;7308:17;;7198:95;;-1:-1:-1;7308:21:0;7304:224;;7450:10;7439:30;;;;;;;;;;;;:::i;:::-;7431:85;;;;-1:-1:-1;;;7431:85:0;;;;;;;:::i;5831:204::-;5931:96;5951:5;5981:27;;;6010:4;6016:2;6020:5;5958:68;;;;;;;;;;:::i;5931:96::-;5831:204;;;;:::o;2036:196::-;2139:12;2171:53;2194:6;2202:4;2208:1;2211:12;2171:22;:53::i;:::-;2164:60;;2036:196;;;;;;:::o;2798:979::-;2928:12;2961:18;2972:6;2961:10;:18::i;:::-;2953:60;;;;-1:-1:-1;;;2953:60:0;;;;;;;:::i;:::-;3087:12;3101:23;3128:6;-1:-1:-1;;;;;3128:11:0;3148:8;3159:4;3128:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3086:78;;;;3179:7;3175:595;;;3210:10;-1:-1:-1;3203:17:0;;-1:-1:-1;3203:17:0;3175:595;3324:17;;:21;3320:439;;3587:10;3581:17;3648:15;3635:10;3631:2;3627:19;3620:44;3535:148;3730:12;3723:20;;-1:-1:-1;;;3723:20:0;;;;;;;;:::i;2798:979::-;;;;;;;:::o;823:619::-;883:4;1351:20;;1194:66;1391:23;;;;;;:42;;-1:-1:-1;;1418:15:0;;;1383:51;-1:-1:-1;;823:619:0:o;5:130:-1:-;72:20;;97:33;72:20;97:33;:::i;:::-;57:78;;;;:::o;431:440::-;;532:3;525:4;517:6;513:17;509:27;499:2;;-1:-1;;540:12;499:2;587:6;574:20;15660:18;15652:6;15649:30;15646:2;;;-1:-1;;15682:12;15646:2;609:64;15755:9;15736:17;;-1:-1;;15732:33;15823:4;15813:15;609:64;:::i;:::-;600:73;;693:6;686:5;679:21;797:3;15823:4;788:6;721;779:16;;776:25;773:2;;;814:1;;804:12;773:2;17173:6;15823:4;721:6;717:17;15823:4;755:5;751:16;17150:30;17229:1;17211:16;;;15823:4;17211:16;17204:27;755:5;492:379;-1:-1;;492:379::o;2868:1179::-;;2987:4;2975:9;2970:3;2966:19;2962:30;2959:2;;;-1:-1;;2995:12;2959:2;3023:20;2987:4;3023:20;:::i;:::-;3014:29;;85:6;72:20;97:33;124:5;97:33;:::i;:::-;3103:75;;3247:2;3301:22;;72:20;97:33;72:20;97:33;:::i;:::-;3247:2;3262:16;;3255:75;3402:2;3456:22;;72:20;97:33;72:20;97:33;:::i;:::-;3435:49;3402:2;3421:5;3417:16;3410:75;;3547:2;3605:9;3601:22;4121:20;3547:2;3566:5;3562:16;3555:75;3698:3;3757:9;3753:22;4121:20;3698:3;3718:5;3714:16;3707:75;3875:3;3864:9;3860:19;3847:33;3900:18;3892:6;3889:30;3886:2;;;-1:-1;;3922:12;3886:2;3967:58;4021:3;4012:6;4001:9;3997:22;3967:58;:::i;:::-;3875:3;3953:5;3949:16;3942:84;;2953:1094;;;;:::o;4191:241::-;;4295:2;4283:9;4274:7;4270:23;4266:32;4263:2;;;-1:-1;;4301:12;4263:2;85:6;72:20;97:33;124:5;97:33;:::i;4703:366::-;;;4824:2;4812:9;4803:7;4799:23;4795:32;4792:2;;;-1:-1;;4830:12;4792:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;4882:63;4982:2;5021:22;;;;4121:20;;-1:-1;;;4786:283::o;5076:257::-;;5188:2;5176:9;5167:7;5163:23;5159:32;5156:2;;;-1:-1;;5194:12;5156:2;376:6;370:13;17972:5;16858:13;16851:21;17950:5;17947:32;17937:2;;-1:-1;;17983:12;5340:387;;5474:2;5462:9;5453:7;5449:23;5445:32;5442:2;;;-1:-1;;5480:12;5442:2;5538:17;5525:31;5576:18;;5568:6;5565:30;5562:2;;;-1:-1;;5598:12;5562:2;5694:6;5683:9;5679:22;;;1040:6;;1028:9;1023:3;1019:19;1015:32;1012:2;;;-1:-1;;1050:12;1012:2;1078:22;1040:6;1078:22;:::i;:::-;1069:31;;1185:49;1230:3;1206:22;1185:49;:::i;:::-;1167:16;1160:75;1333:49;1378:3;5474:2;1358:9;1354:22;1333:49;:::i;:::-;5474:2;1319:5;1315:16;1308:75;1449:2;1507:9;1503:22;4121:20;1449:2;1468:5;1464:16;1457:75;1599:2;1657:9;1653:22;4121:20;1599:2;1618:5;1614:16;1607:75;1747:3;1806:9;1802:22;4121:20;1747:3;1767:5;1763:16;1756:75;1901:3;1960:9;1956:22;4121:20;1901:3;1921:5;1917:16;1910:75;2080:49;2125:3;2046;2105:9;2101:22;2080:49;:::i;:::-;2046:3;2066:5;2062:16;2055:75;2228:49;2273:3;2194;2253:9;2249:22;2228:49;:::i;:::-;2194:3;2214:5;2210:16;2203:75;2374:3;;2363:9;2359:19;2346:33;5576:18;2391:6;2388:30;2385:2;;;-1:-1;;2421:12;2385:2;2468:58;2522:3;2513:6;2502:9;2498:22;2468:58;:::i;:::-;2374:3;2452:5;2448:18;2441:86;;;2624:3;;2613:9;2609:19;2596:33;5576:18;2641:6;2638:30;2635:2;;;-1:-1;;2671:12;2635:2;2718:79;2793:3;2784:6;2773:9;2769:22;2718:79;:::i;:::-;2698:18;;;2691:107;;;;-1:-1;2702:5;5436:291;-1:-1;;;;;5436:291::o;5734:137::-;-1:-1;;;;;16946:54;5821:45;;5815:56::o;6108:323::-;;6240:5;15932:12;16207:6;16202:3;16195:19;6323:52;6368:6;16244:4;16239:3;16235:14;16244:4;6349:5;6345:16;6323:52;:::i;:::-;15755:9;17590:14;-1:-1;;17586:28;6387:39;;;;16244:4;6387:39;;6188:243;-1:-1;;6188:243::o;10374:1219::-;;15660:18;;16957:42;;;;10600:16;10594:23;16946:54;5828:3;5821:45;16957:42;10773:4;10766:5;10762:16;10756:23;16946:54;10773:4;10837:3;10833:14;5821:45;16957:42;10938:4;10931:5;10927:16;10921:23;16946:54;10938:4;11002:3;10998:14;5821:45;;11093:4;11086:5;11082:16;11076:23;11093:4;11157:3;11153:14;11661:37;11254:4;11247:5;11243:16;11237:23;11254:4;11318:3;11314:14;11661:37;11412:4;11405:5;11401:16;11395:23;10525:4;11412;11442:3;11438:14;11431:38;11484:71;10525:4;10520:3;10516:14;11536:12;11484:71;:::i;11830:271::-;;6598:5;15932:12;6709:52;6754:6;6749:3;6742:4;6735:5;6731:16;6709:52;:::i;:::-;6773:16;;;;;11964:137;-1:-1;;11964:137::o;12108:222::-;-1:-1;;;;;16946:54;;;;5821:45;;12235:2;12220:18;;12206:124::o;12337:444::-;-1:-1;;;;;16946:54;;;5821:45;;16946:54;;;;12684:2;12669:18;;5821:45;12767:2;12752:18;;11661:37;;;;12520:2;12505:18;;12491:290::o;12788:333::-;-1:-1;;;;;16946:54;;;;5821:45;;13107:2;13092:18;;11661:37;12943:2;12928:18;;12914:207::o;13128:310::-;;13275:2;13296:17;13289:47;13350:78;13275:2;13264:9;13260:18;13414:6;13350:78;:::i;13445:416::-;13645:2;13659:47;;;7380:2;13630:18;;;16195:19;7416:31;16235:14;;;7396:52;7467:12;;;13616:245::o;13868:416::-;14068:2;14082:47;;;7718:2;14053:18;;;16195:19;7754:31;16235:14;;;7734:52;7805:12;;;14039:245::o;14291:416::-;14491:2;14505:47;;;8056:2;14476:18;;;16195:19;8092:34;16235:14;;;8072:55;-1:-1;;;8147:12;;;8140:34;8193:12;;;14462:245::o;14714:533::-;;14945:2;14966:17;14959:47;8561:63;14945:2;14934:9;14930:18;8538:16;8532:23;8561:63;:::i;:::-;8707:4;8700:5;8696:16;8690:23;8719:63;8767:14;14934:9;8767:14;8753:12;8719:63;:::i;:::-;;14945:2;8859:5;8855:16;8849:23;8926:14;14934:9;8926:14;11661:37;8767:14;9019:5;9015:16;9009:23;9086:14;14934:9;9086:14;11661:37;8926:14;9177:5;9173:16;9167:23;9244:14;14934:9;9244:14;11661:37;9086:14;9340:5;9336:16;9330:23;9407:14;14934:9;9407:14;11661:37;9244:14;9494:5;9490:16;9484:23;9561:14;9513:63;9561:14;14934:9;9561:14;9547:12;9513:63;:::i;:::-;9407:14;9651:5;9647:16;9641:23;9621:43;;9718:14;9670:63;9718:14;14934:9;9718:14;9704:12;9670:63;:::i;:::-;9561:14;9812:5;9808:18;9802:25;9782:45;;8461:6;;;;;14934:9;9847:16;9840:40;9895:71;8452:16;14934:9;8452:16;9947:12;9895:71;:::i;:::-;10048:18;;;10042:25;10105:14;;;-1:-1;;10105:14;10087:16;;;10080:40;9887:79;;-1:-1;10042:25;-1:-1;10135:113;9887:79;10042:25;10135:113;:::i;:::-;15012:126;;;;15149:88;8707:4;15222:9;15218:18;15209:6;15149:88;:::i;15254:256::-;15316:2;15310:9;15342:17;;;15417:18;15402:34;;15438:22;;;15399:62;15396:2;;;15474:1;;15464:12;15396:2;15316;15483:22;15294:216;;-1:-1;15294:216::o;17246:268::-;17311:1;17318:101;17332:6;17329:1;17326:13;17318:101;;;17399:11;;;17393:18;17380:11;;;17373:39;17354:2;17347:10;17318:101;;;17434:6;17431:1;17428:13;17425:2;;;-1:-1;;17311:1;17481:16;;17474:27;17295:219::o;17627:117::-;-1:-1;;;;;16946:54;;17686:35;;17676:2;;17735:1;;17725:12;17676:2;17670:74;:::o

ipfs://0c455f6e8a3c7bd303da34aeb176d3a9438164375afa21ce23f514b5c47d06fe