Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
• 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 functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(address ...
•    - function _verifyCallResult(bool succe ...
• 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 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 ...
•  contract TokenVesting is Ownable *
•    - function release(IERC20 token)
•    - function revoke(IERC20 token)
•    - function beneficiary()
•    - function start()
•    - function cliff()
•    - function duration()
•    - function revocable()
•    - function released(address token)
•    - function revoked(address token)
•    - function releasableAmount(IERC20 toke ...
•    - function vestedAmount(IERC20 token)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // 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 (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @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) {
        return a + b;
    }

    /**
     * @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 a - b;
    }

    /**
     * @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) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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 a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards 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).
     *
     * 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

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

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/contracts/access/Ownable.sol

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

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

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

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

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

    /**
     * @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");

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

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/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'
        // 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) + 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));
        }
    }

    /**
     * @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: TokenVesting.sol

pragma solidity 0.8.3;





/**
 * @title TokenVesting
 * @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 TokenVesting is Ownable {
  // The vesting schedule is time-based (i.e. using block timestamps as opposed to e.g. block numbers), and is
  // therefore sensitive to timestamp manipulation (which is something miners can do, to a certain degree). Therefore,
  // it is recommended to avoid using short time durations (less than a minute). Typical vesting schemes, with a
  // cliff period of a year and a duration of four years, are safe to use.
  // solhint-disable not-rely-on-time

  using SafeMath for uint256;
  using SafeERC20 for IERC20;

  event TokensReleased(address token, uint256 amount);
  event TokenVestingRevoked(address token);

  // Beneficiary of tokens after they are released
  address private _beneficiary;

  // Durations and timestamps are expressed in UNIX time, the same units as block.timestamp.
  uint256 private _start;
  uint256 private _cliff;
  uint256 private _duration;
  uint256 private _end;

  bool private _revocable;

  mapping (address => uint256) private _released;
  mapping (address => bool) private _revoked;

  /**
   * @dev Creates a vesting contract that vests its balance of any ERC20 token to the
   * beneficiary, gradually in a linear fashion until start + duration. By then all
   * of the balance will have vested.
   * @param beneficiary_ address of the beneficiary to whom vested tokens are transferred
   * @param start_ the time (as Unix time) at which point vesting starts
   * @param cliff_ duration in seconds of the cliff in which tokens will begin to vest
   * @param duration_ duration in seconds of the period in which the tokens will vest
   * @param revocable_ whether the vesting is revocable or not
   */
  constructor (
    address beneficiary_,
    uint256 start_,
    uint256 cliff_,
    uint256 duration_,
    bool revocable_
  ) {
    require(beneficiary_ != address(0), "TokenVesting: beneficiary is the zero address");
    require(cliff_ <= duration_, "TokenVesting: cliff is longer than duration");
    require(duration_ > 0, "TokenVesting: duration is 0");
    require(start_.add(duration_) > block.timestamp, "TokenVesting: final time is before current time");

    _beneficiary = beneficiary_;
    _revocable = revocable_;
    _duration = duration_;
    _cliff = start_.add(cliff_);
    _end = start_.add(duration_);
    _start = start_;
  }

  /**
   * @notice Transfers vested tokens to beneficiary.
   * @param token ERC20 token which is being vested
   */
  function release(IERC20 token) external {
    uint256 unreleased = releasableAmount(token);

    require(unreleased > 0, "TokenVesting: no tokens are due");

    _released[address(token)] = _released[address(token)].add(unreleased);

    token.safeTransfer(_beneficiary, unreleased);

    emit TokensReleased(address(token), unreleased);
  }

  /**
   * @notice Allows the owner to revoke the vesting. Tokens already vested
   * remain in the contract, the rest are returned to the owner.
   * @param token ERC20 token which is being vested
   */
  function revoke(IERC20 token) external onlyOwner {
    require(_revocable, "TokenVesting: cannot revoke");
    require(!_revoked[address(token)], "TokenVesting: token already revoked");

    uint256 balance = token.balanceOf(address(this));

    uint256 unreleased = releasableAmount(token);
    uint256 refund = balance.sub(unreleased);

    _revoked[address(token)] = true;

    token.safeTransfer(owner(), refund);

    emit TokenVestingRevoked(address(token));
  }

  /**
   * @return the beneficiary of the tokens.
   */
  function beneficiary() public view returns (address) {
    return _beneficiary;
  }

  /**
   * @return the start time of the token vesting.
   */
  function start() public view returns (uint256) {
    return _start;
  }

  /**
   * @return the cliff time of the token vesting.
   */
  function cliff() public view returns (uint256) {
    return _cliff;
  }

  /**
   * @return the duration of the token vesting.
   */
  function duration() public view returns (uint256) {
    return _duration;
  }

  /**
   * @return true if the vesting is revocable.
   */
  function revocable() public view returns (bool) {
    return _revocable;
  }

  /**
   * @return the amount of the token released.
   */
  function released(address token) public view returns (uint256) {
    return _released[token];
  }

  /**
   * @return true if the token is revoked.
   */
  function revoked(address token) public view returns (bool) {
    return _revoked[token];
  }

  /**
   * @dev Calculates the amount that has already vested but hasn't been released yet.
   * @param token ERC20 token which is being vested
   */
  function releasableAmount(IERC20 token) public view returns (uint256) {
    return vestedAmount(token).sub(_released[address(token)]);
  }

  /**
   * @dev Calculates the amount that has already vested.
   * @param token ERC20 token which is being vested
   */
  function vestedAmount(IERC20 token) public view returns (uint256) {
    uint256 currentBalance = token.balanceOf(address(this));
    uint256 totalBalance = currentBalance.add(_released[address(token)]);

    if (block.timestamp < _cliff) {
      return 0;
    } else if (block.timestamp >= _end || _revoked[address(token)]) {
      return totalBalance;
    } else {
      return totalBalance.mul(block.timestamp.sub(_start)).div(_duration);
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"beneficiary_","type":"address"},{"internalType":"uint256","name":"start_","type":"uint256"},{"internalType":"uint256","name":"cliff_","type":"uint256"},{"internalType":"uint256","name":"duration_","type":"uint256"},{"internalType":"bool","name":"revocable_","type":"bool"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"}],"name":"TokenVestingRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensReleased","type":"event"},{"inputs":[],"name":"beneficiary","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cliff","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"duration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"releasableAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revocable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"revoke","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"revoked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"start","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"vestedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

25305:5509:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29369:79;29433:9;;29369:79;;;5609:25:1;;;5597:2;5582:18;29369:79:0;;;;;;;;29227:73;29288:6;;29227:73;;30079:140;;;;;;:::i;:::-;;:::i;27814:351::-;;;;;;:::i;:::-;;:::i;:::-;;30350:461;;;;;;:::i;:::-;;:::i;28927:85::-;28994:12;;-1:-1:-1;;;;;28994:12:0;28927:85;;;-1:-1:-1;;;;;1496:32:1;;;1478:51;;1466:2;1451:18;28927:85:0;1433:102:1;9822:148:0;;;:::i;28380:482::-;;;;;;:::i;:::-;;:::i;29516:78::-;29578:10;;;;29516:78;;;1984:14:1;;1977:22;1959:41;;1947:2;1932:18;29516:78:0;1914:92:1;9171:87:0;9217:7;9244:6;-1:-1:-1;;;;;9244:6:0;9171:87;;29662:99;;;;;;:::i;:::-;-1:-1:-1;;;;;29739:16:0;29716:7;29739:16;;;:9;:16;;;;;;;29662:99;29083:73;29144:6;;29083:73;;10125:244;;;;;;:::i;:::-;;:::i;29825:94::-;;;;;;:::i;:::-;-1:-1:-1;;;;;29898:15:0;29878:4;29898:15;;;:8;:15;;;;;;;;;29825:94;30079:140;-1:-1:-1;;;;;30187:25:0;;30140:7;30187:25;;;:9;:25;;;;;;30163:50;;:19;30205:5;30163:12;:19::i;:::-;:23;;:50::i;:::-;30156:57;;30079:140;;;;:::o;27814:351::-;27861:18;27882:23;27899:5;27882:16;:23::i;:::-;27861:44;;27935:1;27922:10;:14;27914:58;;;;-1:-1:-1;;;27914:58:0;;3364:2:1;27914:58:0;;;3346:21:1;3403:2;3383:18;;;3376:30;3442:33;3422:18;;;3415:61;3493:18;;27914:58:0;;;;;;;;;-1:-1:-1;;;;;28009:25:0;;;;;;:9;:25;;;;;;:41;;28039:10;28009:29;:41::i;:::-;-1:-1:-1;;;;;27981:25:0;;;;;;;:9;:25;;;;;:69;;;;28078:12;;28059:44;;27981:25;28078:12;28092:10;28059:18;:44::i;:::-;28117:42;;;-1:-1:-1;;;;;1732:32:1;;1714:51;;1796:2;1781:18;;1774:34;;;28117:42:0;;1687:18:1;28117:42:0;;;;;;;27814:351;;:::o;30350:461::-;30448:30;;-1:-1:-1;;;30448:30:0;;30472:4;30448:30;;;1478:51:1;30407:7:0;;;;-1:-1:-1;;;;;30448:15:0;;;;;1451:18:1;;30448:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;30527:25:0;;30485:20;30527:25;;;:9;:25;;;;;;30423:55;;-1:-1:-1;30485:20:0;30508:45;;30423:55;;30508:18;:45::i;:::-;30485:68;;30584:6;;30566:15;:24;30562:244;;;30608:1;30601:8;;;;;;30562:244;30646:4;;30627:15;:23;;:51;;;-1:-1:-1;;;;;;30654:24:0;;;;;;:8;:24;;;;;;;;30627:51;30623:183;;;30696:12;-1:-1:-1;30689:19:0;;-1:-1:-1;30689:19:0;30623:183;30738:60;30788:9;;30738:45;30755:27;30775:6;;30755:15;:19;;:27;;;;:::i;:::-;30738:12;;:16;:45::i;:::-;:49;;:60::i;:::-;30731:67;;;;;;9822:148;9217:7;9244:6;-1:-1:-1;;;;;9244:6:0;7813:10;9391:23;9383:68;;;;-1:-1:-1;;;9383:68:0;;;;;;;:::i;:::-;9929:1:::1;9913:6:::0;;9892:40:::1;::::0;-1:-1:-1;;;;;9913:6:0;;::::1;::::0;9892:40:::1;::::0;9929:1;;9892:40:::1;9960:1;9943:19:::0;;-1:-1:-1;;;;;;9943:19:0::1;::::0;;9822:148::o;28380:482::-;9217:7;9244:6;-1:-1:-1;;;;;9244:6:0;7813:10;9391:23;9383:68;;;;-1:-1:-1;;;9383:68:0;;;;;;;:::i;:::-;28444:10:::1;::::0;::::1;;28436:50;;;::::0;-1:-1:-1;;;28436:50:0;;2601:2:1;28436:50:0::1;::::0;::::1;2583:21:1::0;2640:2;2620:18;;;2613:30;2679:29;2659:18;;;2652:57;2726:18;;28436:50:0::1;2573:177:1::0;28436:50:0::1;-1:-1:-1::0;;;;;28502:24:0;::::1;;::::0;;;:8:::1;:24;::::0;;;;;::::1;;28501:25;28493:73;;;::::0;-1:-1:-1;;;28493:73:0;;5261:2:1;28493:73:0::1;::::0;::::1;5243:21:1::0;5300:2;5280:18;;;5273:30;5339:34;5319:18;;;5312:62;-1:-1:-1;;;5390:18:1;;;5383:33;5433:19;;28493:73:0::1;5233:225:1::0;28493:73:0::1;28593:30;::::0;-1:-1:-1;;;28593:30:0;;28617:4:::1;28593:30;::::0;::::1;1478:51:1::0;28575:15:0::1;::::0;-1:-1:-1;;;;;28593:15:0;::::1;::::0;::::1;::::0;1451:18:1;;28593:30:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;28575:48;;28632:18;28653:23;28670:5;28653:16;:23::i;:::-;28632:44:::0;-1:-1:-1;28683:14:0::1;28700:23;:7:::0;28632:44;28700:11:::1;:23::i;:::-;-1:-1:-1::0;;;;;28732:24:0;::::1;;::::0;;;:8:::1;:24;::::0;;;;:31;;-1:-1:-1;;28732:31:0::1;28759:4;28732:31;::::0;;28683:40;-1:-1:-1;28772:35:0::1;28791:7;9217::::0;9244:6;-1:-1:-1;;;;;9244:6:0;9171:87;;28791:7:::1;-1:-1:-1::0;;;;;28772:18:0;::::1;::::0;28800:6;28772:18:::1;:35::i;:::-;28821;::::0;-1:-1:-1;;;;;1496:32:1;;1478:51;;28821:35:0::1;::::0;1466:2:1;1451:18;28821:35:0::1;;;;;;;9462:1;;;28380:482:::0;:::o;10125:244::-;9217:7;9244:6;-1:-1:-1;;;;;9244:6:0;7813:10;9391:23;9383:68;;;;-1:-1:-1;;;9383:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;10214:22:0;::::1;10206:73;;;::::0;-1:-1:-1;;;10206:73:0;;2957:2:1;10206:73:0::1;::::0;::::1;2939:21:1::0;2996:2;2976:18;;;2969:30;3035:34;3015:18;;;3008:62;-1:-1:-1;;;3086:18:1;;;3079:36;3132:19;;10206:73:0::1;2929:228:1::0;10206:73:0::1;10316:6;::::0;;10295:38:::1;::::0;-1:-1:-1;;;;;10295:38:0;;::::1;::::0;10316:6;::::1;::::0;10295:38:::1;::::0;::::1;10344:6;:17:::0;;-1:-1:-1;;;;;;10344:17:0::1;-1:-1:-1::0;;;;;10344:17:0;;;::::1;::::0;;;::::1;::::0;;10125:244::o;2823:98::-;2881:7;2908:5;2912:1;2908;:5;:::i;:::-;2901:12;2823:98;-1:-1:-1;;;2823:98:0:o;3204:::-;3262:7;3289:5;3293:1;3289;:5;:::i;21821:177::-;21931:58;;;-1:-1:-1;;;;;1732:32:1;;21931:58:0;;;1714:51:1;1781:18;;;;1774:34;;;21931:58:0;;;;;;;;;;1687:18:1;;;;21931:58:0;;;;;;;;-1:-1:-1;;;;;21931:58:0;-1:-1:-1;;;21931:58:0;;;21904:86;;21924:5;;21904:19;:86::i;:::-;21821:177;;;:::o;3561:98::-;3619:7;3646:5;3650:1;3646;:5;:::i;3960:98::-;4018:7;4045:5;4049:1;4045;:5;:::i;24255:761::-;24679:23;24705:69;24733:4;24705:69;;;;;;;;;;;;;;;;;24713:5;-1:-1:-1;;;;;24705:27:0;;;:69;;;;;:::i;:::-;24789:17;;24679:95;;-1:-1:-1;24789:21:0;24785:224;;24931:10;24920:30;;;;;;;;;;;;:::i;:::-;24912:85;;;;-1:-1:-1;;;24912:85:0;;4850:2:1;24912:85:0;;;4832:21:1;4889:2;4869:18;;;4862:30;4928:34;4908:18;;;4901:62;-1:-1:-1;;;4979:18:1;;;4972:40;5029:19;;24912:85:0;4822:232:1;14056:195:0;14159:12;14191:52;14213:6;14221:4;14227:1;14230:12;14191:21;:52::i;:::-;14184:59;14056:195;-1:-1:-1;;;;14056:195:0:o;15108:530::-;15235:12;15293:5;15268:21;:30;;15260:81;;;;-1:-1:-1;;;15260:81:0;;3724:2:1;15260:81:0;;;3706:21:1;3763:2;3743:18;;;3736:30;3802:34;3782:18;;;3775:62;-1:-1:-1;;;3853:18:1;;;3846:36;3899:19;;15260:81:0;3696:228:1;15260:81:0;11505:20;;15352:60;;;;-1:-1:-1;;;15352:60:0;;4492:2:1;15352:60:0;;;4474:21:1;4531:2;4511:18;;;4504:30;4570:31;4550:18;;;4543:59;4619:18;;15352:60:0;4464:179:1;15352:60:0;15486:12;15500:23;15527:6;-1:-1:-1;;;;;15527:11:0;15547:5;15555:4;15527:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15485:75;;;;15578:52;15596:7;15605:10;15617:12;15578:17;:52::i;:::-;15571:59;15108:530;-1:-1:-1;;;;;;;15108:530:0:o;17648:742::-;17763:12;17792:7;17788:595;;;-1:-1:-1;17823:10:0;17816:17;;17788:595;17937:17;;:21;17933:439;;18200:10;18194:17;18261:15;18248:10;18244:2;18240:19;18233:44;18148:148;18343:12;18336:20;;-1:-1:-1;;;18336:20:0;;;;;;;;:::i;14:257:1:-;;126:2;114:9;105:7;101:23;97:32;94:2;;;147:6;139;132:22;94:2;191:9;178:23;210:31;235:5;210:31;:::i;276:297::-;;396:2;384:9;375:7;371:23;367:32;364:2;;;417:6;409;402:22;364:2;454:9;448:16;507:5;500:13;493:21;486:5;483:32;473:2;;534:6;526;519:22;854:194;;977:2;965:9;956:7;952:23;948:32;945:2;;;998:6;990;983:22;945:2;-1:-1:-1;1026:16:1;;935:113;-1:-1:-1;935:113:1:o;1053:274::-;;1220:6;1214:13;1236:53;1282:6;1277:3;1270:4;1262:6;1258:17;1236:53;:::i;:::-;1305:16;;;;;1190:137;-1:-1:-1;;1190:137:1:o;2011:383::-;;2160:2;2149:9;2142:21;2192:6;2186:13;2235:6;2230:2;2219:9;2215:18;2208:34;2251:66;2310:6;2305:2;2294:9;2290:18;2285:2;2277:6;2273:15;2251:66;:::i;:::-;2378:2;2357:15;-1:-1:-1;;2353:29:1;2338:45;;;;2385:2;2334:54;;2132:262;-1:-1:-1;;2132:262:1:o;3929:356::-;4131:2;4113:21;;;4150:18;;;4143:30;4209:34;4204:2;4189:18;;4182:62;4276:2;4261:18;;4103:182::o;5645:128::-;;5716:1;5712:6;5709:1;5706:13;5703:2;;;5722:18;;:::i;:::-;-1:-1:-1;5758:9:1;;5693:80::o;5778:217::-;;5844:1;5834:2;;-1:-1:-1;;;5869:31:1;;5923:4;5920:1;5913:15;5951:4;5876:1;5941:15;5834:2;-1:-1:-1;5980:9:1;;5824:171::o;6000:168::-;;6106:1;6102;6098:6;6094:14;6091:1;6088:21;6083:1;6076:9;6069:17;6065:45;6062:2;;;6113:18;;:::i;:::-;-1:-1:-1;6153:9:1;;6052:116::o;6173:125::-;;6241:1;6238;6235:8;6232:2;;;6246:18;;:::i;:::-;-1:-1:-1;6283:9:1;;6222:76::o;6303:258::-;6375:1;6385:113;6399:6;6396:1;6393:13;6385:113;;;6475:11;;;6469:18;6456:11;;;6449:39;6421:2;6414:10;6385:113;;;6516:6;6513:1;6510:13;6507:2;;;6551:1;6542:6;6537:3;6533:16;6526:27;6507:2;;6356:205;;;:::o;6566:127::-;6627:10;6622:3;6618:20;6615:1;6608:31;6658:4;6655:1;6648:15;6682:4;6679:1;6672:15;6698:131;-1:-1:-1;;;;;6773:31:1;;6763:42;;6753:2;;6819:1;6816;6809:12;6753:2;6743:86;:::o

ipfs://156cc3812f018a5443e642e4c5c9f7ed459b5a446e6b14227835c64f3ae34ce5