Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;
pragma experimental ABIEncoderV2;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";

import "./MinimalProxyFactory.sol";
import "./IGraphTokenLockManager.sol";

/**
 * @title GraphTokenLockManager
 * @notice This contract manages a list of authorized function calls and targets that can be called
 * by any TokenLockWallet contract and it is a factory of TokenLockWallet contracts.
 *
 * This contract receives funds to make the process of creating TokenLockWallet contracts
 * easier by distributing them the initial tokens to be managed.
 *
 * The owner can setup a list of token destinations that will be used by TokenLock contracts to
 * approve the pulling of funds, this way in can be guaranteed that only protocol contracts
 * will manipulate users funds.
 */
contract GraphTokenLockManager is MinimalProxyFactory, IGraphTokenLockManager {
    using SafeERC20 for IERC20;
    using EnumerableSet for EnumerableSet.AddressSet;

    // -- State --

    mapping(bytes4 => address) public authFnCalls;
    EnumerableSet.AddressSet private _tokenDestinations;

    address public masterCopy;
    IERC20 private _token;

    // -- Events --

    event MasterCopyUpdated(address indexed masterCopy);
    event TokenLockCreated(
        address indexed contractAddress,
        bytes32 indexed initHash,
        address indexed beneficiary,
        address token,
        uint256 managedAmount,
        uint256 startTime,
        uint256 endTime,
        uint256 periods,
        uint256 releaseStartTime,
        uint256 vestingCliffTime,
        IGraphTokenLock.Revocability revocable
    );

    event TokensDeposited(address indexed sender, uint256 amount);
    event TokensWithdrawn(address indexed sender, uint256 amount);

    event FunctionCallAuth(address indexed caller, bytes4 indexed sigHash, address indexed target, string signature);
    event TokenDestinationAllowed(address indexed dst, bool allowed);

    /**
     * Constructor.
     * @param _graphToken Token to use for deposits and withdrawals
     * @param _masterCopy Address of the master copy to use to clone proxies
     */
    constructor(IERC20 _graphToken, address _masterCopy) {
        require(address(_graphToken) != address(0), "Token cannot be zero");
        _token = _graphToken;
        setMasterCopy(_masterCopy);
    }

    // -- Factory --

    /**
     * @notice Sets the masterCopy bytecode to use to create clones of TokenLock contracts
     * @param _masterCopy Address of contract bytecode to factory clone
     */
    function setMasterCopy(address _masterCopy) public override onlyOwner {
        require(_masterCopy != address(0), "MasterCopy cannot be zero");
        masterCopy = _masterCopy;
        emit MasterCopyUpdated(_masterCopy);
    }

    /**
     * @notice Creates and fund a new token lock wallet using a minimum proxy
     * @param _owner Address of the contract owner
     * @param _beneficiary Address of the beneficiary of locked tokens
     * @param _managedAmount Amount of tokens to be managed by the lock contract
     * @param _startTime Start time of the release schedule
     * @param _endTime End time of the release schedule
     * @param _periods Number of periods between start time and end time
     * @param _releaseStartTime Override time for when the releases start
     * @param _revocable Whether the contract is revocable
     */
    function createTokenLockWallet(
        address _owner,
        address _beneficiary,
        uint256 _managedAmount,
        uint256 _startTime,
        uint256 _endTime,
        uint256 _periods,
        uint256 _releaseStartTime,
        uint256 _vestingCliffTime,
        IGraphTokenLock.Revocability _revocable
    ) external override onlyOwner {
        require(_token.balanceOf(address(this)) >= _managedAmount, "Not enough tokens to create lock");

        // Create contract using a minimal proxy and call initializer
        bytes memory initializer = abi.encodeWithSignature(
            "initialize(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint8)",
            address(this),
            _owner,
            _beneficiary,
            address(_token),
            _managedAmount,
            _startTime,
            _endTime,
            _periods,
            _releaseStartTime,
            _vestingCliffTime,
            _revocable
        );
        address contractAddress = _deployProxy2(keccak256(initializer), masterCopy, initializer);

        // Send managed amount to the created contract
        _token.safeTransfer(contractAddress, _managedAmount);

        emit TokenLockCreated(
            contractAddress,
            keccak256(initializer),
            _beneficiary,
            address(_token),
            _managedAmount,
            _startTime,
            _endTime,
            _periods,
            _releaseStartTime,
            _vestingCliffTime,
            _revocable
        );
    }

    // -- Funds Management --

    /**
     * @notice Gets the GRT token address
     * @return Token used for transfers and approvals
     */
    function token() external view override returns (IERC20) {
        return _token;
    }

    /**
     * @notice Deposits tokens into the contract
     * @dev Even if the ERC20 token can be transferred directly to the contract
     * this function provide a safe interface to do the transfer and avoid mistakes
     * @param _amount Amount to deposit
     */
    function deposit(uint256 _amount) external override {
        require(_amount > 0, "Amount cannot be zero");
        _token.safeTransferFrom(msg.sender, address(this), _amount);
        emit TokensDeposited(msg.sender, _amount);
    }

    /**
     * @notice Withdraws tokens from the contract
     * @dev Escape hatch in case of mistakes or to recover remaining funds
     * @param _amount Amount of tokens to withdraw
     */
    function withdraw(uint256 _amount) external override onlyOwner {
        require(_amount > 0, "Amount cannot be zero");
        _token.safeTransfer(msg.sender, _amount);
        emit TokensWithdrawn(msg.sender, _amount);
    }

    // -- Token Destinations --

    /**
     * @notice Adds an address that can be allowed by a token lock to pull funds
     * @param _dst Destination address
     */
    function addTokenDestination(address _dst) external override onlyOwner {
        require(_dst != address(0), "Destination cannot be zero");
        require(_tokenDestinations.add(_dst), "Destination already added");
        emit TokenDestinationAllowed(_dst, true);
    }

    /**
     * @notice Removes an address that can be allowed by a token lock to pull funds
     * @param _dst Destination address
     */
    function removeTokenDestination(address _dst) external override onlyOwner {
        require(_tokenDestinations.remove(_dst), "Destination already removed");
        emit TokenDestinationAllowed(_dst, false);
    }

    /**
     * @notice Returns True if the address is authorized to be a destination of tokens
     * @param _dst Destination address
     * @return True if authorized
     */
    function isTokenDestination(address _dst) external view override returns (bool) {
        return _tokenDestinations.contains(_dst);
    }

    /**
     * @notice Returns an array of authorized destination addresses
     * @return Array of addresses authorized to pull funds from a token lock
     */
    function getTokenDestinations() external view override returns (address[] memory) {
        address[] memory dstList = new address[](_tokenDestinations.length());
        for (uint256 i = 0; i < _tokenDestinations.length(); i++) {
            dstList[i] = _tokenDestinations.at(i);
        }
        return dstList;
    }

    // -- Function Call Authorization --

    /**
     * @notice Sets an authorized function call to target
     * @dev Input expected is the function signature as 'transfer(address,uint256)'
     * @param _signature Function signature
     * @param _target Address of the destination contract to call
     */
    function setAuthFunctionCall(string calldata _signature, address _target) external override onlyOwner {
        _setAuthFunctionCall(_signature, _target);
    }

    /**
     * @notice Unsets an authorized function call to target
     * @dev Input expected is the function signature as 'transfer(address,uint256)'
     * @param _signature Function signature
     */
    function unsetAuthFunctionCall(string calldata _signature) external override onlyOwner {
        bytes4 sigHash = _toFunctionSigHash(_signature);
        authFnCalls[sigHash] = address(0);

        emit FunctionCallAuth(msg.sender, sigHash, address(0), _signature);
    }

    /**
     * @notice Sets an authorized function call to target in bulk
     * @dev Input expected is the function signature as 'transfer(address,uint256)'
     * @param _signatures Function signatures
     * @param _targets Address of the destination contract to call
     */
    function setAuthFunctionCallMany(string[] calldata _signatures, address[] calldata _targets)
        external
        override
        onlyOwner
    {
        require(_signatures.length == _targets.length, "Array length mismatch");

        for (uint256 i = 0; i < _signatures.length; i++) {
            _setAuthFunctionCall(_signatures[i], _targets[i]);
        }
    }

    /**
     * @notice Sets an authorized function call to target
     * @dev Input expected is the function signature as 'transfer(address,uint256)'
     * @dev Function signatures of Graph Protocol contracts to be used are known ahead of time
     * @param _signature Function signature
     * @param _target Address of the destination contract to call
     */
    function _setAuthFunctionCall(string calldata _signature, address _target) internal {
        require(_target != address(this), "Target must be other contract");
        require(Address.isContract(_target), "Target must be a contract");

        bytes4 sigHash = _toFunctionSigHash(_signature);
        authFnCalls[sigHash] = _target;

        emit FunctionCallAuth(msg.sender, sigHash, _target, _signature);
    }

    /**
     * @notice Gets the target contract to call for a particular function signature
     * @param _sigHash Function signature hash
     * @return Address of the target contract where to send the call
     */
    function getAuthFunctionCallTarget(bytes4 _sigHash) public view override returns (address) {
        return authFnCalls[_sigHash];
    }

    /**
     * @notice Returns true if the function call is authorized
     * @param _sigHash Function signature hash
     * @return True if authorized
     */
    function isAuthFunctionCall(bytes4 _sigHash) external view override returns (bool) {
        return getAuthFunctionCallTarget(_sigHash) != address(0);
    }

    /**
     * @dev Converts a function signature string to 4-bytes hash
     * @param _signature Function signature string
     * @return Function signature hash
     */
    function _toFunctionSigHash(string calldata _signature) internal pure returns (bytes4) {
        return _convertToBytes4(abi.encodeWithSignature(_signature));
    }

    /**
     * @dev Converts function signature bytes to function signature hash (bytes4)
     * @param _signature Function signature
     * @return Function signature in bytes4
     */
    function _convertToBytes4(bytes memory _signature) internal pure returns (bytes4) {
        require(_signature.length == 4, "Invalid method signature");
        bytes4 sigHash;
        // solium-disable-next-line security/no-inline-assembly
        assembly {
            sigHash := mload(add(_signature, 32))
        }
        return sigHash;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

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

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

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

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

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

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

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

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    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");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    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");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    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");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        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);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;

        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint256(_at(set._inner, index)));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;

import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Create2.sol";

// Adapted from https://github.com/OpenZeppelin/openzeppelin-sdk/blob/v2.5.0/packages/lib/contracts/upgradeability/ProxyFactory.sol
// Based on https://eips.ethereum.org/EIPS/eip-1167
contract MinimalProxyFactory is Ownable {
    // -- Events --

    event ProxyCreated(address indexed proxy);

    /**
     * @notice Gets the deterministic CREATE2 address for MinimalProxy with a particular implementation
     * @param _salt Bytes32 salt to use for CREATE2
     * @param _implementation Address of the proxy target implementation
     * @return Address of the counterfactual MinimalProxy
     */
    function getDeploymentAddress(bytes32 _salt, address _implementation) external view returns (address) {
        return Create2.computeAddress(_salt, keccak256(_getContractCreationCode(_implementation)), address(this));
    }

    /**
     * @notice Deploys a MinimalProxy with CREATE2
     * @param _salt Bytes32 salt to use for CREATE2
     * @param _implementation Address of the proxy target implementation
     * @param _data Bytes with the initializer call
     * @return Address of the deployed MinimalProxy
     */
    function _deployProxy2(
        bytes32 _salt,
        address _implementation,
        bytes memory _data
    ) internal returns (address) {
        address proxyAddress = Create2.deploy(0, _salt, _getContractCreationCode(_implementation));

        emit ProxyCreated(proxyAddress);

        // Call function with data
        if (_data.length > 0) {
            Address.functionCall(proxyAddress, _data);
        }

        return proxyAddress;
    }

    /**
     * @notice Gets the MinimalProxy bytecode
     * @param _implementation Address of the proxy target implementation
     * @return MinimalProxy bytecode
     */
    function _getContractCreationCode(address _implementation) internal pure returns (bytes memory) {
        bytes10 creation = 0x3d602d80600a3d3981f3;
        bytes10 prefix = 0x363d3d373d3d3d363d73;
        bytes20 targetBytes = bytes20(_implementation);
        bytes15 suffix = 0x5af43d82803e903d91602b57fd5bf3;
        return abi.encodePacked(creation, prefix, targetBytes, suffix);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;
pragma experimental ABIEncoderV2;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import "./IGraphTokenLock.sol";

interface IGraphTokenLockManager {
    // -- Factory --

    function setMasterCopy(address _masterCopy) external;

    function createTokenLockWallet(
        address _owner,
        address _beneficiary,
        uint256 _managedAmount,
        uint256 _startTime,
        uint256 _endTime,
        uint256 _periods,
        uint256 _releaseStartTime,
        uint256 _vestingCliffTime,
        IGraphTokenLock.Revocability _revocable
    ) external;

    // -- Funds Management --

    function token() external returns (IERC20);

    function deposit(uint256 _amount) external;

    function withdraw(uint256 _amount) external;

    // -- Allowed Funds Destinations --

    function addTokenDestination(address _dst) external;

    function removeTokenDestination(address _dst) external;

    function isTokenDestination(address _dst) external view returns (bool);

    function getTokenDestinations() external view returns (address[] memory);

    // -- Function Call Authorization --

    function setAuthFunctionCall(string calldata _signature, address _target) external;

    function unsetAuthFunctionCall(string calldata _signature) external;

    function setAuthFunctionCallMany(string[] calldata _signatures, address[] calldata _targets) external;

    function getAuthFunctionCallTarget(bytes4 _sigHash) external view returns (address);

    function isAuthFunctionCall(bytes4 _sigHash) external view returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot 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-contracts/pull/522
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be 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;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "../GSN/Context.sol";
/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.
 * `CREATE2` can be used to compute in advance the address where a smart
 * contract will be deployed, which allows for interesting new mechanisms known
 * as 'counterfactual interactions'.
 *
 * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more
 * information.
 */
library Create2 {
    /**
     * @dev Deploys a contract using `CREATE2`. The address where the contract
     * will be deployed can be known in advance via {computeAddress}.
     *
     * The bytecode for a contract can be obtained from Solidity with
     * `type(contractName).creationCode`.
     *
     * Requirements:
     *
     * - `bytecode` must not be empty.
     * - `salt` must have not been used for `bytecode` already.
     * - the factory must have a balance of at least `amount`.
     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.
     */
    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address) {
        address addr;
        require(address(this).balance >= amount, "Create2: insufficient balance");
        require(bytecode.length != 0, "Create2: bytecode length is zero");
        // solhint-disable-next-line no-inline-assembly
        assembly {
            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
        }
        require(addr != address(0), "Create2: Failed on deploy");
        return addr;
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the
     * `bytecodeHash` or `salt` will result in a new destination address.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {
        return computeAddress(salt, bytecodeHash, address(this));
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at
     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address) {
        bytes32 _data = keccak256(
            abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash)
        );
        return address(uint256(_data));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.3;
pragma experimental ABIEncoderV2;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IGraphTokenLock {
    enum Revocability { NotSet, Enabled, Disabled }

    // -- Balances --

    function currentBalance() external view returns (uint256);

    // -- Time & Periods --

    function currentTime() external view returns (uint256);

    function duration() external view returns (uint256);

    function sinceStartTime() external view returns (uint256);

    function amountPerPeriod() external view returns (uint256);

    function periodDuration() external view returns (uint256);

    function currentPeriod() external view returns (uint256);

    function passedPeriods() external view returns (uint256);

    // -- Locking & Release Schedule --

    function availableAmount() external view returns (uint256);

    function vestedAmount() external view returns (uint256);

    function releasableAmount() external view returns (uint256);

    function totalOutstandingAmount() external view returns (uint256);

    function surplusAmount() external view returns (uint256);

    // -- Value Transfer --

    function release() external;

    function withdrawSurplus(uint256 _amount) external;

    function revoke() external;
}

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_graphToken","type":"address"},{"internalType":"address","name":"_masterCopy","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"bytes4","name":"sigHash","type":"bytes4"},{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"string","name":"signature","type":"string"}],"name":"FunctionCallAuth","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"masterCopy","type":"address"}],"name":"MasterCopyUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"proxy","type":"address"}],"name":"ProxyCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"dst","type":"address"},{"indexed":false,"internalType":"bool","name":"allowed","type":"bool"}],"name":"TokenDestinationAllowed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"contractAddress","type":"address"},{"indexed":true,"internalType":"bytes32","name":"initHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"managedAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"startTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"endTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"periods","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"releaseStartTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"vestingCliffTime","type":"uint256"},{"indexed":false,"internalType":"enum IGraphTokenLock.Revocability","name":"revocable","type":"uint8"}],"name":"TokenLockCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensDeposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensWithdrawn","type":"event"},{"inputs":[{"internalType":"address","name":"_dst","type":"address"}],"name":"addTokenDestination","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"name":"authFnCalls","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_beneficiary","type":"address"},{"internalType":"uint256","name":"_managedAmount","type":"uint256"},{"internalType":"uint256","name":"_startTime","type":"uint256"},{"internalType":"uint256","name":"_endTime","type":"uint256"},{"internalType":"uint256","name":"_periods","type":"uint256"},{"internalType":"uint256","name":"_releaseStartTime","type":"uint256"},{"internalType":"uint256","name":"_vestingCliffTime","type":"uint256"},{"internalType":"enum IGraphTokenLock.Revocability","name":"_revocable","type":"uint8"}],"name":"createTokenLockWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"_sigHash","type":"bytes4"}],"name":"getAuthFunctionCallTarget","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_salt","type":"bytes32"},{"internalType":"address","name":"_implementation","type":"address"}],"name":"getDeploymentAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokenDestinations","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"_sigHash","type":"bytes4"}],"name":"isAuthFunctionCall","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_dst","type":"address"}],"name":"isTokenDestination","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"masterCopy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_dst","type":"address"}],"name":"removeTokenDestination","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_signature","type":"string"},{"internalType":"address","name":"_target","type":"address"}],"name":"setAuthFunctionCall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string[]","name":"_signatures","type":"string[]"},{"internalType":"address[]","name":"_targets","type":"address[]"}],"name":"setAuthFunctionCallMany","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_masterCopy","type":"address"}],"name":"setMasterCopy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_signature","type":"string"}],"name":"unsetAuthFunctionCall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561001057600080fd5b506004361061012c5760003560e01c80639c05fc60116100ad578063c1ab13db11610071578063c1ab13db14610319578063cf497e6c14610335578063f1d24c4514610351578063f2fde38b14610381578063fc0c546a1461039d5761012c565b80639c05fc6014610275578063a345746614610291578063a619486e146102af578063b6b55f25146102cd578063bdb62fbe146102e95761012c565b806368d30c2e116100f457806368d30c2e146101d15780636e03b8dc146101ed578063715018a61461021d57806379ee1bdf146102275780638da5cb5b146102575761012c565b806303990a6c146101315780630602ba2b1461014d5780632e1a7d4d1461017d578063463013a2146101995780635975e00c146101b5575b600080fd5b61014b60048036038101906101469190612638565b6103bb565b005b6101676004803603810190610162919061260f565b61057c565b6040516101749190613127565b60405180910390f35b610197600480360381019061019291906126d5565b6105bd565b005b6101b360048036038101906101ae919061267d565b610733565b005b6101cf60048036038101906101ca9190612446565b6107d8565b005b6101eb60048036038101906101e6919061246f565b610982565b005b6102076004803603810190610202919061260f565b610cfb565b6040516102149190612f61565b60405180910390f35b610225610d2e565b005b610241600480360381019061023c9190612446565b610e81565b60405161024e9190613127565b60405180910390f35b61025f610e9e565b60405161026c9190612f61565b60405180910390f35b61028f600480360381019061028a9190612535565b610ec7565b005b61029961100d565b6040516102a69190613105565b60405180910390f35b6102b76110e5565b6040516102c49190612f61565b60405180910390f35b6102e760048036038101906102e291906126d5565b61110b565b005b61030360048036038101906102fe91906125d3565b6111ee565b6040516103109190612f61565b60405180910390f35b610333600480360381019061032e9190612446565b611212565b005b61034f600480360381019061034a9190612446565b61134c565b005b61036b6004803603810190610366919061260f565b6114d8565b6040516103789190612f61565b60405180910390f35b61039b60048036038101906103969190612446565b611553565b005b6103a5611715565b6040516103b29190613142565b60405180910390f35b6103c361173f565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610450576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161044790613323565b60405180910390fd5b600061045c8383611747565b9050600060016000837bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600073ffffffffffffffffffffffffffffffffffffffff16817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19163373ffffffffffffffffffffffffffffffffffffffff167f450397a2db0e89eccfe664cc6cdfd274a88bc00d29aaec4d991754a42f19f8c9868660405161056f92919061315d565b60405180910390a4505050565b60008073ffffffffffffffffffffffffffffffffffffffff1661059e836114d8565b73ffffffffffffffffffffffffffffffffffffffff1614159050919050565b6105c561173f565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610652576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161064990613323565b60405180910390fd5b60008111610695576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161068c90613303565b60405180910390fd5b6106e23382600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166117d59092919063ffffffff16565b3373ffffffffffffffffffffffffffffffffffffffff167f6352c5382c4a4578e712449ca65e83cdb392d045dfcf1cad9615189db2da244b826040516107289190613403565b60405180910390a250565b61073b61173f565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146107c8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107bf90613323565b60405180910390fd5b6107d383838361185b565b505050565b6107e061173f565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161461086d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161086490613323565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156108dd576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108d490613203565b60405180910390fd5b6108f1816002611a3d90919063ffffffff16565b610930576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161092790613363565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff167f33442b8c13e72dd75a027f08f9bff4eed2dfd26e43cdea857365f5163b359a7960016040516109779190613127565b60405180910390a250565b61098a61173f565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610a17576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a0e90613323565b60405180910390fd5b86600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610a739190612f61565b60206040518083038186803b158015610a8b57600080fd5b505afa158015610a9f573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ac391906126fe565b1015610b04576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610afb90613243565b60405180910390fd5b6060308a8a600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff168b8b8b8b8b8b8b604051602401610b4d9b9a99989796959493929190612f7c565b6040516020818303038152906040527fbd896dcb000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505090506000610c028280519060200120600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1684611a6d565b9050610c51818a600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166117d59092919063ffffffff16565b8973ffffffffffffffffffffffffffffffffffffffff1682805190602001208273ffffffffffffffffffffffffffffffffffffffff167f3c7ff6acee351ed98200c285a04745858a107e16da2f13c3a81a43073c17d644600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff168d8d8d8d8d8d8d604051610ce6989796959493929190613087565b60405180910390a45050505050505050505050565b60016020528060005260406000206000915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610d3661173f565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610dc3576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610dba90613323565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a360008060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550565b6000610e97826002611ae990919063ffffffff16565b9050919050565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b610ecf61173f565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610f5c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f5390613323565b60405180910390fd5b818190508484905014610fa4576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f9b906131e3565b60405180910390fd5b60005b8484905081101561100657610ff9858583818110610fc157fe5b9050602002810190610fd3919061341e565b858585818110610fdf57fe5b9050602002016020810190610ff49190612446565b61185b565b8080600101915050610fa7565b5050505050565b60608061101a6002611b19565b67ffffffffffffffff8111801561103057600080fd5b5060405190808252806020026020018201604052801561105f5781602001602082028036833780820191505090505b50905060005b61106f6002611b19565b8110156110dd5761108a816002611b2e90919063ffffffff16565b82828151811061109657fe5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff16815250508080600101915050611065565b508091505090565b600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000811161114e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161114590613303565b60405180910390fd5b61119d333083600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16611b48909392919063ffffffff16565b3373ffffffffffffffffffffffffffffffffffffffff167f59062170a285eb80e8c6b8ced60428442a51910635005233fc4ce084a475845e826040516111e39190613403565b60405180910390a250565b600061120a836111fd84611bd1565b8051906020012030611c47565b905092915050565b61121a61173f565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146112a7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161129e90613323565b60405180910390fd5b6112bb816002611c8b90919063ffffffff16565b6112fa576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112f190613283565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff167f33442b8c13e72dd75a027f08f9bff4eed2dfd26e43cdea857365f5163b359a7960006040516113419190613127565b60405180910390a250565b61135461173f565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146113e1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113d890613323565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415611451576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611448906132a3565b60405180910390fd5b80600460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff167f30909084afc859121ffc3a5aef7fe37c540a9a1ef60bd4d8dcdb76376fadf9de60405160405180910390a250565b600060016000837bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b61155b61173f565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146115e8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115df90613323565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415611658576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161164f90613223565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a3806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b6000600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b600033905090565b60006117cd83836040516024016040516020818303038152906040529190604051611773929190612f48565b60405180910390207bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611cbb565b905092915050565b6118568363a9059cbb60e01b84846040516024016117f492919061305e565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611d13565b505050565b3073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156118ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016118c1906132c3565b60405180910390fd5b6118d381611dda565b611912576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611909906133e3565b60405180910390fd5b600061191e8484611747565b90508160016000837bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff16817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19163373ffffffffffffffffffffffffffffffffffffffff167f450397a2db0e89eccfe664cc6cdfd274a88bc00d29aaec4d991754a42f19f8c98787604051611a2f92919061315d565b60405180910390a450505050565b6000611a65836000018373ffffffffffffffffffffffffffffffffffffffff1660001b611ded565b905092915050565b600080611a84600086611a7f87611bd1565b611e5d565b90508073ffffffffffffffffffffffffffffffffffffffff167efffc2da0b561cae30d9826d37709e9421c4725faebc226cbbb7ef5fc5e734960405160405180910390a2600083511115611ade57611adc8184611f6e565b505b809150509392505050565b6000611b11836000018373ffffffffffffffffffffffffffffffffffffffff1660001b611fb8565b905092915050565b6000611b2782600001611fdb565b9050919050565b6000611b3d8360000183611fec565b60001c905092915050565b611bcb846323b872dd60e01b858585604051602401611b6993929190613027565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611d13565b50505050565b60606000693d602d80600a3d3981f360b01b9050600069363d3d373d3d3d363d7360b01b905060008460601b905060006e5af43d82803e903d91602b57fd5bf360881b905083838383604051602001611c2d9493929190612e95565b604051602081830303815290604052945050505050919050565b60008060ff60f81b838686604051602001611c659493929190612ee3565b6040516020818303038152906040528051906020012090508060001c9150509392505050565b6000611cb3836000018373ffffffffffffffffffffffffffffffffffffffff1660001b612059565b905092915050565b60006004825114611d01576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611cf890613343565b60405180910390fd5b60006020830151905080915050919050565b6060611d75826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166121419092919063ffffffff16565b9050600081511115611dd55780806020019051810190611d9591906125aa565b611dd4576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611dcb906133a3565b60405180910390fd5b5b505050565b600080823b905060008111915050919050565b6000611df98383611fb8565b611e52578260000182908060018154018082558091505060019003906000526020600020016000909190919091505582600001805490508360010160008481526020019081526020016000208190555060019050611e57565b600090505b92915050565b60008084471015611ea3576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e9a906133c3565b60405180910390fd5b600083511415611ee8576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611edf906131c3565b60405180910390fd5b8383516020850187f59050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415611f63576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f5a906132e3565b60405180910390fd5b809150509392505050565b6060611fb083836040518060400160405280601e81526020017f416464726573733a206c6f772d6c6576656c2063616c6c206661696c65640000815250612141565b905092915050565b600080836001016000848152602001908152602001600020541415905092915050565b600081600001805490509050919050565b600081836000018054905011612037576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161202e906131a3565b60405180910390fd5b82600001828154811061204657fe5b9060005260206000200154905092915050565b6000808360010160008481526020019081526020016000205490506000811461213557600060018203905060006001866000018054905003905060008660000182815481106120a457fe5b90600052602060002001549050808760000184815481106120c157fe5b90600052602060002001819055506001830187600101600083815260200190815260200160002081905550866000018054806120f957fe5b6001900381819060005260206000200160009055905586600101600087815260200190815260200160002060009055600194505050505061213b565b60009150505b92915050565b60606121508484600085612159565b90509392505050565b60608247101561219e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161219590613263565b60405180910390fd5b6121a785611dda565b6121e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016121dd90613383565b60405180910390fd5b600060608673ffffffffffffffffffffffffffffffffffffffff1685876040516122109190612f31565b60006040518083038185875af1925050503d806000811461224d576040519150601f19603f3d011682016040523d82523d6000602084013e612252565b606091505b509150915061226282828661226e565b92505050949350505050565b6060831561227e578290506122ce565b6000835111156122915782518084602001fd5b816040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016122c59190613181565b60405180910390fd5b9392505050565b6000813590506122e48161372e565b92915050565b60008083601f8401126122fc57600080fd5b8235905067ffffffffffffffff81111561231557600080fd5b60208301915083602082028301111561232d57600080fd5b9250929050565b60008083601f84011261234657600080fd5b8235905067ffffffffffffffff81111561235f57600080fd5b60208301915083602082028301111561237757600080fd5b9250929050565b60008151905061238d81613745565b92915050565b6000813590506123a28161375c565b92915050565b6000813590506123b781613773565b92915050565b6000813590506123cc8161378a565b92915050565b60008083601f8401126123e457600080fd5b8235905067ffffffffffffffff8111156123fd57600080fd5b60208301915083600182028301111561241557600080fd5b9250929050565b60008135905061242b8161379a565b92915050565b6000815190506124408161379a565b92915050565b60006020828403121561245857600080fd5b6000612466848285016122d5565b91505092915050565b60008060008060008060008060006101208a8c03121561248e57600080fd5b600061249c8c828d016122d5565b99505060206124ad8c828d016122d5565b98505060406124be8c828d0161241c565b97505060606124cf8c828d0161241c565b96505060806124e08c828d0161241c565b95505060a06124f18c828d0161241c565b94505060c06125028c828d0161241c565b93505060e06125138c828d0161241c565b9250506101006125258c828d016123bd565b9150509295985092959850929598565b6000806000806040858703121561254b57600080fd5b600085013567ffffffffffffffff81111561256557600080fd5b61257187828801612334565b9450945050602085013567ffffffffffffffff81111561259057600080fd5b61259c878288016122ea565b925092505092959194509250565b6000602082840312156125bc57600080fd5b60006125ca8482850161237e565b91505092915050565b600080604083850312156125e657600080fd5b60006125f485828601612393565b9250506020612605858286016122d5565b9150509250929050565b60006020828403121561262157600080fd5b600061262f848285016123a8565b91505092915050565b6000806020838503121561264b57600080fd5b600083013567ffffffffffffffff81111561266557600080fd5b612671858286016123d2565b92509250509250929050565b60008060006040848603121561269257600080fd5b600084013567ffffffffffffffff8111156126ac57600080fd5b6126b8868287016123d2565b935093505060206126cb868287016122d5565b9150509250925092565b6000602082840312156126e757600080fd5b60006126f58482850161241c565b91505092915050565b60006020828403121561271057600080fd5b600061271e84828501612431565b91505092915050565b6000612733838361273f565b60208301905092915050565b612748816134eb565b82525050565b612757816134eb565b82525050565b61276e612769826134eb565b6136a4565b82525050565b600061277f82613485565b61278981856134b3565b935061279483613475565b8060005b838110156127c55781516127ac8882612727565b97506127b7836134a6565b925050600181019050612798565b5085935050505092915050565b6127db816134fd565b82525050565b6127f26127ed82613535565b6136c0565b82525050565b61280961280482613561565b6136ca565b82525050565b61282061281b82613509565b6136b6565b82525050565b6128376128328261358d565b6136d4565b82525050565b61284e612849826135b9565b6136de565b82525050565b600061285f82613490565b61286981856134c4565b9350612879818560208601613671565b80840191505092915050565b61288e8161362c565b82525050565b61289d81613650565b82525050565b60006128af83856134cf565b93506128bc838584613662565b6128c5836136fc565b840190509392505050565b60006128dc83856134e0565b93506128e9838584613662565b82840190509392505050565b60006129008261349b565b61290a81856134cf565b935061291a818560208601613671565b612923816136fc565b840191505092915050565b600061293b6022836134cf565b91507f456e756d657261626c655365743a20696e646578206f7574206f6620626f756e60008301527f64730000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b60006129a16020836134cf565b91507f437265617465323a2062797465636f6465206c656e677468206973207a65726f6000830152602082019050919050565b60006129e16015836134cf565b91507f4172726179206c656e677468206d69736d6174636800000000000000000000006000830152602082019050919050565b6000612a21601a836134cf565b91507f44657374696e6174696f6e2063616e6e6f74206265207a65726f0000000000006000830152602082019050919050565b6000612a616026836134cf565b91507f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008301527f64647265737300000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000612ac76020836134cf565b91507f4e6f7420656e6f75676820746f6b656e7320746f20637265617465206c6f636b6000830152602082019050919050565b6000612b076026836134cf565b91507f416464726573733a20696e73756666696369656e742062616c616e636520666f60008301527f722063616c6c00000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000612b6d601b836134cf565b91507f44657374696e6174696f6e20616c72656164792072656d6f76656400000000006000830152602082019050919050565b6000612bad6019836134cf565b91507f4d6173746572436f70792063616e6e6f74206265207a65726f000000000000006000830152602082019050919050565b6000612bed601d836134cf565b91507f546172676574206d757374206265206f7468657220636f6e74726163740000006000830152602082019050919050565b6000612c2d6019836134cf565b91507f437265617465323a204661696c6564206f6e206465706c6f79000000000000006000830152602082019050919050565b6000612c6d6015836134cf565b91507f416d6f756e742063616e6e6f74206265207a65726f00000000000000000000006000830152602082019050919050565b6000612cad6020836134cf565b91507f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726000830152602082019050919050565b6000612ced6018836134cf565b91507f496e76616c6964206d6574686f64207369676e617475726500000000000000006000830152602082019050919050565b6000612d2d6019836134cf565b91507f44657374696e6174696f6e20616c7265616479206164646564000000000000006000830152602082019050919050565b6000612d6d601d836134cf565b91507f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006000830152602082019050919050565b6000612dad602a836134cf565b91507f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008301527f6f742073756363656564000000000000000000000000000000000000000000006020830152604082019050919050565b6000612e13601d836134cf565b91507f437265617465323a20696e73756666696369656e742062616c616e63650000006000830152602082019050919050565b6000612e536019836134cf565b91507f546172676574206d757374206265206120636f6e7472616374000000000000006000830152602082019050919050565b612e8f81613622565b82525050565b6000612ea182876127e1565b600a82019150612eb182866127e1565b600a82019150612ec18285612826565b601482019150612ed182846127f8565b600f8201915081905095945050505050565b6000612eef828761280f565b600182019150612eff828661275d565b601482019150612f0f828561283d565b602082019150612f1f828461283d565b60208201915081905095945050505050565b6000612f3d8284612854565b915081905092915050565b6000612f558284866128d0565b91508190509392505050565b6000602082019050612f76600083018461274e565b92915050565b600061016082019050612f92600083018e61274e565b612f9f602083018d61274e565b612fac604083018c61274e565b612fb9606083018b61274e565b612fc6608083018a612e86565b612fd360a0830189612e86565b612fe060c0830188612e86565b612fed60e0830187612e86565b612ffb610100830186612e86565b613009610120830185612e86565b613017610140830184612894565b9c9b505050505050505050505050565b600060608201905061303c600083018661274e565b613049602083018561274e565b6130566040830184612e86565b949350505050565b6000604082019050613073600083018561274e565b6130806020830184612e86565b9392505050565b60006101008201905061309d600083018b61274e565b6130aa602083018a612e86565b6130b76040830189612e86565b6130c46060830188612e86565b6130d16080830187612e86565b6130de60a0830186612e86565b6130eb60c0830185612e86565b6130f860e0830184612894565b9998505050505050505050565b6000602082019050818103600083015261311f8184612774565b905092915050565b600060208201905061313c60008301846127d2565b92915050565b60006020820190506131576000830184612885565b92915050565b600060208201905081810360008301526131788184866128a3565b90509392505050565b6000602082019050818103600083015261319b81846128f5565b905092915050565b600060208201905081810360008301526131bc8161292e565b9050919050565b600060208201905081810360008301526131dc81612994565b9050919050565b600060208201905081810360008301526131fc816129d4565b9050919050565b6000602082019050818103600083015261321c81612a14565b9050919050565b6000602082019050818103600083015261323c81612a54565b9050919050565b6000602082019050818103600083015261325c81612aba565b9050919050565b6000602082019050818103600083015261327c81612afa565b9050919050565b6000602082019050818103600083015261329c81612b60565b9050919050565b600060208201905081810360008301526132bc81612ba0565b9050919050565b600060208201905081810360008301526132dc81612be0565b9050919050565b600060208201905081810360008301526132fc81612c20565b9050919050565b6000602082019050818103600083015261331c81612c60565b9050919050565b6000602082019050818103600083015261333c81612ca0565b9050919050565b6000602082019050818103600083015261335c81612ce0565b9050919050565b6000602082019050818103600083015261337c81612d20565b9050919050565b6000602082019050818103600083015261339c81612d60565b9050919050565b600060208201905081810360008301526133bc81612da0565b9050919050565b600060208201905081810360008301526133dc81612e06565b9050919050565b600060208201905081810360008301526133fc81612e46565b9050919050565b60006020820190506134186000830184612e86565b92915050565b6000808335600160200384360303811261343757600080fd5b80840192508235915067ffffffffffffffff82111561345557600080fd5b60208301925060018202360383131561346d57600080fd5b509250929050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b600081905092915050565b60006134f682613602565b9050919050565b60008115159050919050565b60007fff0000000000000000000000000000000000000000000000000000000000000082169050919050565b60007fffffffffffffffffffff0000000000000000000000000000000000000000000082169050919050565b60007fffffffffffffffffffffffffffffff000000000000000000000000000000000082169050919050565b60007fffffffffffffffffffffffffffffffffffffffff00000000000000000000000082169050919050565b6000819050919050565b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b60008190506135fd8261371a565b919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b60006136378261363e565b9050919050565b600061364982613602565b9050919050565b600061365b826135ef565b9050919050565b82818337600083830152505050565b60005b8381101561368f578082015181840152602081019050613674565b8381111561369e576000848401525b50505050565b60006136af826136e8565b9050919050565b6000819050919050565b6000819050919050565b6000819050919050565b6000819050919050565b6000819050919050565b60006136f38261370d565b9050919050565bfe5b6000601f19601f8301169050919050565b60008160601b9050919050565b6003811061372b5761372a6136fa565b5b50565b613737816134eb565b811461374257600080fd5b50565b61374e816134fd565b811461375957600080fd5b50565b613765816135b9565b811461377057600080fd5b50565b61377c816135c3565b811461378757600080fd5b50565b6003811061379757600080fd5b50565b6137a381613622565b81146137ae57600080fd5b5056fea2646970667358221220ce8e84f89eb556f2f74739a29d42b007afeaac5ac92a1454d6c07fa4523a0a9564736f6c63430007030033

000000000000000000000000c944e90c64b2c07662a292be6244bdf05cda44a7000000000000000000000000be5e630383b5baecf0db7b15c50d410edd5a2255

-----Decoded View---------------
Arg [0] : _graphToken (address): 0xc944E90C64B2c07662A292be6244BDf05Cda44a7
Arg [1] : _masterCopy (address): 0xbE5e630383b5BAEcF0Db7b15C50d410edD5A2255

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000c944e90c64b2c07662a292be6244bdf05cda44a7
Arg [1] : 000000000000000000000000be5e630383b5baecf0db7b15c50d410edd5a2255