Contract

// SPDX-License-Identifier: AGPLv3
pragma solidity 0.8.4;

import "./GROBaseVester.sol";

/// @notice Vesting contract for investors in gro protocol - Can create vesting positiong that
///     cannot be stopped or removed. All investors vesting position has a fixed start time at
///     1632844845, when the first LBP transaction occured. The number of investors is already fixed
///     and no additional investors can be added to this contract. It is not possible for any investors
///     to claim their tokens before the one year cliff has expired, after which they will have access
///     to 1/3 of their tokens, the remaining will vest over the remaining vesting period.
contract GROInvVesting is GROBaseVesting {

    struct InvestorPosition {
        uint256 total;
        uint256 withdrawn;
        uint256 startTime;
    }

    mapping(address => InvestorPosition) public investorPositions;
    // Start time for the main vesting pool
    uint256 public constant START_TIME = 1632844845;

    event LogNewVest(address indexed investor, uint256 amount);
    event LogClaimed(address indexed investor, uint256 amount, uint256 withdrawn, uint256 available);

    constructor(uint256 quota) GROBaseVesting(START_TIME, quota) {}

    /// @notice Create or modify a vesting position
    /// @param account Account which to add vesting position for
    /// @param startTime irrelevant for investor vesting, they all start at the same timestamp
    /// @param amount Amount to add to vesting position
    function vest(address account, uint256 startTime, uint256 amount) external override onlyOwner {
        require(account != address(0), "vest: !account");
        require(amount > 0, "vest: !amount");

        InvestorPosition storage ep = investorPositions[account];

        require(ep.startTime == 0, 'vest: position already exists');
        ep.startTime = START_TIME;
        require((QUOTA - vestingAssets) >= amount, 'vest: not enough assets available');
        ep.total = amount;
        vestingAssets += amount;

        emit LogNewVest(account, amount);
    }

    /// @notice Claim an amount of tokens
    /// @param amount amount to be claimed
    function claim(uint256 amount) external override {
        require(amount > 0, "claim: No amount specified");
        (uint256 unlocked, uint256 available, , ) = unlockedBalance(msg.sender);
        require(available >= amount, "claim: Not enough user assets available");

        uint256 _withdrawn = unlocked - available + amount;

        InvestorPosition storage ep = investorPositions[msg.sender];
        ep.withdrawn = _withdrawn;
        distributer.mint(msg.sender, amount);
        emit LogClaimed(msg.sender, amount, _withdrawn, available - amount);
    }

    /// @notice See the amount of vested assets the account has accumulated
    /// @param account Account to get vested amount for
    function unlockedBalance(address account)
        internal
        view
        override
        returns ( uint256, uint256, uint256, uint256 )
    {
        InvestorPosition storage ep = investorPositions[account];
        uint256 startTime = ep.startTime;
        if (block.timestamp < startTime + VESTING_CLIFF) {
            return (0, 0, startTime, startTime + VESTING_TIME);
        }
        uint256 unlocked;
        uint256 available;
        uint256 _endTime = startTime + VESTING_TIME;
        if (block.timestamp < _endTime) {
            unlocked = ep.total * (block.timestamp - startTime) / VESTING_TIME;
        } else {
            unlocked = ep.total;
        }
        available = unlocked - ep.withdrawn;
        return (unlocked, available, startTime, _endTime);
    }

    /// @notice Get total size of position, vested + vesting
    /// @param account Target account
    function totalBalance(address account) external view override returns (uint256 balance) {
        InvestorPosition storage ep = investorPositions[account];
        balance = ep.total;
    }
}

// SPDX-License-Identifier: AGPLv3
pragma solidity 0.8.4;

import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

interface IMintable {
    function mint(address _receiver, uint256 _amount) external;
    function mintDao(address _receiver, uint256 _amount, bool community) external;
}

abstract contract GROBaseVesting is Ownable {
    using SafeERC20 for IERC20;

    uint256 internal constant ONE_YEAR_SECONDS = 31556952; // average year (including leap years) in seconds
    uint256 internal constant START_TIME_LOWER_BOUND = 604800 * 3; // 3 Weeks
    uint256 internal constant VESTING_TIME = ONE_YEAR_SECONDS * 3; // 3 years period
    uint256 internal constant VESTING_CLIFF = ONE_YEAR_SECONDS; // 1 years period
    uint256 public constant PERCENTAGE_DECIMAL_FACTOR = 10000; // BP
    uint256 public immutable QUOTA;
    uint256 public immutable VESTING_START_TIME;

    uint256 public vestingAssets;

    IMintable public distributer;

    event LogNewDistributer(address indexed distributer);

    constructor(uint256 startTime, uint256 quota) {
        VESTING_START_TIME = startTime;
        QUOTA = quota;
    }

    function setDistributer(address _distributer) external onlyOwner {
        distributer = IMintable(_distributer);
        emit LogNewDistributer(_distributer);
    }

    /// @notice Create or modify a vesting position
    function vest(address account, uint256 startDate, uint256 amount) external virtual;

    /// @notice Claim an amount of tokens
    function claim(uint256 amount) external virtual;

    /// @notice See the amount of vested assets the account has accumulated
    /// @param account Account to get vested amount for
    function unlockedBalance(address account)
        internal
        view
        virtual
        returns ( uint256, uint256, uint256, uint256 );

    /// @notice How much of the quota is unlocked, vesting and available
    function globallyUnlocked() public view virtual returns (uint256 unlocked, uint256 vesting, uint256 available) {
        if (block.timestamp > VESTING_START_TIME + VESTING_TIME) {
            unlocked = QUOTA;
        } else {
            unlocked = (QUOTA) * (block.timestamp - VESTING_START_TIME) / (VESTING_TIME);
        }
        vesting = vestingAssets;
        available = unlocked - vesting;
    }

    /// @notice Get total size of position, vested + vesting
    /// @param account Target account
    function totalBalance(address account) external view virtual returns (uint256 unvested);

    /// @notice Get current vested position
    /// @param account Target account
    function vestedBalance(address account) external view returns (uint256 vested, uint256 available) {
        (vested, available, , ) = unlockedBalance(account);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

// SPDX-License-Identifier: MIT

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

// SPDX-License-Identifier: MIT

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

        (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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../utils/Context.sol";

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT

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) {
        return msg.data;
    }
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"quota","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"investor","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"withdrawn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"available","type":"uint256"}],"name":"LogClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"distributer","type":"address"}],"name":"LogNewDistributer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"investor","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LogNewVest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"PERCENTAGE_DECIMAL_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"QUOTA","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"START_TIME","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VESTING_START_TIME","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"distributer","outputs":[{"internalType":"contract IMintable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"globallyUnlocked","outputs":[{"internalType":"uint256","name":"unlocked","type":"uint256"},{"internalType":"uint256","name":"vesting","type":"uint256"},{"internalType":"uint256","name":"available","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"investorPositions","outputs":[{"internalType":"uint256","name":"total","type":"uint256"},{"internalType":"uint256","name":"withdrawn","type":"uint256"},{"internalType":"uint256","name":"startTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_distributer","type":"address"}],"name":"setDistributer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"totalBalance","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"vest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"vestedBalance","outputs":[{"internalType":"uint256","name":"vested","type":"uint256"},{"internalType":"uint256","name":"available","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000000000000000000000101f4a4bdb9d4b59a40000

-----Decoded View---------------
Arg [0] : quota (uint256): 19490577000000000000000000

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000000000000000000000101f4a4bdb9d4b59a40000

679:3279:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1510:569;;;;;;:::i;:::-;;:::i;:::-;;2170:566;;;;;;:::i;:::-;;:::i;841:61::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5249:25:7;;;5305:2;5290:18;;5283:34;;;;5333:18;;;5326:34;5237:2;5222:18;841:61:1;;;;;;;;893:43:0;;;;;;;;4758:25:7;;;4746:2;4731:18;893:43:0;4713:76:7;3767:189:1;;;;;;:::i;:::-;-1:-1:-1;;;;;3895:26:1;3838:15;3895:26;;;:17;:26;;;;;3941:8;;3767:189;1605:92:2;;;:::i;973:85::-;1019:7;1045:6;-1:-1:-1;;;;;1045:6:2;973:85;;;-1:-1:-1;;;;;1089:32:7;;;1071:51;;1059:2;1044:18;973:85:2;1026:102:7;2642:165:0;;;;;;:::i;:::-;;:::i;:::-;;;;4968:25:7;;;5024:2;5009:18;;5002:34;;;;4941:18;2642:165:0;4923:119:7;1956:405:0;;;:::i;857:30::-;;;;;978:28;;;;;-1:-1:-1;;;;;978:28:0;;;788:57;;840:5;788:57;;952:47:1;;989:10;952:47;;943:28:0;;;;;;1194:165;;;;;;:::i;:::-;;:::i;1846:189:2:-;;;;;;:::i;:::-;;:::i;1510:569:1:-;1019:7:2;1045:6;-1:-1:-1;;;;;1045:6:2;666:10:6;1185:23:2;1177:68;;;;-1:-1:-1;;;1177:68:2;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;1622:21:1;::::1;1614:48;;;::::0;-1:-1:-1;;;1614:48:1;;2245:2:7;1614:48:1::1;::::0;::::1;2227:21:7::0;2284:2;2264:18;;;2257:30;-1:-1:-1;;;2303:18:7;;;2296:44;2357:18;;1614:48:1::1;2217:164:7::0;1614:48:1::1;1689:1;1680:6;:10;1672:36;;;::::0;-1:-1:-1;;;1672:36:1;;3398:2:7;1672:36:1::1;::::0;::::1;3380:21:7::0;3437:2;3417:18;;;3410:30;-1:-1:-1;;;3456:18:7;;;3449:43;3509:18;;1672:36:1::1;3370:163:7::0;1672:36:1::1;-1:-1:-1::0;;;;;1749:26:1;::::1;1719:27;1749:26:::0;;;:17:::1;:26;::::0;;;;1794:12:::1;::::0;::::1;::::0;:17;1786:59:::1;;;::::0;-1:-1:-1;;;1786:59:1;;4456:2:7;1786:59:1::1;::::0;::::1;4438:21:7::0;4495:2;4475:18;;;4468:30;4534:31;4514:18;;;4507:59;4583:18;;1786:59:1::1;4428:179:7::0;1786:59:1::1;989:10;1855:12;::::0;::::1;:25:::0;1907:13:::1;::::0;1925:6;;1899:21:::1;::::0;:5:::1;:21;:::i;:::-;1898:33;;1890:79;;;::::0;-1:-1:-1;;;1890:79:1;;2996:2:7;1890:79:1::1;::::0;::::1;2978:21:7::0;3035:2;3015:18;;;3008:30;3074:34;3054:18;;;3047:62;-1:-1:-1;;;3125:18:7;;;3118:31;3166:19;;1890:79:1::1;2968:223:7::0;1890:79:1::1;1979:17:::0;;;2006:13:::1;:23:::0;;1990:6;;2006:13;1979:8:::1;::::0;2006:23:::1;::::0;1990:6;;2006:23:::1;:::i;:::-;::::0;;;-1:-1:-1;;2045:27:1::1;::::0;4758:25:7;;;-1:-1:-1;;;;;2045:27:1;::::1;::::0;::::1;::::0;4746:2:7;4731:18;2045:27:1::1;;;;;;;1255:1:2;1510:569:1::0;;;:::o;2170:566::-;2246:1;2237:6;:10;2229:49;;;;-1:-1:-1;;;2229:49:1;;3740:2:7;2229:49:1;;;3722:21:7;3779:2;3759:18;;;3752:30;3818:28;3798:18;;;3791:56;3864:18;;2229:49:1;3712:176:7;2229:49:1;2289:16;2307:17;2332:27;2348:10;2332:15;:27::i;:::-;2288:71;;;;;;2390:6;2377:9;:19;;2369:71;;;;-1:-1:-1;;;2369:71:1;;2588:2:7;2369:71:1;;;2570:21:7;2627:2;2607:18;;;2600:30;2666:34;2646:18;;;2639:62;-1:-1:-1;;;2717:18:7;;;2710:37;2764:19;;2369:71:1;2560:229:7;2369:71:1;2451:18;2495:6;2472:20;2483:9;2472:8;:20;:::i;:::-;:29;;;;:::i;:::-;2560:10;2512:27;2542:29;;;:17;:29;;;;;;;2581:12;;;:25;;;2616:11;;:36;;-1:-1:-1;;;2616:36:1;;;;;1307:51:7;;;;1374:18;;;1367:34;;;2581:25:1;;-1:-1:-1;;;;;;2616:11:1;;:16;;1280:18:7;;2616:36:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2678:10:1;;-1:-1:-1;2667:62:1;;-1:-1:-1;2690:6:1;;-1:-1:-1;2698:10:1;2710:18;2690:6;2710:9;:18;:::i;:::-;2667:62;;;5249:25:7;;;5305:2;5290:18;;5283:34;;;;5333:18;;;5326:34;5237:2;5222:18;2667:62:1;;;;;;;2170:566;;;;;:::o;1605:92:2:-;1019:7;1045:6;-1:-1:-1;;;;;1045:6:2;666:10:6;1185:23:2;1177:68;;;;-1:-1:-1;;;1177:68:2;;;;;;;:::i;:::-;1669:21:::1;1687:1;1669:9;:21::i;:::-;1605:92::o:0;2642:165:0:-;2705:14;2721:17;2776:24;2792:7;2776:15;:24::i;:::-;-1:-1:-1;2750:50:0;;;;-1:-1:-1;2642:165:0;-1:-1:-1;;;2642:165:0:o;1956:405::-;2013:16;;;662:20;479:8;681:1;662:20;:::i;:::-;2099:33;;:18;:33;:::i;:::-;2081:15;:51;2077:205;;;2159:5;2148:16;;2077:205;;;662:20;479:8;681:1;662:20;:::i;:::-;2217:36;2235:18;2217:15;:36;:::i;:::-;2206:48;;2207:5;2206:48;:::i;:::-;:65;;;;:::i;:::-;2195:76;;2077:205;2301:13;;;-1:-1:-1;2336:18:0;2301:13;2336:8;:18;:::i;:::-;2324:30;;1956:405;;;:::o;1194:165::-;1019:7:2;1045:6;-1:-1:-1;;;;;1045:6:2;666:10:6;1185:23:2;1177:68;;;;-1:-1:-1;;;1177:68:2;;;;;;;:::i;:::-;1269:11:0::1;:37:::0;;-1:-1:-1;;;;;;1269:37:0::1;-1:-1:-1::0;;;;;1269:37:0;::::1;::::0;;::::1;::::0;;;1321:31:::1;::::0;::::1;::::0;-1:-1:-1;;1321:31:0::1;1194:165:::0;:::o;1846:189:2:-;1019:7;1045:6;-1:-1:-1;;;;;1045:6:2;666:10:6;1185:23:2;1177:68;;;;-1:-1:-1;;;1177:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;1934:22:2;::::1;1926:73;;;::::0;-1:-1:-1;;;1926:73:2;;1838:2:7;1926:73:2::1;::::0;::::1;1820:21:7::0;1877:2;1857:18;;;1850:30;1916:34;1896:18;;;1889:62;-1:-1:-1;;;1967:18:7;;;1960:36;2013:19;;1926:73:2::1;1810:228:7::0;1926:73:2::1;2009:19;2019:8;2009:9;:19::i;:::-;1846:189:::0;:::o;2874:788:1:-;-1:-1:-1;;;;;3062:26:1;;2981:7;3062:26;;;:17;:26;;;;;3118:12;;;;2981:7;;;;;;3062:26;3162:25;479:8:0;3118:12:1;3162:25;:::i;:::-;3144:15;:43;3140:124;;;3211:1;;3217:9;662:20:0;479:8;681:1;662:20;:::i;:::-;3228:24:1;;:9;:24;:::i;:::-;3203:50;;;;;;;;;;;;3140:124;3273:16;;;662:20:0;479:8;681:1;662:20;:::i;:::-;3345:24:1;;:9;:24;:::i;:::-;3326:43;;3401:8;3383:15;:26;3379:173;;;662:20:0;479:8;681:1;662:20;:::i;:::-;3448:27:1;3466:9;3448:15;:27;:::i;:::-;3436:8;;:40;;;;:::i;:::-;:55;;;;:::i;:::-;3425:66;;3379:173;;;3533:8;;;-1:-1:-1;3379:173:1;3584:12;;;;3573:23;;:8;:23;:::i;:::-;3614:8;;-1:-1:-1;3561:35:1;;-1:-1:-1;3635:9:1;;-1:-1:-1;3646:8:1;-1:-1:-1;;;2874:788:1;;;;;;:::o;2041:169:2:-;2096:16;2115:6;;-1:-1:-1;;;;;2131:17:2;;;-1:-1:-1;;;;;;2131:17:2;;;;;;2163:40;;2115:6;;;;;;;2163:40;;2096:16;2163:40;2041:169;;:::o;14:173:7:-;82:20;;-1:-1:-1;;;;;131:31:7;;121:42;;111:2;;177:1;174;167:12;111:2;63:124;;;:::o;192:196::-;251:6;304:2;292:9;283:7;279:23;275:32;272:2;;;325:6;317;310:22;272:2;353:29;372:9;353:29;:::i;:::-;343:39;262:126;-1:-1:-1;;;262:126:7:o;393:332::-;470:6;478;486;539:2;527:9;518:7;514:23;510:32;507:2;;;560:6;552;545:22;507:2;588:29;607:9;588:29;:::i;:::-;578:39;664:2;649:18;;636:32;;-1:-1:-1;715:2:7;700:18;;;687:32;;497:228;-1:-1:-1;;;497:228:7:o;730:190::-;789:6;842:2;830:9;821:7;817:23;813:32;810:2;;;863:6;855;848:22;810:2;-1:-1:-1;891:23:7;;800:120;-1:-1:-1;800:120:7:o;3893:356::-;4095:2;4077:21;;;4114:18;;;4107:30;4173:34;4168:2;4153:18;;4146:62;4240:2;4225:18;;4067:182::o;5371:128::-;5411:3;5442:1;5438:6;5435:1;5432:13;5429:2;;;5448:18;;:::i;:::-;-1:-1:-1;5484:9:7;;5419:80::o;5504:217::-;5544:1;5570;5560:2;;-1:-1:-1;;;5595:31:7;;5649:4;5646:1;5639:15;5677:4;5602:1;5667:15;5560:2;-1:-1:-1;5706:9:7;;5550:171::o;5726:168::-;5766:7;5832:1;5828;5824:6;5820:14;5817:1;5814:21;5809:1;5802:9;5795:17;5791:45;5788:2;;;5839:18;;:::i;:::-;-1:-1:-1;5879:9:7;;5778:116::o;5899:125::-;5939:4;5967:1;5964;5961:8;5958:2;;;5972:18;;:::i;:::-;-1:-1:-1;6009:9:7;;5948:76::o;6029:127::-;6090:10;6085:3;6081:20;6078:1;6071:31;6121:4;6118:1;6111:15;6145:4;6142:1;6135:15

ipfs://a55a4cad686c1d8854358a393b7ac4874d6ecc5da150d1657240c30f71a13c14