Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at polygonscan.com on 2021-10-11
*/

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

/**

  Source code of Opium Protocol
  Web https://opium.network
  Telegram https://t.me/opium_network
  Twitter https://twitter.com/opium_network

 */

// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.5.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
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);
}

// File: openzeppelin-solidity/contracts/math/SafeMath.sol

pragma solidity ^0.5.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.
     *
     * _Available since v2.4.0._
     */
    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.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        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.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: openzeppelin-solidity/contracts/utils/Address.sol

pragma solidity ^0.5.5;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * This test is non-exhaustive, and there may be false-negatives: during the
     * execution of a contract's constructor, its address will be reported as
     * not containing 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.
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != 0x0 && codehash != accountHash);
    }

    /**
     * @dev Converts an `address` into `address payable`. Note that this is
     * simply a type cast: the actual underlying value is not changed.
     *
     * _Available since v2.4.0._
     */
    function toPayable(address account) internal pure returns (address payable) {
        return address(uint160(account));
    }

    /**
     * @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].
     *
     * _Available since v2.4.0._
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-call-value
        (bool success, ) = recipient.call.value(amount)("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }
}

// File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol

pragma solidity ^0.5.0;




/**
 * @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 ERC20;` 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));
    }

    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.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "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");
        }
    }
}

// File: erc721o/contracts/Interfaces/IERC721O.sol

pragma solidity ^0.5.4;

contract IERC721O {
  function name() external view returns (string memory);
  function symbol() external view returns (string memory);

  function implementsERC721O() public pure returns (bool);
  function ownerOf(uint256 _tokenId) public view returns (address _owner);
  function balanceOf(address owner) public view returns (uint256);
  function balanceOf(address owner, uint256 tokenId) public view returns (uint256);
  function tokensOwned(address owner) public view returns (uint256[] memory, uint256[] memory);

  function transfer(address to, uint256 tokenId, uint256 quantity) public;
  function transferFrom(address from, address to, uint256 tokenId, uint256 quantity) public;

  // Fungible Safe Transfer From
  function safeTransferFrom(address from, address to, uint256 tokenId, uint256 _amount) public;
  function safeTransferFrom(address from, address to, uint256 tokenId, uint256 _amount, bytes memory data) public;

  // Batch Safe Transfer From
  function safeBatchTransferFrom(address _from, address _to, uint256[] memory tokenIds, uint256[] memory _amounts, bytes memory _data) public;

  // Required Events
  event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
  event TransferWithQuantity(address indexed from, address indexed to, uint256 indexed tokenId, uint256 quantity);
  event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
  event BatchTransfer(address indexed from, address indexed to, uint256[] tokenTypes, uint256[] amounts);
  event Composition(uint256 portfolioId, uint256[] tokenIds, uint256[] tokenRatio);
}

// File: contracts/Lib/Whitelisted.sol

pragma solidity 0.5.16;

/// @title Opium.Lib.Whitelisted contract implements whitelist with modifier to restrict access to only whitelisted addresses
contract Whitelisted {
    // Whitelist array
    address[] internal whitelist;

    /// @notice This modifier restricts access to functions, which could be called only by whitelisted addresses
    modifier onlyWhitelisted() {
        // Allowance flag
        bool allowed = false;

        // Going through whitelisted addresses array
        uint256 whitelistLength = whitelist.length;
        for (uint256 i = 0; i < whitelistLength; i++) {
            // If `msg.sender` is met within whitelisted addresses, raise the flag and exit the loop
            if (whitelist[i] == msg.sender) {
                allowed = true;
                break;
            }
        }

        // Check if flag was raised
        require(allowed, "Only whitelisted allowed");
        _;
    }

    /// @notice Getter for whitelisted addresses array
    /// @return Array of whitelisted addresses
    function getWhitelist() public view returns (address[] memory) {
        return whitelist;
    }
}

// File: contracts/Lib/WhitelistedWithGovernance.sol

pragma solidity 0.5.16;


/// @title Opium.Lib.WhitelistedWithGovernance contract implements Opium.Lib.Whitelisted and adds governance for whitelist controlling
contract WhitelistedWithGovernance is Whitelisted {
    // Emitted when new governor is set
    event GovernorSet(address governor);

    // Emitted when new whitelist is proposed
    event Proposed(address[] whitelist);
    // Emitted when proposed whitelist is committed (set)
    event Committed(address[] whitelist);

    // Proposal life timelock interval
    uint256 public timeLockInterval;

    // Governor address
    address public governor;

    // Timestamp of last proposal
    uint256 public proposalTime;

    // Proposed whitelist
    address[] public proposedWhitelist;

    /// @notice This modifier restricts access to functions, which could be called only by governor
    modifier onlyGovernor() {
        require(msg.sender == governor, "Only governor allowed");
        _;
    }

    /// @notice Contract constructor
    /// @param _timeLockInterval uint256 Initial value for timelock interval
    /// @param _governor address Initial value for governor
    constructor(uint256 _timeLockInterval, address _governor) public {
        timeLockInterval = _timeLockInterval;
        governor = _governor;
        emit GovernorSet(governor);
    }

    /// @notice Calling this function governor could propose new whitelist addresses array. Also it allows to initialize first whitelist if it was not initialized yet.
    function proposeWhitelist(address[] memory _whitelist) public onlyGovernor {
        // Restrict empty proposals
        require(_whitelist.length != 0, "Can't be empty");

        // Consider empty whitelist as not initialized, as proposing of empty whitelists is not allowed
        // If whitelist has never been initialized, we set whitelist right away without proposal
        if (whitelist.length == 0) {
            whitelist = _whitelist;
            emit Committed(_whitelist);

        // Otherwise save current time as timestamp of proposal, save proposed whitelist and emit event
        } else {
            proposalTime = now;
            proposedWhitelist = _whitelist;
            emit Proposed(_whitelist);
        }
    }

    /// @notice Calling this function governor commits proposed whitelist if timelock interval of proposal was passed
    function commitWhitelist() public onlyGovernor {
        // Check if proposal was made
        require(proposalTime != 0, "Didn't proposed yet");

        // Check if timelock interval was passed
        require((proposalTime + timeLockInterval) < now, "Can't commit yet");

        // Set new whitelist and emit event
        whitelist = proposedWhitelist;
        emit Committed(whitelist);

        // Reset proposal time lock
        proposalTime = 0;
    }

    /// @notice This function allows governor to transfer governance to a new governor and emits event
    /// @param _governor address Address of new governor
    function setGovernor(address _governor) public onlyGovernor {
        require(_governor != address(0), "Can't set zero address");
        governor = _governor;
        emit GovernorSet(governor);
    }
}

// File: contracts/Lib/WhitelistedWithGovernanceAndChangableTimelock.sol

pragma solidity 0.5.16;


/// @notice Opium.Lib.WhitelistedWithGovernanceAndChangableTimelock contract implements Opium.Lib.WhitelistedWithGovernance and adds possibility for governor to change timelock interval within timelock interval
contract WhitelistedWithGovernanceAndChangableTimelock is WhitelistedWithGovernance {
    // Emitted when new timelock is proposed
    event Proposed(uint256 timelock);
    // Emitted when new timelock is committed (set)
    event Committed(uint256 timelock);

    // Timestamp of last timelock proposal
    uint256 public timeLockProposalTime;
    // Proposed timelock
    uint256 public proposedTimeLock;

    /// @notice Calling this function governor could propose new timelock
    /// @param _timelock uint256 New timelock value
    function proposeTimelock(uint256 _timelock) public onlyGovernor {
        timeLockProposalTime = now;
        proposedTimeLock = _timelock;
        emit Proposed(_timelock);
    }

    /// @notice Calling this function governor could commit previously proposed new timelock if timelock interval of proposal was passed
    function commitTimelock() public onlyGovernor {
        // Check if proposal was made
        require(timeLockProposalTime != 0, "Didn't proposed yet");
        // Check if timelock interval was passed
        require((timeLockProposalTime + timeLockInterval) < now, "Can't commit yet");

        // Set new timelock and emit event
        timeLockInterval = proposedTimeLock;
        emit Committed(proposedTimeLock);

        // Reset timelock time lock
        timeLockProposalTime = 0;
    }
}

// File: contracts/TokenSpender.sol

pragma solidity 0.5.16;





/// @title Opium.TokenSpender contract holds users ERC20 approvals and allows whitelisted contracts to use tokens
contract TokenSpender is WhitelistedWithGovernanceAndChangableTimelock {
    using SafeERC20 for IERC20;

    // Initial timelock period
    uint256 public constant WHITELIST_TIMELOCK = 1 hours;

    /// @notice Calls constructors of super-contracts
    /// @param _governor address Address of governor, who is allowed to adjust whitelist
    constructor(address _governor) public WhitelistedWithGovernance(WHITELIST_TIMELOCK, _governor) {}

    /// @notice Using this function whitelisted contracts could call ERC20 transfers
    /// @param token IERC20 Instance of token
    /// @param from address Address from which tokens are transferred
    /// @param to address Address of tokens receiver
    /// @param amount uint256 Amount of tokens to be transferred
    function claimTokens(IERC20 token, address from, address to, uint256 amount) external onlyWhitelisted {
        token.safeTransferFrom(from, to, amount);
    }

    /// @notice Using this function whitelisted contracts could call ERC721O transfers
    /// @param token IERC721O Instance of token
    /// @param from address Address from which tokens are transferred
    /// @param to address Address of tokens receiver
    /// @param tokenId uint256 Token ID to be transferred
    /// @param amount uint256 Amount of tokens to be transferred
    function claimPositions(IERC721O token, address from, address to, uint256 tokenId, uint256 amount) external onlyWhitelisted {
        token.safeTransferFrom(from, to, tokenId, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_governor","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"timelock","type":"uint256"}],"name":"Committed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"whitelist","type":"address[]"}],"name":"Committed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"governor","type":"address"}],"name":"GovernorSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"timelock","type":"uint256"}],"name":"Proposed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"whitelist","type":"address[]"}],"name":"Proposed","type":"event"},{"constant":true,"inputs":[],"name":"WHITELIST_TIMELOCK","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"contract IERC721O","name":"token","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claimPositions","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claimTokens","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"commitTimelock","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"commitWhitelist","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getWhitelist","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"governor","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"proposalTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_timelock","type":"uint256"}],"name":"proposeTimelock","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"_whitelist","type":"address[]"}],"name":"proposeWhitelist","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"proposedTimeLock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"proposedWhitelist","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_governor","type":"address"}],"name":"setGovernor","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"timeLockInterval","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"timeLockProposalTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]

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

0x608060405234801561001057600080fd5b50600436106100f55760003560e01c80639109b14611610097578063d497501111610066578063d4975011146102f9578063dde3c14e14610301578063e61abd4a1461031e578063ef7bac3d14610326576100f5565b80639109b146146101d0578063c42cf535146101d8578063c93f70e7146101fe578063d01f63f5146102a1576100f5565b8063184a0ae9116100d3578063184a0ae9146101645780632031f63e1461017e578063289fa9b0146101c05780633e1b2cdd146101c8576100f5565b806304f7c749146100fa5780630a5ea466146101045780630c340a2414610140575b600080fd5b610102610343565b005b6101026004803603608081101561011a57600080fd5b506001600160a01b03813581169160208101358216916040820135169060600135610472565b610148610534565b604080516001600160a01b039092168252519081900360200190f35b61016c610543565b60408051918252519081900360200190f35b610102600480360360a081101561019457600080fd5b506001600160a01b03813581169160208101358216916040820135169060608101359060800135610549565b61016c61066a565b61016c610670565b610102610676565b610102600480360360208110156101ee57600080fd5b50356001600160a01b03166107fc565b6101026004803603602081101561021457600080fd5b81019060208101813564010000000081111561022f57600080fd5b82018360208201111561024157600080fd5b8035906020019184602083028401116401000000008311171561026357600080fd5b919080806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250929550610901945050505050565b6102a9610ac2565b60408051602080825283518183015283519192839290830191858101910280838360005b838110156102e55781810151838201526020016102cd565b505050509050019250505060405180910390f35b61016c610b25565b6101486004803603602081101561031757600080fd5b5035610b2b565b61016c610b52565b6101026004803603602081101561033c57600080fd5b5035610b58565b6002546001600160a01b0316331461039a576040805162461bcd60e51b815260206004820152601560248201527413db9b1e4819dbdd995c9b9bdc88185b1b1bddd959605a1b604482015290519081900360640190fd5b6005546103e4576040805162461bcd60e51b8152602060048201526013602482015272111a591b89dd081c1c9bdc1bdcd959081e595d606a1b604482015290519081900360640190fd5b426001546005540110610431576040805162461bcd60e51b815260206004820152601060248201526f10d85b89dd0818dbdb5b5a5d081e595d60821b604482015290519081900360640190fd5b600654600181905560408051918252517f023ad9f3cfd45bbf91919354cab651602c11b3d4267df2f095331f1e31c0c4299181900360200190a16000600555565b60008054815b818110156104c357336001600160a01b03166000828154811061049757fe5b6000918252602090912001546001600160a01b031614156104bb57600192506104c3565b600101610478565b5081610511576040805162461bcd60e51b815260206004820152601860248201527713db9b1e481dda1a5d195b1a5cdd195908185b1b1bddd95960421b604482015290519081900360640190fd5b61052c6001600160a01b03871686868663ffffffff610bee16565b505050505050565b6002546001600160a01b031681565b60035481565b60008054815b8181101561059a57336001600160a01b03166000828154811061056e57fe5b6000918252602090912001546001600160a01b03161415610592576001925061059a565b60010161054f565b50816105e8576040805162461bcd60e51b815260206004820152601860248201527713db9b1e481dda1a5d195b1a5cdd195908185b1b1bddd95960421b604482015290519081900360640190fd5b60408051630febdd4960e01b81526001600160a01b03888116600483015287811660248301526044820187905260648201869052915191891691630febdd499160848082019260009290919082900301818387803b15801561064957600080fd5b505af115801561065d573d6000803e3d6000fd5b5050505050505050505050565b610e1081565b60015481565b6002546001600160a01b031633146106cd576040805162461bcd60e51b815260206004820152601560248201527413db9b1e4819dbdd995c9b9bdc88185b1b1bddd959605a1b604482015290519081900360640190fd5b600354610717576040805162461bcd60e51b8152602060048201526013602482015272111a591b89dd081c1c9bdc1bdcd959081e595d606a1b604482015290519081900360640190fd5b426001546003540110610764576040805162461bcd60e51b815260206004820152601060248201526f10d85b89dd0818dbdb5b5a5d081e595d60821b604482015290519081900360640190fd5b6004805461077491600091610e42565b507fcf5f6182ae6cecd595e884fb28fd9bf02ff7d4800a47ad91888a5d42b9b7c0ee6000604051808060200182810382528381815481526020019150805480156107e757602002820191906000526020600020905b81546001600160a01b031681526001909101906020018083116107c9575b50509250505060405180910390a16000600355565b6002546001600160a01b03163314610853576040805162461bcd60e51b815260206004820152601560248201527413db9b1e4819dbdd995c9b9bdc88185b1b1bddd959605a1b604482015290519081900360640190fd5b6001600160a01b0381166108a7576040805162461bcd60e51b815260206004820152601660248201527543616e277420736574207a65726f206164647265737360501b604482015290519081900360640190fd5b600280546001600160a01b0319166001600160a01b03838116919091179182905560408051929091168252517f1cbb37f5a02c38ab13773cb770fae505cce417a4d81560117389e3a9f7e001f2916020908290030190a150565b6002546001600160a01b03163314610958576040805162461bcd60e51b815260206004820152601560248201527413db9b1e4819dbdd995c9b9bdc88185b1b1bddd959605a1b604482015290519081900360640190fd5b805161099c576040805162461bcd60e51b815260206004820152600e60248201526d43616e277420626520656d70747960901b604482015290519081900360640190fd5b600054610a315780516109b6906000906020840190610e92565b507fcf5f6182ae6cecd595e884fb28fd9bf02ff7d4800a47ad91888a5d42b9b7c0ee816040518080602001828103825283818151815260200191508051906020019060200280838360005b83811015610a19578181015183820152602001610a01565b505050509050019250505060405180910390a1610abf565b426003558051610a48906004906020840190610e92565b507f733d9de768ebc70929dcf63858a484af89d827b792edf6c89b1f6b39e6a190ae816040518080602001828103825283818151815260200191508051906020019060200280838360005b83811015610aab578181015183820152602001610a93565b505050509050019250505060405180910390a15b50565b60606000805480602002602001604051908101604052809291908181526020018280548015610b1a57602002820191906000526020600020905b81546001600160a01b03168152600190910190602001808311610afc575b505050505090505b90565b60055481565b60048181548110610b3857fe5b6000918252602090912001546001600160a01b0316905081565b60065481565b6002546001600160a01b03163314610baf576040805162461bcd60e51b815260206004820152601560248201527413db9b1e4819dbdd995c9b9bdc88185b1b1bddd959605a1b604482015290519081900360640190fd5b4260055560068190556040805182815290517fbce69c9602eb3fe8fb05c3a4be218b5f67aec8aafaf6395d2a88cc817ea97b379181900360200190a150565b604080516001600160a01b0385811660248301528416604482015260648082018490528251808303909101815260849091019091526020810180516001600160e01b03166323b872dd60e01b179052610c48908590610c4e565b50505050565b610c60826001600160a01b0316610e06565b610cb1576040805162461bcd60e51b815260206004820152601f60248201527f5361666545524332303a2063616c6c20746f206e6f6e2d636f6e747261637400604482015290519081900360640190fd5b60006060836001600160a01b0316836040518082805190602001908083835b60208310610cef5780518252601f199092019160209182019101610cd0565b6001836020036101000a0380198251168184511680821785525050505050509050019150506000604051808303816000865af19150503d8060008114610d51576040519150601f19603f3d011682016040523d82523d6000602084013e610d56565b606091505b509150915081610dad576040805162461bcd60e51b815260206004820181905260248201527f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564604482015290519081900360640190fd5b805115610c4857808060200190516020811015610dc957600080fd5b5051610c485760405162461bcd60e51b815260040180806020018281038252602a815260200180610f0c602a913960400191505060405180910390fd5b6000813f7fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a4708115801590610e3a5750808214155b949350505050565b828054828255906000526020600020908101928215610e825760005260206000209182015b82811115610e82578254825591600101919060010190610e67565b50610e8e929150610ee7565b5090565b828054828255906000526020600020908101928215610e82579160200282015b82811115610e8257825182546001600160a01b0319166001600160a01b03909116178255602090920191600190910190610eb2565b610b2291905b80821115610e8e5780546001600160a01b0319168155600101610eed56fe5361666545524332303a204552433230206f7065726174696f6e20646964206e6f742073756363656564a265627a7a723158206f3409f872b50810983d9ba1c0b25e2a2108e9366d019242c5a1566f9ef933fa64736f6c63430005100032

000000000000000000000000f80d12e55f6cda587a26a05f2e6477054e8255e5

-----Decoded View---------------
Arg [0] : _governor (address): 0xF80D12E55F6cdA587a26a05f2e6477054e8255e5

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000f80d12e55f6cda587a26a05f2e6477054e8255e5

23773:1531:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23773:1531:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23070:507;;;:::i;:::-;;24553:161;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;24553:161:0;;;;;;;;;;;;;;;;;;;;;;:::i;19200:23::-;;;:::i;:::-;;;;-1:-1:-1;;;;;19200:23:0;;;;;;;;;;;;;;19267:27;;;:::i;:::-;;;;;;;;;;;;;;;;25109:192;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;25109:192:0;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;23918:52::-;;;:::i;19135:31::-;;;:::i;21017:474::-;;;:::i;21661:205::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;21661:205:0;-1:-1:-1;;;;;21661:205:0;;:::i;20135:755::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;20135:755:0;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;20135:755:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;20135:755:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;20135:755:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;20135:755:0;;-1:-1:-1;20135:755:0;;-1:-1:-1;;;;;20135:755:0:i;18434:98::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;18434:98:0;;;;;;;;;;;;;;;;;22505:35;;;:::i;19330:34::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;19330:34:0;;:::i;22573:31::-;;;:::i;22741:183::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;22741:183:0;;:::i;23070:507::-;19531:8;;-1:-1:-1;;;;;19531:8:0;19517:10;:22;19509:56;;;;;-1:-1:-1;;;19509:56:0;;;;;;;;;;;;-1:-1:-1;;;19509:56:0;;;;;;;;;;;;;;;23174:20;;23166:57;;;;;-1:-1:-1;;;23166:57:0;;;;;;;;;;;;-1:-1:-1;;;23166:57:0;;;;;;;;;;;;;;;23336:3;23316:16;;23293:20;;:39;23292:47;23284:76;;;;;-1:-1:-1;;;23284:76:0;;;;;;;;;;;;-1:-1:-1;;;23284:76:0;;;;;;;;;;;;;;;23436:16;;23417;:35;;;23468:27;;;;;;;;;;;;;;;;23568:1;23545:20;:24;23070:507::o;24553:161::-;17790:12;17903:16;;17790:12;17930:279;17954:15;17950:1;:19;17930:279;;;18113:10;-1:-1:-1;;;;;18097:26:0;:9;18107:1;18097:12;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18097:12:0;:26;18093:105;;;18154:4;18144:14;;18177:5;;18093:105;17971:3;;17930:279;;;;18266:7;18258:44;;;;;-1:-1:-1;;;18258:44:0;;;;;;;;;;;;-1:-1:-1;;;18258:44:0;;;;;;;;;;;;;;;24666:40;-1:-1:-1;;;;;24666:22:0;;24689:4;24695:2;24699:6;24666:40;:22;:40;:::i;:::-;24553:161;;;;;;:::o;19200:23::-;;;-1:-1:-1;;;;;19200:23:0;;:::o;19267:27::-;;;;:::o;25109:192::-;17790:12;17903:16;;17790:12;17930:279;17954:15;17950:1;:19;17930:279;;;18113:10;-1:-1:-1;;;;;18097:26:0;:9;18107:1;18097:12;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18097:12:0;:26;18093:105;;;18154:4;18144:14;;18177:5;;18093:105;17971:3;;17930:279;;;;18266:7;18258:44;;;;;-1:-1:-1;;;18258:44:0;;;;;;;;;;;;-1:-1:-1;;;18258:44:0;;;;;;;;;;;;;;;25244:49;;;-1:-1:-1;;;25244:49:0;;-1:-1:-1;;;;;25244:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;:22;;;;;;:49;;;;;-1:-1:-1;;25244:49:0;;;;;;;;-1:-1:-1;25244:22:0;:49;;;5:2:-1;;;;30:1;27;20:12;5:2;25244:49:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;25244:49:0;;;;25109:192;;;;;;;:::o;23918:52::-;23963:7;23918:52;:::o;19135:31::-;;;;:::o;21017:474::-;19531:8;;-1:-1:-1;;;;;19531:8:0;19517:10;:22;19509:56;;;;;-1:-1:-1;;;19509:56:0;;;;;;;;;;;;-1:-1:-1;;;19509:56:0;;;;;;;;;;;;;;;21122:12;;21114:49;;;;;-1:-1:-1;;;21114:49:0;;;;;;;;;;;;-1:-1:-1;;;21114:49:0;;;;;;;;;;;;;;;21270:3;21250:16;;21235:12;;:31;21234:39;21226:68;;;;;-1:-1:-1;;;21226:68:0;;;;;;;;;;;;-1:-1:-1;;;21226:68:0;;;;;;;;;;;;;;;21364:17;21352:29;;;;:9;;:29;:::i;:::-;;21397:20;21407:9;21397:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;21397:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21482:1;21467:12;:16;21017:474::o;21661:205::-;19531:8;;-1:-1:-1;;;;;19531:8:0;19517:10;:22;19509:56;;;;;-1:-1:-1;;;19509:56:0;;;;;;;;;;;;-1:-1:-1;;;19509:56:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;21740:23:0;;21732:58;;;;;-1:-1:-1;;;21732:58:0;;;;;;;;;;;;-1:-1:-1;;;21732:58:0;;;;;;;;;;;;;;;21801:8;:20;;-1:-1:-1;;;;;;21801:20:0;-1:-1:-1;;;;;21801:20:0;;;;;;;;;;;21837:21;;;21849:8;;;;21837:21;;;;;;;;;;;;;21661:205;:::o;20135:755::-;19531:8;;-1:-1:-1;;;;;19531:8:0;19517:10;:22;19509:56;;;;;-1:-1:-1;;;19509:56:0;;;;;;;;;;;;-1:-1:-1;;;19509:56:0;;;;;;;;;;;;;;;20266:17;;20258:49;;;;;-1:-1:-1;;;20258:49:0;;;;;;;;;;;;-1:-1:-1;;;20258:49:0;;;;;;;;;;;;;;;20527:9;:16;20523:360;;20565:22;;;;:9;;:22;;;;;:::i;:::-;;20607:21;20617:10;20607:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;20607:21:0;;;;;;;;;;;;;;;;;20523:360;;;20783:3;20768:12;:18;20801:30;;;;:17;;:30;;;;;:::i;:::-;;20851:20;20860:10;20851:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;20851:20:0;;;;;;;;;;;;;;;;;20523:360;20135:755;:::o;18434:98::-;18479:16;18515:9;18508:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18508:16:0;;;;;;;;;;;;;;;;;;;;;;;18434:98;;:::o;22505:35::-;;;;:::o;19330:34::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19330:34:0;;-1:-1:-1;19330:34:0;:::o;22573:31::-;;;;:::o;22741:183::-;19531:8;;-1:-1:-1;;;;;19531:8:0;19517:10;:22;19509:56;;;;;-1:-1:-1;;;19509:56:0;;;;;;;;;;;;-1:-1:-1;;;19509:56:0;;;;;;;;;;;;;;;22839:3;22816:20;:26;22853:16;:28;;;22897:19;;;;;;;;;;;;;;;;;22741:183;:::o;12629:204::-;12756:68;;;-1:-1:-1;;;;;12756:68:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;12756:68:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;12730:95:0;;12749:5;;12730:18;:95::i;:::-;12629:204;;;;:::o;14484:1114::-;15088:27;15096:5;-1:-1:-1;;;;;15088:25:0;;:27::i;:::-;15080:71;;;;;-1:-1:-1;;;15080:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;15225:12;15239:23;15274:5;-1:-1:-1;;;;;15266:19:0;15286:4;15266:25;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;15266:25:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;15224:67:0;;;;15310:7;15302:52;;;;;-1:-1:-1;;;15302:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15371:17;;:21;15367:224;;15513:10;15502:30;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;15502:30:0;15494:85;;;;-1:-1:-1;;;15494:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9275:810;9335:4;9994:20;;9837:66;10034:15;;;;;:42;;;10065:11;10053:8;:23;;10034:42;10026:51;9275:810;-1:-1:-1;;;;9275:810:0:o;23773:1531::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;23773:1531:0;;;-1:-1:-1;23773:1531:0;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;23773:1531:0;-1:-1:-1;;;;;23773:1531:0;;;;;;;;;;;-1:-1:-1;23773:1531:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;23773:1531:0;;;;;;

bzzr://6f3409f872b50810983d9ba1c0b25e2a2108e9366d019242c5a1566f9ef933fa