Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function safePermit(
•    - function _callOptionalReturn(IERC20 t ...
•  contract TokenTimelock
•    - function token()
•    - function beneficiary()
•    - function releaseTime()
•    - function release()
•  contract Timelock is TokenTimelock *
•    - function balance()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-09-19
*/

// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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");

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

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

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.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 IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    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'
        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) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

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

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @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
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/utils/TokenTimelock.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/utils/TokenTimelock.sol)

pragma solidity ^0.8.0;


/**
 * @dev A token holder contract that will allow a beneficiary to extract the
 * tokens after a given release time.
 *
 * Useful for simple vesting schedules like "advisors get all of their tokens
 * after 1 year".
 */
contract TokenTimelock {
    using SafeERC20 for IERC20;

    // ERC20 basic token contract being held
    IERC20 private immutable _token;

    // beneficiary of tokens after they are released
    address private immutable _beneficiary;

    // timestamp when token release is enabled
    uint256 private immutable _releaseTime;

    /**
     * @dev Deploys a timelock instance that is able to hold the token specified, and will only release it to
     * `beneficiary_` when {release} is invoked after `releaseTime_`. The release time is specified as a Unix timestamp
     * (in seconds).
     */
    constructor(
        IERC20 token_,
        address beneficiary_,
        uint256 releaseTime_
    ) {
        require(releaseTime_ > block.timestamp, "TokenTimelock: release time is before current time");
        _token = token_;
        _beneficiary = beneficiary_;
        _releaseTime = releaseTime_;
    }

    /**
     * @dev Returns the token being held.
     */
    function token() public view virtual returns (IERC20) {
        return _token;
    }

    /**
     * @dev Returns the beneficiary that will receive the tokens.
     */
    function beneficiary() public view virtual returns (address) {
        return _beneficiary;
    }

    /**
     * @dev Returns the time when the tokens are released in seconds since Unix epoch (i.e. Unix timestamp).
     */
    function releaseTime() public view virtual returns (uint256) {
        return _releaseTime;
    }

    /**
     * @dev Transfers tokens held by the timelock to the beneficiary. Will only succeed if invoked after the release
     * time.
     */
    function release() public virtual {
        require(block.timestamp >= releaseTime(), "TokenTimelock: current time is before release time");

        uint256 amount = token().balanceOf(address(this));
        require(amount > 0, "TokenTimelock: no tokens to release");

        token().safeTransfer(beneficiary(), amount);
    }
}

// File: contracts/timelock.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;


contract Timelock is TokenTimelock {
    constructor(
        IERC20 token_,
        address beneficiary_,
        uint256 releaseTime_
    ) TokenTimelock(token_, beneficiary_, releaseTime_) {}

    function balance() public view virtual returns (uint256) {
        return token().balanceOf(address(this));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"token_","type":"address"},{"internalType":"address","name":"beneficiary_","type":"address"},{"internalType":"uint256","name":"releaseTime_","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"balance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beneficiary","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"releaseTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0x608060405234801561001057600080fd5b50600436106100575760003560e01c806338af3eed1461005c57806386d1a69f1461007a578063b69ef8a814610084578063b91d4001146100a2578063fc0c546a146100c0575b600080fd5b6100646100de565b6040516100719190610670565b60405180910390f35b610082610106565b005b61008c610254565b60405161009991906106a4565b60405180910390f35b6100aa6102dc565b6040516100b791906106a4565b60405180910390f35b6100c8610304565b6040516100d5919061071e565b60405180910390f35b60007f000000000000000000000000092156599132a1205a9665c49eebf208bc3ef2f0905090565b61010e6102dc565b421015610150576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610147906107bc565b60405180910390fd5b600061015a610304565b73ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016101929190610670565b602060405180830381865afa1580156101af573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101d3919061080d565b905060008111610218576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161020f906108ac565b60405180910390fd5b6102516102236100de565b8261022c610304565b73ffffffffffffffffffffffffffffffffffffffff1661032c9092919063ffffffff16565b50565b600061025e610304565b73ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016102969190610670565b602060405180830381865afa1580156102b3573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906102d7919061080d565b905090565b60007f000000000000000000000000000000000000000000000000000000006424d100905090565b60007f0000000000000000000000006988a804c74fd04f37da1ea4781cea68c9c00f86905090565b6103ad8363a9059cbb60e01b848460405160240161034b9291906108cc565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff83818316178352505050506103b2565b505050565b6000610414826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166104799092919063ffffffff16565b90506000815111156104745780806020019051810190610434919061092d565b610473576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161046a906109cc565b60405180910390fd5b5b505050565b60606104888484600085610491565b90509392505050565b6060824710156104d6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104cd90610a5e565b60405180910390fd5b6104df856105a5565b61051e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161051590610aca565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516105479190610b64565b60006040518083038185875af1925050503d8060008114610584576040519150601f19603f3d011682016040523d82523d6000602084013e610589565b606091505b50915091506105998282866105c8565b92505050949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b606083156105d857829050610628565b6000835111156105eb5782518084602001fd5b816040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161061f9190610bd0565b60405180910390fd5b9392505050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600061065a8261062f565b9050919050565b61066a8161064f565b82525050565b60006020820190506106856000830184610661565b92915050565b6000819050919050565b61069e8161068b565b82525050565b60006020820190506106b96000830184610695565b92915050565b6000819050919050565b60006106e46106df6106da8461062f565b6106bf565b61062f565b9050919050565b60006106f6826106c9565b9050919050565b6000610708826106eb565b9050919050565b610718816106fd565b82525050565b6000602082019050610733600083018461070f565b92915050565b600082825260208201905092915050565b7f546f6b656e54696d656c6f636b3a2063757272656e742074696d65206973206260008201527f65666f72652072656c656173652074696d650000000000000000000000000000602082015250565b60006107a6603283610739565b91506107b18261074a565b604082019050919050565b600060208201905081810360008301526107d581610799565b9050919050565b600080fd5b6107ea8161068b565b81146107f557600080fd5b50565b600081519050610807816107e1565b92915050565b600060208284031215610823576108226107dc565b5b6000610831848285016107f8565b91505092915050565b7f546f6b656e54696d656c6f636b3a206e6f20746f6b656e7320746f2072656c6560008201527f6173650000000000000000000000000000000000000000000000000000000000602082015250565b6000610896602383610739565b91506108a18261083a565b604082019050919050565b600060208201905081810360008301526108c581610889565b9050919050565b60006040820190506108e16000830185610661565b6108ee6020830184610695565b9392505050565b60008115159050919050565b61090a816108f5565b811461091557600080fd5b50565b60008151905061092781610901565b92915050565b600060208284031215610943576109426107dc565b5b600061095184828501610918565b91505092915050565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b60006109b6602a83610739565b91506109c18261095a565b604082019050919050565b600060208201905081810360008301526109e5816109a9565b9050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b6000610a48602683610739565b9150610a53826109ec565b604082019050919050565b60006020820190508181036000830152610a7781610a3b565b9050919050565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b6000610ab4601d83610739565b9150610abf82610a7e565b602082019050919050565b60006020820190508181036000830152610ae381610aa7565b9050919050565b600081519050919050565b600081905092915050565b60005b83811015610b1e578082015181840152602081019050610b03565b83811115610b2d576000848401525b50505050565b6000610b3e82610aea565b610b488185610af5565b9350610b58818560208601610b00565b80840191505092915050565b6000610b708284610b33565b915081905092915050565b600081519050919050565b6000601f19601f8301169050919050565b6000610ba282610b7b565b610bac8185610739565b9350610bbc818560208601610b00565b610bc581610b86565b840191505092915050565b60006020820190508181036000830152610bea8184610b97565b90509291505056fea264697066735822122040178ba7b3f29eae56a71c0116cf45dc27754ebe37aec23f024b5c0b53355fa364736f6c634300080f0033

0000000000000000000000006988a804c74fd04f37da1ea4781cea68c9c00f86000000000000000000000000092156599132a1205a9665c49eebf208bc3ef2f0000000000000000000000000000000000000000000000000000000006424d100

-----Decoded View---------------
Arg [0] : token_ (address): 0x6988A804C74Fd04F37DA1EA4781CEa68c9C00F86
Arg [1] : beneficiary_ (address): 0x092156599132a1205A9665c49eebF208bC3Ef2f0
Arg [2] : releaseTime_ (uint256): 1680134400

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000006988a804c74fd04f37da1ea4781cea68c9c00f86
Arg [1] : 000000000000000000000000092156599132a1205a9665c49eebf208bc3ef2f0
Arg [2] : 000000000000000000000000000000000000000000000000000000006424d100

20840:325:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19908:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20400:335;;;:::i;:::-;;21047:115;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20143:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19729:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19908:99;19960:7;19987:12;19980:19;;19908:99;:::o;20400:335::-;20472:13;:11;:13::i;:::-;20453:15;:32;;20445:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;20553:14;20570:7;:5;:7::i;:::-;:17;;;20596:4;20570:32;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20553:49;;20630:1;20621:6;:10;20613:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;20684:43;20705:13;:11;:13::i;:::-;20720:6;20684:7;:5;:7::i;:::-;:20;;;;:43;;;;;:::i;:::-;20434:301;20400:335::o;21047:115::-;21095:7;21122;:5;:7::i;:::-;:17;;;21148:4;21122:32;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21115:39;;21047:115;:::o;20143:99::-;20195:7;20222:12;20215:19;;20143:99;:::o;19729:86::-;19775:6;19801;19794:13;;19729:86;:::o;14511:211::-;14628:86;14648:5;14678:23;;;14703:2;14707:5;14655:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14628:19;:86::i;:::-;14511:211;;;:::o;17578:716::-;18002:23;18028:69;18056:4;18028:69;;;;;;;;;;;;;;;;;18036:5;18028:27;;;;:69;;;;;:::i;:::-;18002:95;;18132:1;18112:10;:17;:21;18108:179;;;18209:10;18198:30;;;;;;;;;;;;:::i;:::-;18190:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;18108:179;17648:646;17578:716;;:::o;3978:229::-;4115:12;4147:52;4169:6;4177:4;4183:1;4186:12;4147:21;:52::i;:::-;4140:59;;3978:229;;;;;:::o;5098:510::-;5268:12;5326:5;5301:21;:30;;5293:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;5393:18;5404:6;5393:10;:18::i;:::-;5385:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;5459:12;5473:23;5500:6;:11;;5519:5;5526:4;5500:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5458:73;;;;5549:51;5566:7;5575:10;5587:12;5549:16;:51::i;:::-;5542:58;;;;5098:510;;;;;;:::o;1233:326::-;1293:4;1550:1;1528:7;:19;;;:23;1521:30;;1233:326;;;:::o;7784:762::-;7934:12;7963:7;7959:580;;;7994:10;7987:17;;;;7959:580;8128:1;8108:10;:17;:21;8104:424;;;8356:10;8350:17;8417:15;8404:10;8400:2;8396:19;8389:44;8104:424;8499:12;8492:20;;;;;;;;;;;:::i;:::-;;;;;;;;7784:762;;;;;;:::o;7:126:1:-;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:96::-;176:7;205:24;223:5;205:24;:::i;:::-;194:35;;139:96;;;:::o;241:118::-;328:24;346:5;328:24;:::i;:::-;323:3;316:37;241:118;;:::o;365:222::-;458:4;496:2;485:9;481:18;473:26;;509:71;577:1;566:9;562:17;553:6;509:71;:::i;:::-;365:222;;;;:::o;593:77::-;630:7;659:5;648:16;;593:77;;;:::o;676:118::-;763:24;781:5;763:24;:::i;:::-;758:3;751:37;676:118;;:::o;800:222::-;893:4;931:2;920:9;916:18;908:26;;944:71;1012:1;1001:9;997:17;988:6;944:71;:::i;:::-;800:222;;;;:::o;1028:60::-;1056:3;1077:5;1070:12;;1028:60;;;:::o;1094:142::-;1144:9;1177:53;1195:34;1204:24;1222:5;1204:24;:::i;:::-;1195:34;:::i;:::-;1177:53;:::i;:::-;1164:66;;1094:142;;;:::o;1242:126::-;1292:9;1325:37;1356:5;1325:37;:::i;:::-;1312:50;;1242:126;;;:::o;1374:140::-;1438:9;1471:37;1502:5;1471:37;:::i;:::-;1458:50;;1374:140;;;:::o;1520:159::-;1621:51;1666:5;1621:51;:::i;:::-;1616:3;1609:64;1520:159;;:::o;1685:250::-;1792:4;1830:2;1819:9;1815:18;1807:26;;1843:85;1925:1;1914:9;1910:17;1901:6;1843:85;:::i;:::-;1685:250;;;;:::o;1941:169::-;2025:11;2059:6;2054:3;2047:19;2099:4;2094:3;2090:14;2075:29;;1941:169;;;;:::o;2116:237::-;2256:34;2252:1;2244:6;2240:14;2233:58;2325:20;2320:2;2312:6;2308:15;2301:45;2116:237;:::o;2359:366::-;2501:3;2522:67;2586:2;2581:3;2522:67;:::i;:::-;2515:74;;2598:93;2687:3;2598:93;:::i;:::-;2716:2;2711:3;2707:12;2700:19;;2359:366;;;:::o;2731:419::-;2897:4;2935:2;2924:9;2920:18;2912:26;;2984:9;2978:4;2974:20;2970:1;2959:9;2955:17;2948:47;3012:131;3138:4;3012:131;:::i;:::-;3004:139;;2731:419;;;:::o;3237:117::-;3346:1;3343;3336:12;3483:122;3556:24;3574:5;3556:24;:::i;:::-;3549:5;3546:35;3536:63;;3595:1;3592;3585:12;3536:63;3483:122;:::o;3611:143::-;3668:5;3699:6;3693:13;3684:22;;3715:33;3742:5;3715:33;:::i;:::-;3611:143;;;;:::o;3760:351::-;3830:6;3879:2;3867:9;3858:7;3854:23;3850:32;3847:119;;;3885:79;;:::i;:::-;3847:119;4005:1;4030:64;4086:7;4077:6;4066:9;4062:22;4030:64;:::i;:::-;4020:74;;3976:128;3760:351;;;;:::o;4117:222::-;4257:34;4253:1;4245:6;4241:14;4234:58;4326:5;4321:2;4313:6;4309:15;4302:30;4117:222;:::o;4345:366::-;4487:3;4508:67;4572:2;4567:3;4508:67;:::i;:::-;4501:74;;4584:93;4673:3;4584:93;:::i;:::-;4702:2;4697:3;4693:12;4686:19;;4345:366;;;:::o;4717:419::-;4883:4;4921:2;4910:9;4906:18;4898:26;;4970:9;4964:4;4960:20;4956:1;4945:9;4941:17;4934:47;4998:131;5124:4;4998:131;:::i;:::-;4990:139;;4717:419;;;:::o;5142:332::-;5263:4;5301:2;5290:9;5286:18;5278:26;;5314:71;5382:1;5371:9;5367:17;5358:6;5314:71;:::i;:::-;5395:72;5463:2;5452:9;5448:18;5439:6;5395:72;:::i;:::-;5142:332;;;;;:::o;5480:90::-;5514:7;5557:5;5550:13;5543:21;5532:32;;5480:90;;;:::o;5576:116::-;5646:21;5661:5;5646:21;:::i;:::-;5639:5;5636:32;5626:60;;5682:1;5679;5672:12;5626:60;5576:116;:::o;5698:137::-;5752:5;5783:6;5777:13;5768:22;;5799:30;5823:5;5799:30;:::i;:::-;5698:137;;;;:::o;5841:345::-;5908:6;5957:2;5945:9;5936:7;5932:23;5928:32;5925:119;;;5963:79;;:::i;:::-;5925:119;6083:1;6108:61;6161:7;6152:6;6141:9;6137:22;6108:61;:::i;:::-;6098:71;;6054:125;5841:345;;;;:::o;6192:229::-;6332:34;6328:1;6320:6;6316:14;6309:58;6401:12;6396:2;6388:6;6384:15;6377:37;6192:229;:::o;6427:366::-;6569:3;6590:67;6654:2;6649:3;6590:67;:::i;:::-;6583:74;;6666:93;6755:3;6666:93;:::i;:::-;6784:2;6779:3;6775:12;6768:19;;6427:366;;;:::o;6799:419::-;6965:4;7003:2;6992:9;6988:18;6980:26;;7052:9;7046:4;7042:20;7038:1;7027:9;7023:17;7016:47;7080:131;7206:4;7080:131;:::i;:::-;7072:139;;6799:419;;;:::o;7224:225::-;7364:34;7360:1;7352:6;7348:14;7341:58;7433:8;7428:2;7420:6;7416:15;7409:33;7224:225;:::o;7455:366::-;7597:3;7618:67;7682:2;7677:3;7618:67;:::i;:::-;7611:74;;7694:93;7783:3;7694:93;:::i;:::-;7812:2;7807:3;7803:12;7796:19;;7455:366;;;:::o;7827:419::-;7993:4;8031:2;8020:9;8016:18;8008:26;;8080:9;8074:4;8070:20;8066:1;8055:9;8051:17;8044:47;8108:131;8234:4;8108:131;:::i;:::-;8100:139;;7827:419;;;:::o;8252:179::-;8392:31;8388:1;8380:6;8376:14;8369:55;8252:179;:::o;8437:366::-;8579:3;8600:67;8664:2;8659:3;8600:67;:::i;:::-;8593:74;;8676:93;8765:3;8676:93;:::i;:::-;8794:2;8789:3;8785:12;8778:19;;8437:366;;;:::o;8809:419::-;8975:4;9013:2;9002:9;8998:18;8990:26;;9062:9;9056:4;9052:20;9048:1;9037:9;9033:17;9026:47;9090:131;9216:4;9090:131;:::i;:::-;9082:139;;8809:419;;;:::o;9234:98::-;9285:6;9319:5;9313:12;9303:22;;9234:98;;;:::o;9338:147::-;9439:11;9476:3;9461:18;;9338:147;;;;:::o;9491:307::-;9559:1;9569:113;9583:6;9580:1;9577:13;9569:113;;;9668:1;9663:3;9659:11;9653:18;9649:1;9644:3;9640:11;9633:39;9605:2;9602:1;9598:10;9593:15;;9569:113;;;9700:6;9697:1;9694:13;9691:101;;;9780:1;9771:6;9766:3;9762:16;9755:27;9691:101;9540:258;9491:307;;;:::o;9804:373::-;9908:3;9936:38;9968:5;9936:38;:::i;:::-;9990:88;10071:6;10066:3;9990:88;:::i;:::-;9983:95;;10087:52;10132:6;10127:3;10120:4;10113:5;10109:16;10087:52;:::i;:::-;10164:6;10159:3;10155:16;10148:23;;9912:265;9804:373;;;;:::o;10183:271::-;10313:3;10335:93;10424:3;10415:6;10335:93;:::i;:::-;10328:100;;10445:3;10438:10;;10183:271;;;;:::o;10460:99::-;10512:6;10546:5;10540:12;10530:22;;10460:99;;;:::o;10565:102::-;10606:6;10657:2;10653:7;10648:2;10641:5;10637:14;10633:28;10623:38;;10565:102;;;:::o;10673:364::-;10761:3;10789:39;10822:5;10789:39;:::i;:::-;10844:71;10908:6;10903:3;10844:71;:::i;:::-;10837:78;;10924:52;10969:6;10964:3;10957:4;10950:5;10946:16;10924:52;:::i;:::-;11001:29;11023:6;11001:29;:::i;:::-;10996:3;10992:39;10985:46;;10765:272;10673:364;;;;:::o;11043:313::-;11156:4;11194:2;11183:9;11179:18;11171:26;;11243:9;11237:4;11233:20;11229:1;11218:9;11214:17;11207:47;11271:78;11344:4;11335:6;11271:78;:::i;:::-;11263:86;;11043:313;;;;:::o

ipfs://40178ba7b3f29eae56a71c0116cf45dc27754ebe37aec23f024b5c0b53355fa3