Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function _functionCallWithValue(addre ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
• interface ENS
•    - function resolver(bytes32 node)
• interface Resolver
•    - function addr(bytes32 node)
•  contract EnsResolve
•    - function resolve(bytes32 node)
•    - function bulkResolve(bytes32[] memory ...
•    - function getChainId()
•  contract Vesting is EnsResolve *
•    - function release()
•    - function vestedAmount()
•    - function blockTimestamp()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

/**
 *Submitted for verification at Etherscan.io on 2020-12-18
*/

// https://tornado.cash
/*
* d888888P                                           dP              a88888b.                   dP
*    88                                              88             d8'   `88                   88
*    88    .d8888b. 88d888b. 88d888b. .d8888b. .d888b88 .d8888b.    88        .d8888b. .d8888b. 88d888b.
*    88    88'  `88 88'  `88 88'  `88 88'  `88 88'  `88 88'  `88    88        88'  `88 Y8ooooo. 88'  `88
*    88    88.  .88 88       88    88 88.  .88 88.  .88 88.  .88 dP Y8.   .88 88.  .88       88 88    88
*    dP    `88888P' dP       dP    dP `88888P8 `88888P8 `88888P' 88  Y88888P' `88888P8 `88888P' dP    dP
* ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
*/

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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);
}

// File: @openzeppelin/contracts/math/SafeMath.sol



pragma solidity ^0.6.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;
    }
}

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



pragma solidity ^0.6.2;

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

    /**
     * @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");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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



pragma solidity ^0.6.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 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");
        }
    }
}

// File: @openzeppelin/contracts/math/Math.sol



pragma solidity ^0.6.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

// File: contracts/ENS.sol



pragma solidity ^0.6.0;

interface ENS {
  function resolver(bytes32 node) external view returns (Resolver);
}

interface Resolver {
  function addr(bytes32 node) external view returns (address);
}

contract EnsResolve {
  function resolve(bytes32 node) public view virtual returns (address) {
    ENS Registry = ENS(
      getChainId() == 1 ? 0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e : 0x8595bFb0D940DfEDC98943FA8a907091203f25EE
    );
    return Registry.resolver(node).addr(node);
  }

  function bulkResolve(bytes32[] memory domains) public view returns (address[] memory result) {
    result = new address[](domains.length);
    for (uint256 i = 0; i < domains.length; i++) {
      result[i] = resolve(domains[i]);
    }
  }

  function getChainId() internal pure returns (uint256) {
    uint256 chainId;
    assembly {
      chainId := chainid()
    }
    return chainId;
  }
}

// File: contracts/Vesting.sol



pragma solidity ^0.6.0;






/**
 * @title Vesting
 * @dev A token holder contract that can release its token balance gradually like a
 * typical vesting scheme, with a cliff and vesting period. Optionally revocable by the
 * owner.
 */
contract Vesting is EnsResolve {
  using SafeERC20 for IERC20;
  using SafeMath for uint256;

  uint256 public constant SECONDS_PER_MONTH = 30 days;

  event Released(uint256 amount);

  // beneficiary of tokens after they are released
  address public immutable beneficiary;
  IERC20 public immutable token;

  uint256 public immutable cliffInMonths;
  uint256 public immutable startTimestamp;
  uint256 public immutable durationInMonths;
  uint256 public released;

  /**
   * @dev Creates a vesting contract that vests its balance of any ERC20 token to the
   * _beneficiary, monthly in a linear fashion until duration has passed. By then all
   * of the balance will have vested.
   * @param _beneficiary address of the beneficiary to whom vested tokens are transferred
   * @param _cliffInMonths duration in months of the cliff in which tokens will begin to vest
   * @param _durationInMonths duration in months of the period in which the tokens will vest
   */
  constructor(
    bytes32 _token,
    address _beneficiary,
    uint256 _startTimestamp,
    uint256 _cliffInMonths,
    uint256 _durationInMonths
  ) public {
    require(_beneficiary != address(0), "Beneficiary cannot be empty");
    require(_cliffInMonths <= _durationInMonths, "Cliff is greater than duration");

    token = IERC20(resolve(_token));
    beneficiary = _beneficiary;
    durationInMonths = _durationInMonths;
    cliffInMonths = _cliffInMonths;
    startTimestamp = _startTimestamp == 0 ? blockTimestamp() : _startTimestamp;
  }

  /**
   * @notice Transfers vested tokens to beneficiary.
   */
  function release() external {
    uint256 vested = vestedAmount();
    require(vested > 0, "No tokens to release");

    released = released.add(vested);
    token.safeTransfer(beneficiary, vested);

    emit Released(vested);
  }

  /**
   * @dev Calculates the amount that has already vested but hasn't been released yet.
   */
  function vestedAmount() public view returns (uint256) {
    if (blockTimestamp() < startTimestamp) {
      return 0;
    }

    uint256 elapsedTime = blockTimestamp().sub(startTimestamp);
    uint256 elapsedMonths = elapsedTime.div(SECONDS_PER_MONTH);

    if (elapsedMonths < cliffInMonths) {
      return 0;
    }

    // If over vesting duration, all tokens vested
    if (elapsedMonths >= durationInMonths) {
      return token.balanceOf(address(this));
    } else {
      uint256 currentBalance = token.balanceOf(address(this));
      uint256 totalBalance = currentBalance.add(released);

      uint256 vested = totalBalance.mul(elapsedMonths).div(durationInMonths);
      uint256 unreleased = vested.sub(released);

      // currentBalance can be 0 in case of vesting being revoked earlier.
      return Math.min(currentBalance, unreleased);
    }
  }

  function blockTimestamp() public view virtual returns (uint256) {
    return block.timestamp;
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"bytes32","name":"_token","type":"bytes32"},{"internalType":"address","name":"_beneficiary","type":"address"},{"internalType":"uint256","name":"_startTimestamp","type":"uint256"},{"internalType":"uint256","name":"_cliffInMonths","type":"uint256"},{"internalType":"uint256","name":"_durationInMonths","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Released","type":"event"},{"inputs":[],"name":"SECONDS_PER_MONTH","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":"blockTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"domains","type":"bytes32[]"}],"name":"bulkResolve","outputs":[{"internalType":"address[]","name":"result","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cliffInMonths","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"durationInMonths","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"node","type":"bytes32"}],"name":"resolve","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

79a75ab558b53fdc478d1b223d669e6f5f650ce9b7e9cdd6ae9bd9f0917b552d0000000000000000000000005efda50f22d34f262c29268506c5fa42cb56a1ce00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000003c

-----Decoded View---------------
Arg [0] : _token (bytes32): 0x79a75ab558b53fdc478d1b223d669e6f5f650ce9b7e9cdd6ae9bd9f0917b552d
Arg [1] : _beneficiary (address): 0x5efda50f22d34F262c29268506C5Fa42cB56A1Ce
Arg [2] : _startTimestamp (uint256): 0
Arg [3] : _cliffInMonths (uint256): 3
Arg [4] : _durationInMonths (uint256): 60

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 79a75ab558b53fdc478d1b223d669e6f5f650ce9b7e9cdd6ae9bd9f0917b552d
Arg [1] : 0000000000000000000000005efda50f22d34f262c29268506c5fa42cb56a1ce
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [4] : 000000000000000000000000000000000000000000000000000000000000003c

21128:2964:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21228:51;;;:::i;:::-;;;;;;;;;;;;;;;;21375:36;;;:::i;:::-;;;;-1:-1:-1;;;;;21375:36:0;;;;;;;;;;;;;;23102:882;;;:::i;20152:271::-;;;;;;;;;;;;;;;;-1:-1:-1;20152:271:0;;:::i;21539:41::-;;;:::i;22757:238::-;;;:::i;:::-;;21452:38;;;:::i;21585:23::-;;;:::i;23990:99::-;;;:::i;21495:39::-;;;:::i;20429:243::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20429:243:0;;-1:-1:-1;20429:243:0;;-1:-1:-1;;;;;20429:243:0:i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21416:29;;;:::i;21228:51::-;21272:7;21228:51;:::o;21375:36::-;;;:::o;23102:882::-;23147:7;23186:14;23167:16;:14;:16::i;:::-;:33;23163:64;;;-1:-1:-1;23218:1:0;23211:8;;23163:64;23235:19;23257:36;23278:14;23257:16;:14;:16::i;:::-;:20;;:36::i;:::-;23235:58;-1:-1:-1;23300:21:0;23324:34;23235:58;21272:7;23324:15;:34::i;:::-;23300:58;;23387:13;23371;:29;23367:60;;;23418:1;23411:8;;;;;;23367:60;23508:16;23491:13;:33;23487:492;;23542:30;;;-1:-1:-1;;;23542:30:0;;23566:4;23542:30;;;;;;-1:-1:-1;;;;;23542:5:0;:15;;;;:30;;;;;;;;;;;;;;:15;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;23542:30:0;;-1:-1:-1;23535:37:0;;-1:-1:-1;;23535:37:0;23487:492;23595:22;23620:5;-1:-1:-1;;;;;23620:15:0;;23644:4;23620:30;;;;;;;;;;;;;-1:-1:-1;;;;;23620:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;23620:30:0;23659:20;23701:8;;23620:30;;-1:-1:-1;23659:20:0;23682:28;;23620:30;;23682:18;:28::i;:::-;23659:51;-1:-1:-1;23721:14:0;23738:53;23774:16;23738:31;23659:51;23755:13;23738:16;:31::i;:::-;:35;;:53::i;:::-;23721:70;;23800:18;23821:20;23832:8;;23821:6;:10;;:20;;;;:::i;:::-;23800:41;;23935:36;23944:14;23960:10;23935:8;:36::i;:::-;23928:43;;;;;;;;23102:882;;:::o;20152:271::-;20212:7;20228:12;20255;:10;:12::i;:::-;20271:1;20255:17;:107;;20320:42;20255:107;;;20275:42;20255:107;20228:141;;20383:8;-1:-1:-1;;;;;20383:17:0;;20401:4;20383:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20383:23:0;:34;;;-1:-1:-1;;;20383:34:0;;;;;;;;;;-1:-1:-1;;;;;20383:28:0;;;;;;:34;;;;;:23;;:34;;;;;;;;:28;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20383:34:0;;20152:271;-1:-1:-1;;;20152:271:0:o;21539:41::-;;;:::o;22757:238::-;22792:14;22809;:12;:14::i;:::-;22792:31;;22847:1;22838:6;:10;22830:43;;;;;-1:-1:-1;;;22830:43:0;;;;;;;;;;;;-1:-1:-1;;;22830:43:0;;;;;;;;;;;;;;;22893:8;;:20;;22906:6;22893:12;:20::i;:::-;22882:8;:31;22920:39;-1:-1:-1;;;;;22920:5:0;:18;22939:11;22952:6;22920:18;:39::i;:::-;22973:16;;;;;;;;;;;;;;;;;22757:238;:::o;21452:38::-;;;:::o;21585:23::-;;;;:::o;23990:99::-;24068:15;23990:99;:::o;21495:39::-;;;:::o;20429:243::-;20497:23;20552:7;:14;20538:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20538:29:0;;20529:38;;20579:9;20574:93;20598:7;:14;20594:1;:18;20574:93;;;20640:19;20648:7;20656:1;20648:10;;;;;;;;;;;;;;20640:7;:19::i;:::-;20628:6;20635:1;20628:9;;;;;;;;-1:-1:-1;;;;;20628:31:0;;;:9;;;;;;;;;;;:31;20614:3;;20574:93;;;;20429:243;;;:::o;21416:29::-;;;:::o;5060:136::-;5118:7;5145:43;5149:1;5152;5145:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;5138:50;;5060:136;;;;;:::o;6897:132::-;6955:7;6982:39;6986:1;6989;6982:39;;;;;;;;;;;;;;;;;:3;:39::i;4596:181::-;4654:7;4686:5;;;4710:6;;;;4702:46;;;;;-1:-1:-1;;;4702:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;5950:471;6008:7;6253:6;6249:47;;-1:-1:-1;6283:1:0;6276:8;;6249:47;6320:5;;;6324:1;6320;:5;:1;6344:5;;;;;:10;6336:56;;;;-1:-1:-1;;;6336:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19459:106;19517:7;19548:1;19544;:5;:13;;19556:1;19544:13;;;-1:-1:-1;19552:1:0;;19459:106;-1:-1:-1;19459:106:0:o;20678:154::-;20790:9;20678:154;:::o;15958:177::-;16068:58;;;-1:-1:-1;;;;;16068:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;16068:58:0;-1:-1:-1;;;16068:58:0;;;16041:86;;16061:5;;16041:19;:86::i;:::-;15958:177;;;:::o;5499:192::-;5585:7;5621:12;5613:6;;;;5605:29;;;;-1:-1:-1;;;5605:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;5657:5:0;;;5499:192::o;7525:278::-;7611:7;7646:12;7639:5;7631:28;;;;-1:-1:-1;;;7631:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7670:9;7686:1;7682;:5;;;;;;;7525:278;-1:-1:-1;;;;;7525:278:0:o;18263:761::-;18687:23;18713:69;18741:4;18713:69;;;;;;;;;;;;;;;;;18721:5;-1:-1:-1;;;;;18713:27:0;;;:69;;;;;:::i;:::-;18797:17;;18687:95;;-1:-1:-1;18797:21:0;18793:224;;18939:10;18928:30;;;;;;;;;;;;;;;-1:-1:-1;18928:30:0;18920:85;;;;-1:-1:-1;;;18920:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12937:196;13040:12;13072:53;13095:6;13103:4;13109:1;13112:12;13072:22;:53::i;:::-;13065:60;12937:196;-1:-1:-1;;;;12937:196:0:o;14314:979::-;14444:12;14477:18;14488:6;14477:10;:18::i;:::-;14469:60;;;;;-1:-1:-1;;;14469:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;14603:12;14617:23;14644:6;-1:-1:-1;;;;;14644:11:0;14664:8;14675:4;14644:36;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;14644:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14602:78;;;;14695:7;14691:595;;;14726:10;-1:-1:-1;14719:17:0;;-1:-1:-1;14719:17:0;14691:595;14840:17;;:21;14836:439;;15103:10;15097:17;15164:15;15151:10;15147:2;15143:19;15136:44;15051:148;15239:20;;-1:-1:-1;;;15239:20:0;;;;;;;;;;;;;;;;;15246:12;;15239:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9822:619;9882:4;10350:20;;10193:66;10390:23;;;;;;:42;;-1:-1:-1;;10417:15:0;;;10382:51;-1:-1:-1;;9822:619:0:o

ipfs://9b4f875a921ed2924a10bc4bcb57eed86e96f83fb59f15e93a3d6067b2701efc