Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
• library CommonMath
•    - function scaleFactor()
•    - function maxUInt256()
•    - function scale(
•    - function deScale(
•    - function safePower(
•    - function divCeil(uint256 a, uint256 b ...
•    - function getPartialAmount(
•    - function ceilLog10(
• interface IERC20
•    - function balanceOf(
•    - function allowance(
•    - function transfer(
•    - function transferFrom(
•    - function approve(
•    - function totalSupply()
• library ERC20Wrapper
•    - function balanceOf(
•    - function allowance(
•    - function transfer(
•    - function transferFrom(
•    - function approve(
•    - function ensureAllowance(
•    - function checkSuccess(
• interface ICore
•    - function transferProxy()
•    - function vault()
•    - function exchangeIds(
•    - function validSets(address)
•    - function validModules(address)
•    - function validPriceLibraries(
•    - function issue(
•    - function issueTo(
•    - function issueInVault(
•    - function redeem(
•    - function redeemTo(
•    - function redeemInVault(
•    - function redeemAndWithdrawTo(
•    - function batchDeposit(
•    - function batchWithdraw(
•    - function deposit(
•    - function withdraw(
•    - function internalTransfer(
•    - function createSet(
•    - function depositModule(
•    - function withdrawModule(
•    - function batchDepositModule(
•    - function batchWithdrawModule(
•    - function issueModule(
•    - function redeemModule(
•    - function batchIncrementTokenOwnerModu ...
•    - function batchDecrementTokenOwnerModu ...
•    - function batchTransferBalanceModule(
•    - function transferModule(
•    - function batchTransferModule(
• library ExchangeWrapperLibraryV2
• interface IExchangeWrapper
•    - function exchange(
• library LibBytes
•    - function contentAddress(bytes memory ...
•    - function readBytes4(
•    - function readBytes32(
•    - function memCopy(
•    - function slice(bytes memory b, uint25 ...
• library ExchangeWrapperLibrary
•    - function returnLeftoverSendTokens(
•    - function callExchange(
• interface KyberNetworkProxyInterface
•    - function getExpectedRate(
•    - function trade(
•  contract KyberNetworkWrapper *
•    - function conversionRate(
•    - function exchange(
•    - function tradeOnKyberReserve(
•    - function parseKyberTrade(

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-03-29
*/

pragma solidity ^0.5.2;
pragma experimental "ABIEncoderV2";

/**
 * @title SafeMath
 * @dev Unsigned math operations with safety checks that revert on error
 */
library SafeMath {
    /**
     * @dev Multiplies two unsigned integers, reverts on overflow.
     */
    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-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b);

        return c;
    }

    /**
     * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Adds two unsigned integers, reverts on overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a);

        return c;
    }

    /**
     * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
     * reverts when dividing by zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0);
        return a % b;
    }
}

// File: contracts/lib/CommonMath.sol

/*
    Copyright 2018 Set Labs Inc.

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

pragma solidity 0.5.7;



library CommonMath {
    using SafeMath for uint256;

    uint256 public constant SCALE_FACTOR = 10 ** 18;
    uint256 public constant MAX_UINT_256 = 2 ** 256 - 1;

    /**
     * Returns scale factor equal to 10 ** 18
     *
     * @return  10 ** 18
     */
    function scaleFactor()
        internal
        pure
        returns (uint256)
    {
        return SCALE_FACTOR;
    }

    /**
     * Calculates and returns the maximum value for a uint256
     *
     * @return  The maximum value for uint256
     */
    function maxUInt256()
        internal
        pure
        returns (uint256)
    {
        return MAX_UINT_256;
    }

    /**
     * Increases a value by the scale factor to allow for additional precision
     * during mathematical operations
     */
    function scale(
        uint256 a
    )
        internal
        pure
        returns (uint256)
    {
        return a.mul(SCALE_FACTOR);
    }

    /**
     * Divides a value by the scale factor to allow for additional precision
     * during mathematical operations
    */
    function deScale(
        uint256 a
    )
        internal
        pure
        returns (uint256)
    {
        return a.div(SCALE_FACTOR);
    }

    /**
    * @dev Performs the power on a specified value, reverts on overflow.
    */
    function safePower(
        uint256 a,
        uint256 pow
    )
        internal
        pure
        returns (uint256)
    {
        require(a > 0);

        uint256 result = 1;
        for (uint256 i = 0; i < pow; i++){
            uint256 previousResult = result;

            // Using safemath multiplication prevents overflows
            result = previousResult.mul(a);
        }

        return result;
    }

    /**
    * @dev Performs division where if there is a modulo, the value is rounded up
    */
    function divCeil(uint256 a, uint256 b)
        internal
        pure
        returns(uint256)
    {
        return a.mod(b) > 0 ? a.div(b).add(1) : a.div(b);
    }

    /**
     * Checks for rounding errors and returns value of potential partial amounts of a principal
     *
     * @param  _principal       Number fractional amount is derived from
     * @param  _numerator       Numerator of fraction
     * @param  _denominator     Denominator of fraction
     * @return uint256          Fractional amount of principal calculated
     */
    function getPartialAmount(
        uint256 _principal,
        uint256 _numerator,
        uint256 _denominator
    )
        internal
        pure
        returns (uint256)
    {
        // Get remainder of partial amount (if 0 not a partial amount)
        uint256 remainder = mulmod(_principal, _numerator, _denominator);

        // Return if not a partial amount
        if (remainder == 0) {
            return _principal.mul(_numerator).div(_denominator);
        }

        // Calculate error percentage
        uint256 errPercentageTimes1000000 = remainder.mul(1000000).div(_numerator.mul(_principal));

        // Require error percentage is less than 0.1%.
        require(
            errPercentageTimes1000000 < 1000,
            "CommonMath.getPartialAmount: Rounding error exceeds bounds"
        );

        return _principal.mul(_numerator).div(_denominator);
    }

    /*
     * Gets the rounded up log10 of passed value
     *
     * @param  _value         Value to calculate ceil(log()) on
     * @return uint256        Output value
     */
    function ceilLog10(
        uint256 _value
    )
        internal
        pure
        returns (uint256)
    {
        // Make sure passed value is greater than 0
        require (
            _value > 0,
            "CommonMath.ceilLog10: Value must be greater than zero."
        );

        // Since log10(1) = 0, if _value = 1 return 0
        if (_value == 1) return 0;

        // Calcualte ceil(log10())
        uint256 x = _value - 1;

        uint256 result = 0;

        if (x >= 10 ** 64) {
            x /= 10 ** 64;
            result += 64;
        }
        if (x >= 10 ** 32) {
            x /= 10 ** 32;
            result += 32;
        }
        if (x >= 10 ** 16) {
            x /= 10 ** 16;
            result += 16;
        }
        if (x >= 10 ** 8) {
            x /= 10 ** 8;
            result += 8;
        }
        if (x >= 10 ** 4) {
            x /= 10 ** 4;
            result += 4;
        }
        if (x >= 100) {
            x /= 100;
            result += 2;
        }
        if (x >= 10) {
            result += 1;
        }

        return result + 1;
    }
}

// File: contracts/lib/IERC20.sol

/*
    Copyright 2018 Set Labs Inc.

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

pragma solidity 0.5.7;


/**
 * @title IERC20
 * @author Set Protocol
 *
 * Interface for using ERC20 Tokens. This interface is needed to interact with tokens that are not
 * fully ERC20 compliant and return something other than true on successful transfers.
 */
interface IERC20 {
    function balanceOf(
        address _owner
    )
        external
        view
        returns (uint256);

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

    function transfer(
        address _to,
        uint256 _quantity
    )
        external;

    function transferFrom(
        address _from,
        address _to,
        uint256 _quantity
    )
        external;

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

    function totalSupply()
        external
        returns (uint256);
}

// File: contracts/lib/ERC20Wrapper.sol

/*
    Copyright 2018 Set Labs Inc.

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

pragma solidity 0.5.7;




/**
 * @title ERC20Wrapper
 * @author Set Protocol
 *
 * This library contains functions for interacting wtih ERC20 tokens, even those not fully compliant.
 * For all functions we will only accept tokens that return a null or true value, any other values will
 * cause the operation to revert.
 */
library ERC20Wrapper {

    // ============ Internal Functions ============

    /**
     * Check balance owner's balance of ERC20 token
     *
     * @param  _token          The address of the ERC20 token
     * @param  _owner          The owner who's balance is being checked
     * @return  uint256        The _owner's amount of tokens
     */
    function balanceOf(
        address _token,
        address _owner
    )
        external
        view
        returns (uint256)
    {
        return IERC20(_token).balanceOf(_owner);
    }

    /**
     * Checks spender's allowance to use token's on owner's behalf.
     *
     * @param  _token          The address of the ERC20 token
     * @param  _owner          The token owner address
     * @param  _spender        The address the allowance is being checked on
     * @return  uint256        The spender's allowance on behalf of owner
     */
    function allowance(
        address _token,
        address _owner,
        address _spender
    )
        internal
        view
        returns (uint256)
    {
        return IERC20(_token).allowance(_owner, _spender);
    }

    /**
     * Transfers tokens from an address. Handle's tokens that return true or null.
     * If other value returned, reverts.
     *
     * @param  _token          The address of the ERC20 token
     * @param  _to             The address to transfer to
     * @param  _quantity       The amount of tokens to transfer
     */
    function transfer(
        address _token,
        address _to,
        uint256 _quantity
    )
        external
    {
        IERC20(_token).transfer(_to, _quantity);

        // Check that transfer returns true or null
        require(
            checkSuccess(),
            "ERC20Wrapper.transfer: Bad return value"
        );
    }

    /**
     * Transfers tokens from an address (that has set allowance on the proxy).
     * Handle's tokens that return true or null. If other value returned, reverts.
     *
     * @param  _token          The address of the ERC20 token
     * @param  _from           The address to transfer from
     * @param  _to             The address to transfer to
     * @param  _quantity       The number of tokens to transfer
     */
    function transferFrom(
        address _token,
        address _from,
        address _to,
        uint256 _quantity
    )
        external
    {
        IERC20(_token).transferFrom(_from, _to, _quantity);

        // Check that transferFrom returns true or null
        require(
            checkSuccess(),
            "ERC20Wrapper.transferFrom: Bad return value"
        );
    }

    /**
     * Grants spender ability to spend on owner's behalf.
     * Handle's tokens that return true or null. If other value returned, reverts.
     *
     * @param  _token          The address of the ERC20 token
     * @param  _spender        The address to approve for transfer
     * @param  _quantity       The amount of tokens to approve spender for
     */
    function approve(
        address _token,
        address _spender,
        uint256 _quantity
    )
        internal
    {
        IERC20(_token).approve(_spender, _quantity);

        // Check that approve returns true or null
        require(
            checkSuccess(),
            "ERC20Wrapper.approve: Bad return value"
        );
    }

    /**
     * Ensure's the owner has granted enough allowance for system to
     * transfer tokens.
     *
     * @param  _token          The address of the ERC20 token
     * @param  _owner          The address of the token owner
     * @param  _spender        The address to grant/check allowance for
     * @param  _quantity       The amount to see if allowed for
     */
    function ensureAllowance(
        address _token,
        address _owner,
        address _spender,
        uint256 _quantity
    )
        internal
    {
        uint256 currentAllowance = allowance(_token, _owner, _spender);
        if (currentAllowance < _quantity) {
            approve(
                _token,
                _spender,
                CommonMath.maxUInt256()
            );
        }
    }

    // ============ Private Functions ============

    /**
     * Checks the return value of the previous function up to 32 bytes. Returns true if the previous
     * function returned 0 bytes or 1.
     */
    function checkSuccess(
    )
        private
        pure
        returns (bool)
    {
        // default to failure
        uint256 returnValue = 0;

        assembly {
            // check number of bytes returned from last function call
            switch returndatasize

            // no bytes returned: assume success
            case 0x0 {
                returnValue := 1
            }

            // 32 bytes returned
            case 0x20 {
                // copy 32 bytes into scratch space
                returndatacopy(0x0, 0x0, 0x20)

                // load those bytes into returnValue
                returnValue := mload(0x0)
            }

            // not sure what was returned: dont mark as success
            default { }
        }

        // check if returned value is one or nothing
        return returnValue == 1;
    }
}

// File: contracts/core/interfaces/ICore.sol

/*
    Copyright 2018 Set Labs Inc.

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

pragma solidity 0.5.7;


/**
 * @title ICore
 * @author Set Protocol
 *
 * The ICore Contract defines all the functions exposed in the Core through its
 * various extensions and is a light weight way to interact with the contract.
 */
interface ICore {
    /**
     * Return transferProxy address.
     *
     * @return address       transferProxy address
     */
    function transferProxy()
        external
        view
        returns (address);

    /**
     * Return vault address.
     *
     * @return address       vault address
     */
    function vault()
        external
        view
        returns (address);

    /**
     * Return address belonging to given exchangeId.
     *
     * @param  _exchangeId       ExchangeId number
     * @return address           Address belonging to given exchangeId
     */
    function exchangeIds(
        uint8 _exchangeId
    )
        external
        view
        returns (address);

    /*
     * Returns if valid set
     *
     * @return  bool      Returns true if Set created through Core and isn't disabled
     */
    function validSets(address)
        external
        view
        returns (bool);

    /*
     * Returns if valid module
     *
     * @return  bool      Returns true if valid module
     */
    function validModules(address)
        external
        view
        returns (bool);

    /**
     * Return boolean indicating if address is a valid Rebalancing Price Library.
     *
     * @param  _priceLibrary    Price library address
     * @return bool             Boolean indicating if valid Price Library
     */
    function validPriceLibraries(
        address _priceLibrary
    )
        external
        view
        returns (bool);

    /**
     * Exchanges components for Set Tokens
     *
     * @param  _set          Address of set to issue
     * @param  _quantity     Quantity of set to issue
     */
    function issue(
        address _set,
        uint256 _quantity
    )
        external;

    /**
     * Issues a specified Set for a specified quantity to the recipient
     * using the caller's components from the wallet and vault.
     *
     * @param  _recipient    Address to issue to
     * @param  _set          Address of the Set to issue
     * @param  _quantity     Number of tokens to issue
     */
    function issueTo(
        address _recipient,
        address _set,
        uint256 _quantity
    )
        external;

    /**
     * Converts user's components into Set Tokens held directly in Vault instead of user's account
     *
     * @param _set          Address of the Set
     * @param _quantity     Number of tokens to redeem
     */
    function issueInVault(
        address _set,
        uint256 _quantity
    )
        external;

    /**
     * Function to convert Set Tokens into underlying components
     *
     * @param _set          The address of the Set token
     * @param _quantity     The number of tokens to redeem. Should be multiple of natural unit.
     */
    function redeem(
        address _set,
        uint256 _quantity
    )
        external;

    /**
     * Redeem Set token and return components to specified recipient. The components
     * are left in the vault
     *
     * @param _recipient    Recipient of Set being issued
     * @param _set          Address of the Set
     * @param _quantity     Number of tokens to redeem
     */
    function redeemTo(
        address _recipient,
        address _set,
        uint256 _quantity
    )
        external;

    /**
     * Function to convert Set Tokens held in vault into underlying components
     *
     * @param _set          The address of the Set token
     * @param _quantity     The number of tokens to redeem. Should be multiple of natural unit.
     */
    function redeemInVault(
        address _set,
        uint256 _quantity
    )
        external;

    /**
     * Composite method to redeem and withdraw with a single transaction
     *
     * Normally, you should expect to be able to withdraw all of the tokens.
     * However, some have central abilities to freeze transfers (e.g. EOS). _toExclude
     * allows you to optionally specify which component tokens to exclude when
     * redeeming. They will remain in the vault under the users' addresses.
     *
     * @param _set          Address of the Set
     * @param _to           Address to withdraw or attribute tokens to
     * @param _quantity     Number of tokens to redeem
     * @param _toExclude    Mask of indexes of tokens to exclude from withdrawing
     */
    function redeemAndWithdrawTo(
        address _set,
        address _to,
        uint256 _quantity,
        uint256 _toExclude
    )
        external;

    /**
     * Deposit multiple tokens to the vault. Quantities should be in the
     * order of the addresses of the tokens being deposited.
     *
     * @param  _tokens           Array of the addresses of the ERC20 tokens
     * @param  _quantities       Array of the number of tokens to deposit
     */
    function batchDeposit(
        address[] calldata _tokens,
        uint256[] calldata _quantities
    )
        external;

    /**
     * Withdraw multiple tokens from the vault. Quantities should be in the
     * order of the addresses of the tokens being withdrawn.
     *
     * @param  _tokens            Array of the addresses of the ERC20 tokens
     * @param  _quantities        Array of the number of tokens to withdraw
     */
    function batchWithdraw(
        address[] calldata _tokens,
        uint256[] calldata _quantities
    )
        external;

    /**
     * Deposit any quantity of tokens into the vault.
     *
     * @param  _token           The address of the ERC20 token
     * @param  _quantity        The number of tokens to deposit
     */
    function deposit(
        address _token,
        uint256 _quantity
    )
        external;

    /**
     * Withdraw a quantity of tokens from the vault.
     *
     * @param  _token           The address of the ERC20 token
     * @param  _quantity        The number of tokens to withdraw
     */
    function withdraw(
        address _token,
        uint256 _quantity
    )
        external;

    /**
     * Transfer tokens associated with the sender's account in vault to another user's
     * account in vault.
     *
     * @param  _token           Address of token being transferred
     * @param  _to              Address of user receiving tokens
     * @param  _quantity        Amount of tokens being transferred
     */
    function internalTransfer(
        address _token,
        address _to,
        uint256 _quantity
    )
        external;

    /**
     * Deploys a new Set Token and adds it to the valid list of SetTokens
     *
     * @param  _factory              The address of the Factory to create from
     * @param  _components           The address of component tokens
     * @param  _units                The units of each component token
     * @param  _naturalUnit          The minimum unit to be issued or redeemed
     * @param  _name                 The bytes32 encoded name of the new Set
     * @param  _symbol               The bytes32 encoded symbol of the new Set
     * @param  _callData             Byte string containing additional call parameters
     * @return setTokenAddress       The address of the new Set
     */
    function createSet(
        address _factory,
        address[] calldata _components,
        uint256[] calldata _units,
        uint256 _naturalUnit,
        bytes32 _name,
        bytes32 _symbol,
        bytes calldata _callData
    )
        external
        returns (address);

    /**
     * Exposes internal function that deposits a quantity of tokens to the vault and attributes
     * the tokens respectively, to system modules.
     *
     * @param  _from            Address to transfer tokens from
     * @param  _to              Address to credit for deposit
     * @param  _token           Address of token being deposited
     * @param  _quantity        Amount of tokens to deposit
     */
    function depositModule(
        address _from,
        address _to,
        address _token,
        uint256 _quantity
    )
        external;

    /**
     * Exposes internal function that withdraws a quantity of tokens from the vault and
     * deattributes the tokens respectively, to system modules.
     *
     * @param  _from            Address to decredit for withdraw
     * @param  _to              Address to transfer tokens to
     * @param  _token           Address of token being withdrawn
     * @param  _quantity        Amount of tokens to withdraw
     */
    function withdrawModule(
        address _from,
        address _to,
        address _token,
        uint256 _quantity
    )
        external;

    /**
     * Exposes internal function that deposits multiple tokens to the vault, to system
     * modules. Quantities should be in the order of the addresses of the tokens being
     * deposited.
     *
     * @param  _from              Address to transfer tokens from
     * @param  _to                Address to credit for deposits
     * @param  _tokens            Array of the addresses of the tokens being deposited
     * @param  _quantities        Array of the amounts of tokens to deposit
     */
    function batchDepositModule(
        address _from,
        address _to,
        address[] calldata _tokens,
        uint256[] calldata _quantities
    )
        external;

    /**
     * Exposes internal function that withdraws multiple tokens from the vault, to system
     * modules. Quantities should be in the order of the addresses of the tokens being withdrawn.
     *
     * @param  _from              Address to decredit for withdrawals
     * @param  _to                Address to transfer tokens to
     * @param  _tokens            Array of the addresses of the tokens being withdrawn
     * @param  _quantities        Array of the amounts of tokens to withdraw
     */
    function batchWithdrawModule(
        address _from,
        address _to,
        address[] calldata _tokens,
        uint256[] calldata _quantities
    )
        external;

    /**
     * Expose internal function that exchanges components for Set tokens,
     * accepting any owner, to system modules
     *
     * @param  _owner        Address to use tokens from
     * @param  _recipient    Address to issue Set to
     * @param  _set          Address of the Set to issue
     * @param  _quantity     Number of tokens to issue
     */
    function issueModule(
        address _owner,
        address _recipient,
        address _set,
        uint256 _quantity
    )
        external;

    /**
     * Expose internal function that exchanges Set tokens for components,
     * accepting any owner, to system modules
     *
     * @param  _burnAddress         Address to burn token from
     * @param  _incrementAddress    Address to increment component tokens to
     * @param  _set                 Address of the Set to redeem
     * @param  _quantity            Number of tokens to redeem
     */
    function redeemModule(
        address _burnAddress,
        address _incrementAddress,
        address _set,
        uint256 _quantity
    )
        external;

    /**
     * Expose vault function that increments user's balance in the vault.
     * Available to system modules
     *
     * @param  _tokens          The addresses of the ERC20 tokens
     * @param  _owner           The address of the token owner
     * @param  _quantities      The numbers of tokens to attribute to owner
     */
    function batchIncrementTokenOwnerModule(
        address[] calldata _tokens,
        address _owner,
        uint256[] calldata _quantities
    )
        external;

    /**
     * Expose vault function that decrement user's balance in the vault
     * Only available to system modules.
     *
     * @param  _tokens          The addresses of the ERC20 tokens
     * @param  _owner           The address of the token owner
     * @param  _quantities      The numbers of tokens to attribute to owner
     */
    function batchDecrementTokenOwnerModule(
        address[] calldata _tokens,
        address _owner,
        uint256[] calldata _quantities
    )
        external;

    /**
     * Expose vault function that transfer vault balances between users
     * Only available to system modules.
     *
     * @param  _tokens           Addresses of tokens being transferred
     * @param  _from             Address tokens being transferred from
     * @param  _to               Address tokens being transferred to
     * @param  _quantities       Amounts of tokens being transferred
     */
    function batchTransferBalanceModule(
        address[] calldata _tokens,
        address _from,
        address _to,
        uint256[] calldata _quantities
    )
        external;

    /**
     * Transfers token from one address to another using the transfer proxy.
     * Only available to system modules.
     *
     * @param  _token          The address of the ERC20 token
     * @param  _quantity       The number of tokens to transfer
     * @param  _from           The address to transfer from
     * @param  _to             The address to transfer to
     */
    function transferModule(
        address _token,
        uint256 _quantity,
        address _from,
        address _to
    )
        external;

    /**
     * Expose transfer proxy function to transfer tokens from one address to another
     * Only available to system modules.
     *
     * @param  _tokens         The addresses of the ERC20 token
     * @param  _quantities     The numbers of tokens to transfer
     * @param  _from           The address to transfer from
     * @param  _to             The address to transfer to
     */
    function batchTransferModule(
        address[] calldata _tokens,
        uint256[] calldata _quantities,
        address _from,
        address _to
    )
        external;
}

// File: contracts/core/lib/ExchangeWrapperLibraryV2.sol

/*
    Copyright 2018 Set Labs Inc.

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

pragma solidity 0.5.7;



/**
 * @title ExchangeWrapperLibrary
 * @author Set Protocol
 *
 * This library contains structs and functions to assist executing orders on third party exchanges
 *
 * CHANGELOG
 * - Removes functions that result in circular dependencies when trying to flatten.
 * - Functions using this library mainly use it for the structs
 */
library ExchangeWrapperLibraryV2 {

    // ============ Structs ============

    /**
     * caller                           Original user initiating transaction
     * orderCount                       Expected number of orders to execute
     */
    struct ExchangeData {
        address caller;
        uint256 orderCount;
    }

    /**
     * components                       A list of the acquired components from exchange wrapper
     * componentQuantities              A list of the component quantities acquired
     */
    struct ExchangeResults {
        address[] receiveTokens;
        uint256[] receiveTokenAmounts;
    }
}

// File: contracts/core/interfaces/IExchangeWrapper.sol

/*
    Copyright 2018 Set Labs Inc.

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

pragma solidity 0.5.7;



/**
 * @title IExchangeWrapper
 * @author Set Protocol
 *
 * Interface for executing an order with an exchange wrapper
 */
interface IExchangeWrapper {

    /* ============ External Functions ============ */

    /**
     * Exchange some amount of makerToken for takerToken.
     *
     * maker                            Issuance order maker
     * taker                            Issuance order taker
     * makerToken                       Address of maker token used in exchange orders
     * makerAssetAmount                 Amount of issuance order maker token to use on this exchange
     * orderCount                       Expected number of orders to execute
     * fillQuantity                     Quantity of Set to be filled
     * attemptedFillQuantity            Quantity of Set taker attempted to fill
     *
     * @param  _orderData               Arbitrary bytes data for any information to pass to the exchange
     */
    function exchange(
        ExchangeWrapperLibraryV2.ExchangeData calldata _exchangeData,
        bytes calldata _orderData
    )
        external
        returns (ExchangeWrapperLibraryV2.ExchangeResults memory);
}

// File: contracts/external/0x/LibBytes.sol

/*
  Copyright 2018 ZeroEx Intl.
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/

pragma solidity 0.5.7;

library LibBytes {

    using LibBytes for bytes;

    /// @dev Gets the memory address for the contents of a byte array.
    /// @param input Byte array to lookup.
    /// @return memoryAddress Memory address of the contents of the byte array.
    function contentAddress(bytes memory input)
        internal
        pure
        returns (uint256 memoryAddress)
    {
        assembly {
            memoryAddress := add(input, 32)
        }
        return memoryAddress;
    }

    /// @dev Reads an unpadded bytes4 value from a position in a byte array.
    /// @param b Byte array containing a bytes4 value.
    /// @param index Index in byte array of bytes4 value.
    /// @return bytes4 value from byte array.
    function readBytes4(
        bytes memory b,
        uint256 index)
        internal
        pure
        returns (bytes4 result)
    {
        require(
            b.length >= index + 4,
            "GREATER_OR_EQUAL_TO_4_LENGTH_REQUIRED"
        );
        assembly {
            result := mload(add(b, 32))
            // Solidity does not require us to clean the trailing bytes.
            // We do it anyway
            result := and(result, 0xFFFFFFFF00000000000000000000000000000000000000000000000000000000)
        }
        return result;
    }


    /// @dev Reads a bytes32 value from a position in a byte array.
    /// @param b Byte array containing a bytes32 value.
    /// @param index Index in byte array of bytes32 value.
    /// @return bytes32 value from byte array.
    function readBytes32(
        bytes memory b,
        uint256 index
    )
        internal
        pure
        returns (bytes32 result)
    {
        require(
            b.length >= index + 32,
            "GREATER_OR_EQUAL_TO_32_LENGTH_REQUIRED"
        );

        // Arrays are prefixed by a 256 bit length parameter
        index += 32;

        // Read the bytes32 from array memory
        assembly {
            result := mload(add(b, index))
        }
        return result;
    }

    /// @dev Copies `length` bytes from memory location `source` to `dest`.
    /// @param dest memory address to copy bytes to.
    /// @param source memory address to copy bytes from.
    /// @param length number of bytes to copy.
    function memCopy(
        uint256 dest,
        uint256 source,
        uint256 length
    )
        internal
        pure
    {
        if (length < 32) {
            // Handle a partial word by reading destination and masking
            // off the bits we are interested in.
            // This correctly handles overlap, zero lengths and source == dest
            assembly {
                let mask := sub(exp(256, sub(32, length)), 1)
                let s := and(mload(source), not(mask))
                let d := and(mload(dest), mask)
                mstore(dest, or(s, d))
            }
        } else {
            // Skip the O(length) loop when source == dest.
            if (source == dest) {
                return;
            }

            // For large copies we copy whole words at a time. The final
            // word is aligned to the end of the range (instead of after the
            // previous) to handle partial words. So a copy will look like this:
            //
            //  ####
            //      ####
            //          ####
            //            ####
            //
            // We handle overlap in the source and destination range by
            // changing the copying direction. This prevents us from
            // overwriting parts of source that we still need to copy.
            //
            // This correctly handles source == dest
            //
            if (source > dest) {
                assembly {
                    // We subtract 32 from `sEnd` and `dEnd` because it
                    // is easier to compare with in the loop, and these
                    // are also the addresses we need for copying the
                    // last bytes.
                    length := sub(length, 32)
                    let sEnd := add(source, length)
                    let dEnd := add(dest, length)

                    // Remember the last 32 bytes of source
                    // This needs to be done here and not after the loop
                    // because we may have overwritten the last bytes in
                    // source already due to overlap.
                    let last := mload(sEnd)

                    // Copy whole words front to back
                    // Note: the first check is always true,
                    // this could have been a do-while loop.
                    for {} lt(source, sEnd) {} {
                        mstore(dest, mload(source))
                        source := add(source, 32)
                        dest := add(dest, 32)
                    }

                    // Write the last 32 bytes
                    mstore(dEnd, last)
                }
            } else {
                assembly {
                    // We subtract 32 from `sEnd` and `dEnd` because those
                    // are the starting points when copying a word at the end.
                    length := sub(length, 32)
                    let sEnd := add(source, length)
                    let dEnd := add(dest, length)

                    // Remember the first 32 bytes of source
                    // This needs to be done here and not after the loop
                    // because we may have overwritten the first bytes in
                    // source already due to overlap.
                    let first := mload(source)

                    // Copy whole words back to front
                    // We use a signed comparisson here to allow dEnd to become
                    // negative (happens when source and dest < 32). Valid
                    // addresses in local memory will never be larger than
                    // 2**255, so they can be safely re-interpreted as signed.
                    // Note: the first check is always true,
                    // this could have been a do-while loop.
                    for {} slt(dest, dEnd) {} {
                        mstore(dEnd, mload(sEnd))
                        sEnd := sub(sEnd, 32)
                        dEnd := sub(dEnd, 32)
                    }

                    // Write the first 32 bytes
                    mstore(dest, first)
                }
            }
        }
    }

    /// @dev Returns a slices from a byte array.
    /// @param b The byte array to take a slice from.
    /// @param from The starting index for the slice (inclusive).
    /// @param to The final index for the slice (exclusive).
    /// @return result The slice containing bytes at indices [from, to)
    function slice(bytes memory b, uint256 from, uint256 to)
        internal
        pure
        returns (bytes memory result)
    {
        require(
            from <= to,
            "FROM_LESS_THAN_TO_REQUIRED"
        );
        require(
            // NOTE: Set Protocol changed from `to < b.length` so that the last byte can be sliced off
            to <= b.length,
            "TO_LESS_THAN_LENGTH_REQUIRED"
        );

        // Create a new bytes structure and copy contents
        result = new bytes(to - from);
        memCopy(
            result.contentAddress(),
            b.contentAddress() + from,
            result.length);
        return result;
    }
}

// File: contracts/core/lib/ExchangeWrapperLibrary.sol

/*
    Copyright 2018 Set Labs Inc.

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

pragma solidity 0.5.7;









/**
 * @title ExchangeWrapperLibrary
 * @author Set Protocol
 *
 * This library contains structs and functions to assist executing orders on third party exchanges
 */
library ExchangeWrapperLibrary {

    // ============ Structs ============

    /**
     * caller                           Original user initiating transaction
     * orderCount                       Expected number of orders to execute
     */
    struct ExchangeData {
        address caller;
        uint256 orderCount;
    }

    /**
     * receiveTokens                    A list of the acquired components from exchange wrapper
     * receiveTokenAmounts              A list of the component quantities acquired
     */
    struct ExchangeResults {
        address[] receiveTokens;
        uint256[] receiveTokenAmounts;
    }

    /**
     * Checks if any send tokens leftover and transfers to caller
     * @param  _sendTokens    The addresses of send tokens
     * @param  _caller        The address of the original transaction caller
     */
    function returnLeftoverSendTokens(
        address[] memory _sendTokens,
        address _caller
    )
        internal
    {
        for (uint256 i = 0; i < _sendTokens.length; i++) {
            // Transfer any unused or remainder send token back to the caller
            uint256 remainderSendToken = ERC20Wrapper.balanceOf(_sendTokens[i], address(this));
            if (remainderSendToken > 0) {
                ERC20Wrapper.transfer(
                    _sendTokens[i],
                    _caller,
                    remainderSendToken
                );
            }
        }
    }

    /**
     * Calls exchange to execute trades and deposits fills into Vault for issuanceOrder maker.
     *
     *
     * @param  _core                    Address of Core
     * @param  _exchangeData            Standard exchange wrapper interface object containing exchange metadata
     * @param  _exchangeWrapper         Address of exchange wrapper being called
     * @param  _bodyData                Arbitrary bytes data for orders to be executed on exchange
     */
    function callExchange(
        address _core,
        ExchangeWrapperLibraryV2.ExchangeData memory _exchangeData,
        address _exchangeWrapper,
        bytes memory _bodyData
    )
        internal
    {
        // Call Exchange
        ExchangeWrapperLibraryV2.ExchangeResults memory exchangeResults = IExchangeWrapper(_exchangeWrapper).exchange(
            _exchangeData,
            _bodyData
        );

        // Transfer receiveToken tokens from wrapper to vault
        ICore(_core).batchDepositModule(
            _exchangeWrapper,
            _exchangeData.caller,
            exchangeResults.receiveTokens,
            exchangeResults.receiveTokenAmounts
        );
    }
}

// File: contracts/external/KyberNetwork/KyberNetworkProxyInterface.sol

pragma solidity 0.5.7;


/// @title Kyber Network interface
interface KyberNetworkProxyInterface {
    function getExpectedRate(
      address src,
      address dest,
      uint256 srcQty
    )
      external
      view
      returns (uint256 expectedRate, uint256 slippageRate);

    function trade(
      address src,
      uint srcAmount,
      address dest,
      address destAddress,
      uint maxDestAmount,
      uint minConversionRate,
      address walletId
    )
      external
      payable
      returns (uint);
}

// File: contracts/core/exchange-wrappers/KyberNetworkWrapper.sol

/*
    Copyright 2018 Set Labs Inc.

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

pragma solidity 0.5.7;









/**
 * @title KyberNetworkWrapper
 * @author Set Protocol
 *
 * The KyberNetworkWrapper contract wrapper to interface with KyberNetwork for reserve liquidity
 */
contract KyberNetworkWrapper {
    using LibBytes for bytes;
    using SafeMath for uint256;

    /* ============ State Variables ============ */

    address public core;
    address public kyberNetworkProxy;
    address public setTransferProxy;

    uint256 public KYBER_TRADE_LENGTH = 160;

    // ============ Structs ============

    struct KyberTrade {
        address destinationToken;
        address sourceToken;
        uint256 sourceTokenQuantity;
        uint256 minimumConversionRate;
        uint256 maxDestinationQuantity;
    }

    /* ============ Constructor ============ */

    /**
     * Initialize exchange wrapper with required addresses to facilitate Kyber trades
     *
     * @param  _core                 Deployed Core contract
     * @param  _kyberNetworkProxy    KyberNetwork contract for filling orders
     * @param  _setTransferProxy     Set Protocol transfer proxy contract
     */
    constructor(
        address _core,
        address _kyberNetworkProxy,
        address _setTransferProxy
    )
        public
    {
        core = _core;
        kyberNetworkProxy = _kyberNetworkProxy;
        setTransferProxy = _setTransferProxy;
    }

    /* ============ Public Functions ============ */

    /**
     * Returns the conversion rate between the issuance order maker token and the set component token
     * in 18 decimals, regardless of component token's decimals
     *
     * @param  _sourceTokens         Address of source token used in exchange orders
     * @param  _destinationTokens    Address of destination token to trade for
     * @param  _quantities           Amount of maker token to exchange for component token
     * @return uint256[]             Conversion rate in wei
     * @return uint256[]             Slippage in wei
     */
    function conversionRate(
        address[] calldata _sourceTokens,
        address[] calldata _destinationTokens,
        uint256[] calldata _quantities
    )
        external
        view
        returns (uint256[] memory, uint256[] memory)
    {
        uint256 rateCount = _sourceTokens.length;
        uint256[] memory expectedRates = new uint256[](rateCount);
        uint256[] memory slippageRates = new uint256[](rateCount);

        for (uint256 i = 0; i < rateCount; i++) {
            (expectedRates[i], slippageRates[i]) = KyberNetworkProxyInterface(kyberNetworkProxy).getExpectedRate(
                _sourceTokens[i],
                _destinationTokens[i],
                _quantities[i]
            );
        }

        return (
            expectedRates,
            slippageRates
        );
    }

    /**
     * IExchangeWrapper interface delegate method.
     *
     * Parses and executes Kyber trades. Depending on conversion rate, Kyber trades may result in change.
     * We currently pass change back to the issuance order maker, exploring how it can safely be passed to the taker.
     *
     *
     * @param  _exchangeData            Standard exchange wrapper interface object containing exchange metadata
     * @param  _tradesData              Arbitrary bytes data for any information to pass to the exchange
     * @return ExchangeWrapperLibrary.ExchangeResults  Struct containing component acquisition results
     */
    function exchange(
        ExchangeWrapperLibrary.ExchangeData memory _exchangeData,
        bytes memory _tradesData
    )
        public
        returns (ExchangeWrapperLibrary.ExchangeResults memory)
    {
        require(
            ICore(core).validModules(msg.sender),
            "KyberNetworkWrapper.exchange: Sender must be approved module"
        );

        uint256 tradesCount = _exchangeData.orderCount;
        address[] memory sendTokens = new address[](tradesCount);
        address[] memory receiveTokens = new address[](tradesCount);
        uint256[] memory receiveTokensAmounts = new uint256[](tradesCount);

        // Parse and execute the trade at the current offset via the KyberNetworkProxy, each kyber trade is 160 bytes
        for (uint256 i = 0; i < tradesCount; i++) {
            // Parse Kyber trade at the current offset
            KyberTrade memory trade = parseKyberTrade(
                _tradesData,
                i.mul(KYBER_TRADE_LENGTH)
            );

            // Ensure the caller's source token is allowed to be transferred by
            // KyberNetworkProxy as the source token
            ERC20Wrapper.ensureAllowance(
                trade.sourceToken,
                address(this),
                kyberNetworkProxy,
                trade.sourceTokenQuantity
            );

            // Track the send tokens to ensure any leftovers are returned to the user
            sendTokens[i] = trade.sourceToken;

            // Execute Kyber trade
            (receiveTokens[i], receiveTokensAmounts[i]) = tradeOnKyberReserve(trade);
        }

        // Return leftover send tokens to the original caller
        ExchangeWrapperLibrary.returnLeftoverSendTokens(
            sendTokens,
            _exchangeData.caller
        );

        return ExchangeWrapperLibrary.ExchangeResults({
            receiveTokens: receiveTokens,
            receiveTokenAmounts: receiveTokensAmounts
        });
    }

    /* ============ Private ============ */

    /**
     * Parses and executes Kyber trade
     *
     * @return address                  Address of set component to trade for
     * @return uint256                  Amount of set component received in trade
     */
    function tradeOnKyberReserve(
        KyberTrade memory _trade
    )
        private
        returns (address, uint256)
    {
        // Execute Kyber trade via deployed KyberNetworkProxy contract
        uint256 destinationTokenQuantity = KyberNetworkProxyInterface(kyberNetworkProxy).trade(
            _trade.sourceToken,
            _trade.sourceTokenQuantity,
            _trade.destinationToken,
            address(this),
            _trade.maxDestinationQuantity,
            _trade.minimumConversionRate,
            address(0)
        );

        // Ensure the destination token is allowed to be transferred by Set TransferProxy
        ERC20Wrapper.ensureAllowance(
            _trade.destinationToken,
            address(this),
            setTransferProxy,
            destinationTokenQuantity
        );

        return (
            _trade.destinationToken,
            destinationTokenQuantity
        );
    }

    /*
     * Parses the bytes array for a Kyber trade
     *
     * | Data                       | Location                      |
     * |----------------------------|-------------------------------|
     * | destinationToken           | 0                             |
     * | sourceTokenQuantity        | 32                            |
     * | sourceTokenQuantity        | 64                            |
     * | minimumConversionRate      | 96                            |
     * | maxDestinationQuantity     | 128                           |
     *
     * @param  _tradesData    Byte array of (multiple) Kyber trades
     * @param  _offset        Offset to start scanning for Kyber trade body
     * @return KyberTrade     KyberTrade struct
     */
    function parseKyberTrade(
        bytes memory _tradesData,
        uint256 _offset
    )
        private
        pure
        returns (KyberTrade memory)
    {
        KyberTrade memory trade;

        uint256 tradeDataStart = _tradesData.contentAddress().add(_offset);

        assembly {
            mstore(trade,           mload(tradeDataStart))            // destinationToken
            mstore(add(trade, 32),  mload(add(tradeDataStart, 32)))   // sourceToken
            mstore(add(trade, 64),  mload(add(tradeDataStart, 64)))   // sourceTokenQuantity
            mstore(add(trade, 96),  mload(add(tradeDataStart, 96)))   // minimumConversionRate
            mstore(add(trade, 128), mload(add(tradeDataStart, 128)))  // maxDestinationQuantity
        }

        return trade;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"setTransferProxy","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"KYBER_TRADE_LENGTH","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"components":[{"name":"caller","type":"address"},{"name":"orderCount","type":"uint256"}],"name":"_exchangeData","type":"tuple"},{"name":"_tradesData","type":"bytes"}],"name":"exchange","outputs":[{"components":[{"name":"receiveTokens","type":"address[]"},{"name":"receiveTokenAmounts","type":"uint256[]"}],"name":"","type":"tuple"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_sourceTokens","type":"address[]"},{"name":"_destinationTokens","type":"address[]"},{"name":"_quantities","type":"uint256[]"}],"name":"conversionRate","outputs":[{"name":"","type":"uint256[]"},{"name":"","type":"uint256[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"kyberNetworkProxy","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"core","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"_core","type":"address"},{"name":"_kyberNetworkProxy","type":"address"},{"name":"_setTransferProxy","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"}]

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

000000000000000000000000f55186cc537e7067ea616f2aae007b4427a120c8000000000000000000000000818e6fecd516ecc3849daf6845e3ec868087b755000000000000000000000000882d80d3a191859d64477eb78cca46599307ec1c

-----Decoded View---------------
Arg [0] : _core (address): 0xf55186CC537E7067EA616F2aaE007b4427a120C8
Arg [1] : _kyberNetworkProxy (address): 0x818E6FECD516Ecc3849DAf6845e3EC868087B755
Arg [2] : _setTransferProxy (address): 0x882d80D3a191859d64477eb78Cca46599307ec1C

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000f55186cc537e7067ea616f2aae007b4427a120c8
Arg [1] : 000000000000000000000000818e6fecd516ecc3849daf6845e3ec868087b755
Arg [2] : 000000000000000000000000882d80d3a191859d64477eb78cca46599307ec1c

ERC20Wrapper : 0xeadada7c6943c223c0d4bea475a6dacc7368f8d6

47422:8174:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47422:8174:0;;;;;;-1:-1:-1;;;47422:8174:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47644:31;;;:::i;:::-;;;;;;;;;;;;;;;;47684:39;;;:::i;:::-;;;;;;;;50757:2006;;;;;;;;;:::i;:::-;;;;;;;;49268:838;;;;;;;;;:::i;:::-;;;;;;;;;47605:32;;;:::i;47579:19::-;;;:::i;47644:31::-;;;-1:-1:-1;;;;;47644:31:0;;:::o;47684:39::-;;;;:::o;50757:2006::-;50918:45;;:::i;:::-;51009:4;;51003:36;;;;;-1:-1:-1;;;;;51009:4:0;;;;51003:24;;:36;;51028:10;;51003:36;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51003:36:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;51003:36:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;51003:36:0;;;;;;;;;50981:146;;;;;;;;;;;;;;;;;;;;;;51140:19;51162:13;:24;;;51140:46;;51197:27;51241:11;51227:26;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;51227:26:0;;51197:56;;51264:30;51311:11;51297:26;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;51297:26:0;;51264:59;;51334:37;51388:11;51374:26;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;51374:26:0;-1:-1:-1;51334:66:0;-1:-1:-1;51537:9:0;51532:860;51556:11;51552:1;:15;51532:860;;;51645:23;;:::i;:::-;51671:104;51705:11;51735:25;51741:18;;51735:1;:5;;:25;;;;:::i;:::-;51671:15;:104::i;:::-;51974:17;;;;52042;;52078:25;;;;51645:130;;-1:-1:-1;51927:191:0;;52018:4;;-1:-1:-1;;;;;52042:17:0;;51927:28;:191::i;:::-;52238:5;:17;;;52222:10;52233:1;52222:13;;;;;;;;;;;;;:33;-1:-1:-1;;;;;52222:33:0;;;-1:-1:-1;;;;;52222:33:0;;;;;52354:26;52374:5;52354:19;:26::i;:::-;52309:13;52323:1;52309:16;;;;;;;;;;;;;52327:20;52348:1;52327:23;;;;;;;;;;;;;;;;;52308:72;;;;-1:-1:-1;;;;;52308:72:0;;;;;-1:-1:-1;51569:3:0;;51532:860;;;;52467:118;52529:10;52554:13;:20;;;52467:47;:118::i;:::-;52605:150;;;;;;;;;;;;;;;;;-1:-1:-1;;;50757:2006:0;;;;;:::o;49268:838::-;49617:24;;;;;;;;;;;;;;;;49481:16;;;;49553:13;;49481:16;;49553:13;49617:24;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;49617:24:0;;49584:57;;49652:30;49699:9;49685:24;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;49685:24:0;-1:-1:-1;49652:57:0;-1:-1:-1;49727:9:0;49722:290;49746:9;49742:1;:13;49722:290;;;49843:17;;-1:-1:-1;;;;;49843:17:0;49816:61;49896:13;;49910:1;49896:16;;;;;;;;;;;;;-1:-1:-1;;;;;49896:16:0;49931:18;;49950:1;49931:21;;;;;;;;;;;;;-1:-1:-1;;;;;49931:21:0;49971:11;;49983:1;49971:14;;;;;;;;;;;;;49816:184;;;;;-1:-1:-1;;;49816:184:0;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49816:184:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49816:184:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;49816:184:0;;;;;;;;;49778:13;49792:1;49778:16;;;;;;;;;;;;;49796:13;49810:1;49796:16;;;;;;;;;;;;;;;;;49777:223;;;;;49757:3;;49722:290;;;-1:-1:-1;50046:13:0;;;;-1:-1:-1;49268:838:0;-1:-1:-1;;;;;;;;49268:838:0:o;47605:32::-;;;-1:-1:-1;;;;;47605:32:0;;:::o;47579:19::-;;;-1:-1:-1;;;;;47579:19:0;;:::o;278:433::-;336:7;580:6;576:47;;-1:-1:-1;610:1:0;603:8;;576:47;647:5;;;651:1;647;:5;:1;671:5;;;;;:10;663:19;;;;;;702:1;278:433;-1:-1:-1;;;278:433:0:o;54784:809::-;54926:17;;:::i;:::-;54961:23;;:::i;:::-;54997:22;55022:41;55055:7;55022:28;:11;:26;:28::i;:::-;:32;:41;:32;:41;:::i;:::-;55124:21;;55100:46;;55241:2;55221:23;;;55215:30;55198:14;;;55191:55;55327:2;55307:23;;;55301:30;55284:14;;;55277:55;55421:2;55401:23;;;55395:30;55378:14;;;55371:55;55517:3;55497:24;;;55491:31;55474:15;;;55467:56;-1:-1:-1;55107:5:0;54784:809;-1:-1:-1;;;54784:809:0:o;13849:428::-;14020:24;14047:35;14057:6;14065;14073:8;14047:9;:35::i;:::-;14020:62;;14116:9;14097:16;:28;14093:177;;;14142:116;14168:6;14193:8;14220:23;:21;:23::i;:::-;14142:7;:116::i;:::-;13849:428;;;;;:::o;53046:956::-;53320:17;;53359:18;;;;53392:26;;;;;53433:23;;53499:29;;;;53543:28;;;;53293:314;;;;;53152:7;;;;;;-1:-1:-1;;;;;53320:17:0;;;;53293:51;;:314;;53359:18;;53392:26;;53433:23;;53479:4;;53499:29;;53543:28;53152:7;;53293:314;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53293:314:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;53293:314:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;53293:314:0;;;;;;;;;53754:23;;53820:16;;53258:349;;-1:-1:-1;53711:175:0;;53800:4;;-1:-1:-1;;;;;53820:16:0;53258:349;53711:28;:175::i;:::-;53921:23;;;53046:956;-1:-1:-1;;53046:956:0:o;44084:609::-;44229:9;44224:462;44248:11;:18;44244:1;:22;44224:462;;;44367:26;44396:12;:22;44419:11;44431:1;44419:14;;;;;;;;;;;;;;44443:4;44396:53;;;;;-1:-1:-1;;;44396:53:0;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;44396:53:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;44396:53:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;44396:53:0;;;;;;;;;44367:82;-1:-1:-1;44468:22:0;;44464:211;;44511:12;:21;44555:11;44567:1;44555:14;;;;;;;;;;;;;;44592:7;44622:18;44511:148;;;;;-1:-1:-1;;;44511:148:0;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;44511:148:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;44511:148:0;;;;44464:211;-1:-1:-1;44268:3:0;;44224:462;;;;44084:609;;:::o;34974:237::-;35159:2;35148:14;;34974:237::o;1525:150::-;1583:7;1615:5;;;1639:6;;;;1631:15;;;;;10941:235;11126:42;;;;;11094:7;;-1:-1:-1;;;;;11126:24:0;;;;;:42;;11151:6;;11159:8;;11126:42;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;11126:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;11126:42:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;11126:42:0;;;;;;;;;11119:49;10941:235;-1:-1:-1;;;;10941:235:0:o;3194:124::-;-1:-1:-1;;3194:124:0;:::o;13100:356::-;13238:43;;;;;-1:-1:-1;;;;;13238:22:0;;;;;:43;;13261:8;;13271:9;;13238:43;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;13238:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;13238:43:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;13238:43:0;;;;;;;;;;13368:14;:12;:14::i;:::-;13346:102;;;;;;;;;;;;;14499:885;14578:4;;14769:14;14849:59;;;;14963:4;14958:226;;;;14762:514;;14849:59;14892:1;14877:16;;14849:59;;14958:226;15065:4;15060:3;15055;15040:30;15165:3;15159:10;15144:25;;14762:514;-1:-1:-1;15375:1:0;15360:16;;-1:-1:-1;14499:885:0;:::o;47422:8174::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;-1:-1:-1;;;;;47422:8174:0;;;;;;-1:-1:-1;;;;;47422:8174:0;;;;;;;;;;;;;;;;;;;;:::o;5:118:-1:-;;72:46;110:6;97:20;72:46;;148:352;;;278:3;271:4;263:6;259:17;255:27;245:2;;296:1;293;286:12;245:2;-1:-1;316:20;;356:18;345:30;;342:2;;;388:1;385;378:12;342:2;422:4;414:6;410:17;398:29;;473:3;465:4;457:6;453:17;443:8;439:32;436:41;433:2;;;490:1;487;480:12;433:2;238:262;;;;;;886:116;;961:36;989:6;983:13;961:36;;1010:440;;1111:3;1104:4;1096:6;1092:17;1088:27;1078:2;;1129:1;1126;1119:12;1078:2;1166:6;1153:20;1188:64;1203:48;1244:6;1203:48;;;1188:64;;;1179:73;;1272:6;1265:5;1258:21;1308:4;1300:6;1296:17;1341:4;1334:5;1330:16;1376:3;1367:6;1362:3;1358:16;1355:25;1352:2;;;1393:1;1390;1383:12;1352:2;1403:41;1437:6;1432:3;1427;1403:41;;;1071:379;;;;;;;;1507:479;;1626:4;1614:9;1609:3;1605:19;1601:30;1598:2;;;1644:1;1641;1634:12;1598:2;1662:20;1677:4;1662:20;;;1653:29;-1:-1;1734:1;1765:49;1810:3;1790:9;1765:49;;;1741:74;;-1:-1;1882:2;1915:49;1960:3;1936:22;;;1915:49;;;1908:4;1901:5;1897:16;1890:75;1836:140;1592:394;;;;;1993:118;;2060:46;2098:6;2085:20;2060:46;;2118:122;;2196:39;2227:6;2221:13;2196:39;;2247:959;;;;;;;2490:2;2478:9;2469:7;2465:23;2461:32;2458:2;;;2506:1;2503;2496:12;2458:2;2541:31;;2592:18;2581:30;;2578:2;;;2624:1;2621;2614:12;2578:2;2652:80;2724:7;2715:6;2704:9;2700:22;2652:80;;;2642:90;;;;2520:218;2797:2;2786:9;2782:18;2769:32;2821:18;2813:6;2810:30;2807:2;;;2853:1;2850;2843:12;2807:2;2881:80;2953:7;2944:6;2933:9;2929:22;2881:80;;;2871:90;;;;2748:219;3026:2;3015:9;3011:18;2998:32;3050:18;3042:6;3039:30;3036:2;;;3082:1;3079;3072:12;3036:2;3110:80;3182:7;3173:6;3162:9;3158:22;3110:80;;;3100:90;;;;2977:219;2452:754;;;;;;;;;3213:257;;3325:2;3313:9;3304:7;3300:23;3296:32;3293:2;;;3341:1;3338;3331:12;3293:2;3376:1;3393:61;3446:7;3426:9;3393:61;;3477:530;;;3637:2;3625:9;3616:7;3612:23;3608:32;3605:2;;;3653:1;3650;3643:12;3605:2;3688:1;3705:83;3780:7;3760:9;3705:83;;;3695:93;;3667:127;3853:2;3842:9;3838:18;3825:32;3877:18;3869:6;3866:30;3863:2;;;3909:1;3906;3899:12;3863:2;3929:62;3983:7;3974:6;3963:9;3959:22;3929:62;;;3919:72;;3804:193;3599:408;;;;;;4014:263;;4129:2;4117:9;4108:7;4104:23;4100:32;4097:2;;;4145:1;4142;4135:12;4097:2;4180:1;4197:64;4253:7;4233:9;4197:64;;4284:399;;;4416:2;4404:9;4395:7;4391:23;4387:32;4384:2;;;4432:1;4429;4422:12;4384:2;4467:1;4484:64;4540:7;4520:9;4484:64;;;4474:74;;4446:108;4585:2;4603:64;4659:7;4650:6;4639:9;4635:22;4603:64;;4691:173;;4778:46;4820:3;4812:6;4778:46;;;-1:-1;;4853:4;4844:14;;4771:93;4873:173;;4960:46;5002:3;4994:6;4960:46;;5054:142;5145:45;5184:5;5145:45;;;5140:3;5133:58;5127:69;;;5203:110;5276:31;5301:5;5276:31;;5613:585;;5744:50;5788:5;5744:50;;;5807:76;5876:6;5871:3;5807:76;;;5800:83;;5903:52;5949:5;5903:52;;;5976:1;5961:215;5986:6;5983:1;5980:13;5961:215;;;6033:63;6092:3;6083:6;6077:13;6033:63;;;6026:70;;6113:56;6162:6;6113:56;;;6103:66;-1:-1;6008:1;6001:9;5961:215;;;-1:-1;6189:3;;5723:475;-1:-1;;;;5723:475;6237:621;;6382:54;6430:5;6382:54;;;6449:86;6528:6;6523:3;6449:86;;;6442:93;;6555:56;6605:5;6555:56;;;6632:1;6617:219;6642:6;6639:1;6636:13;6617:219;;;6689:63;6748:3;6739:6;6733:13;6689:63;;;6682:70;;6769:60;6822:6;6769:60;;;6759:70;-1:-1;6664:1;6657:9;6617:219;;6897:585;;7028:50;7072:5;7028:50;;;7091:76;7160:6;7155:3;7091:76;;;7084:83;;7187:52;7233:5;7187:52;;;7260:1;7245:215;7270:6;7267:1;7264:13;7245:215;;;7317:63;7376:3;7367:6;7361:13;7317:63;;;7310:70;;7397:56;7446:6;7397:56;;;7387:66;-1:-1;7292:1;7285:9;7245:215;;7491:465;;7651:67;7715:2;7710:3;7651:67;;;7751:66;7731:87;;7852:66;7847:2;7838:12;;7831:88;7947:2;7938:12;;7637:319;-1:-1;;7637:319;7965:465;;8125:67;8189:2;8184:3;8125:67;;;8225:66;8205:87;;8326:66;8321:2;8312:12;;8305:88;8421:2;8412:12;;8111:319;-1:-1;;8111:319;8539:733;8780:22;;8706:4;8815:37;;;8539:733;;8697:14;;;;8867:98;8697:14;8780:22;8867:98;;;8859:106;;8726:251;9064:4;9057:5;9053:16;9047:23;9116:3;9110:4;9106:14;9099:4;9094:3;9090:14;9083:38;9136:98;9229:4;9216:11;9136:98;;;9128:106;8679:593;-1:-1;;;;;8679:593;9279:110;9352:31;9377:5;9352:31;;9658:213;9776:2;9761:18;;9790:71;9765:9;9834:6;9790:71;;9878:229;10004:2;9989:18;;10018:79;9993:9;10070:6;10018:79;;10114:324;10260:2;10245:18;;10274:71;10249:9;10318:6;10274:71;;;10356:72;10424:2;10413:9;10409:18;10400:6;10356:72;;10800:435;10974:2;10959:18;;10988:71;10963:9;11032:6;10988:71;;;11070:72;11138:2;11127:9;11123:18;11114:6;11070:72;;;11153;11221:2;11210:9;11206:18;11197:6;11153:72;;11716:324;11862:2;11847:18;;11876:71;11851:9;11920:6;11876:71;;;11958:72;12026:2;12015:9;12011:18;12002:6;11958:72;;12047:899;12341:3;12326:19;;12356:71;12330:9;12400:6;12356:71;;;12438:72;12506:2;12495:9;12491:18;12482:6;12438:72;;;12521;12589:2;12578:9;12574:18;12565:6;12521:72;;;12604;12672:2;12661:9;12657:18;12648:6;12604:72;;;12687:73;12755:3;12744:9;12740:19;12731:6;12687:73;;;12771;12839:3;12828:9;12824:19;12815:6;12771:73;;;12855:81;12931:3;12920:9;12916:19;12907:6;12855:81;;;12312:634;;;;;;;;;;;12953:620;13199:2;13213:47;;;13184:18;;13274:108;13184:18;13368:6;13274:108;;;13266:116;;13430:9;13424:4;13420:20;13415:2;13404:9;13400:18;13393:48;13455:108;13558:4;13549:6;13455:108;;13580:407;13771:2;13785:47;;;13756:18;;13846:131;13756:18;13846:131;;13994:407;14185:2;14199:47;;;14170:18;;14260:131;14170:18;14260:131;;14408:393;14592:2;14606:47;;;14577:18;;14667:124;14577:18;14777:6;14667:124;;14808:213;14926:2;14911:18;;14940:71;14915:9;14984:6;14940:71;;15028:256;15090:2;15084:9;15116:17;;;15191:18;15176:34;;15212:22;;;15173:62;15170:2;;;15248:1;15245;15238:12;15170:2;15264;15257:22;15068:216;;-1:-1;15068:216;15291:258;;15434:18;15426:6;15423:30;15420:2;;;15466:1;15463;15456:12;15420:2;-1:-1;15539:4;15510;15487:17;;;;-1:-1;;15483:33;15529:15;;15357:192;15944:103;16030:12;;16014:33;16664:168;16772:19;;;16821:4;16812:14;;16765:67;17376:105;;-1:-1;;;;;17557:54;;17445:31;17540:76;17623:79;17692:5;17675:27;17821:92;17894:13;17887:21;;17870:43;18141:129;;18228:37;18259:5;18277:121;18356:37;18387:5;18356:37;;18528:145;18609:6;18604:3;18599;18586:30;-1:-1;18665:1;18647:16;;18640:27;18579:94

bzzr://8fa4f01347140fa926f242ab5218106fa1ee43322b1c219521dc12c97e1976bc