Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";

import "./interfaces/ITokenLockup.sol";

contract TokenLockup is Ownable, ITokenLockup {
    address public token;

    uint256 public startTime;
    uint256 public claimDelay;
    Schedule[] public schedule;

    mapping(address => uint256) public initialLocked;
    mapping(address => uint256) public totalClaimed;

    uint256 public initialLockedSupply;
    uint256 public unallocatedSupply;

    uint256 private constant INVERSE_BASIS_POINTS = 10_000;

    constructor(
        address _token,
        uint256 _startTime,
        uint256 _claimDelay,
        Schedule[] memory _schedule
    ) {
        require(_startTime >= block.timestamp, 'Invalid startTime');

        token = _token;
        startTime = _startTime;
        claimDelay = _claimDelay;

        uint256 scheduleLength = _schedule.length;
        uint256 totalPortion;
        for (uint256 i; i < scheduleLength; i++) {
            totalPortion += _schedule[i].portion;
            if (i != 0) {
                require(_schedule[i-1].endTime < _schedule[i].endTime, 'Invalid schedule times');
            }
            schedule.push(_schedule[i]);
        }
        require(totalPortion == INVERSE_BASIS_POINTS, 'Invalid schedule portions');
    }

    /**
     * @notice Transfers and locks unallocated tokens in escrow from msg.sender
     * @param amount Amount of tokens to lock in escrow
     */
    function addTokens(uint256 amount) external onlyOwner {
        require(IERC20(token).transferFrom(msg.sender, address(this), amount));
        unallocatedSupply += amount;
    }

    /**
     * @notice Distributes unallocated tokens to recipients
     * @param recipients List of addresses to distribute tokens to
     * @param amounts List of token amounts to distribute to recipient at respective index
     */
    function fund(address[] calldata recipients, uint256[] calldata amounts)
        external
        onlyOwner
    {
        require(recipients.length == amounts.length);
        uint256 _totalAmount = 0;
        for (uint i; i < amounts.length; ++i) {
            uint256 amount = amounts[i];
            address recipient = recipients[i];
            if (recipient == address(0)) {
                break;
            }
            _totalAmount += amount;
            initialLocked[recipient] += amount;
            emit Fund(recipient, amount);
        }
        initialLockedSupply += _totalAmount;
        unallocatedSupply -= _totalAmount;
    }

    /**
     * @notice Retrieves unclaimed unlocked tokens for msg.sender
     */
    function claim() external {
        require(block.timestamp > startTime + claimDelay, "Claiming is not available yet");

        uint256 claimable = _totalUnlockedOf(msg.sender) - totalClaimed[msg.sender];
        totalClaimed[msg.sender] += claimable;
        require(IERC20(token).transfer(msg.sender, claimable));

        emit Claim(msg.sender, claimable);
    }

    /**
     * @notice Changes the recipient of msg.sender funds
     * @param newRecipient New address to transfer the locked funds to
     */
    function changeRecipient(address newRecipient) external {
        require(newRecipient != msg.sender, "newRecipient must not be msg.sender");
        uint256 _initialLocked = initialLocked[msg.sender];
        uint256 _totalClaimed = totalClaimed[msg.sender];
        initialLocked[msg.sender] = 0;
        totalClaimed[msg.sender] = 0;
        initialLocked[newRecipient] += _initialLocked;
        totalClaimed[newRecipient] += _totalClaimed;

        emit ChangeRecipient(msg.sender, newRecipient);
    }

    /**
     * @notice Returns unclaimed unlocked balance for account
     * @param account Address to check balance of
     * @return Unclaimed unlocked balance
     */
    function balanceOf(address account) external view returns (uint256) {
        return _totalUnlockedOf(account) - totalClaimed[account];
    }

    /**
     * @notice Returns unlocked balance for account
     * @param account Address to check unlocked balance of
     * @return Unlocked balance
     */
    function unlockedOf(address account) external view returns (uint256) {
        return _totalUnlockedOf(account);
    }

    /**
     * @notice Returns locked balance for account
     * @param account Address to check unlocked balance of
     * @return Locked balance
     */
    function lockedOf(address account) external view returns (uint256) {
        return initialLocked[account] - _totalUnlockedOf(account);
    }

    /**
     * @notice Returns total unlocked supply
     * @return Total unlocked supply
     */
    function unlockedSupply() external view returns (uint256) {
        return _totalUnlocked();
    }

    /**
     * @notice Returns total supply that has not unlocked
     * @return Total locked supply
     */
    function lockedSupply() external view returns (uint256) {
        return initialLockedSupply - _totalUnlocked();
    }

    /**
     * @notice Returns unlocked balance for account at specified time
     * @param account Address to check unlocked balance of
     * @return Unlocked balance
     */
    function _totalUnlockedOf(address account) internal view returns (uint256) {
        uint256 locked = initialLocked[account];
        return _computeUnlocked(locked, block.timestamp);
    }

    /**
     * @notice Returns total unlocked supply
     * @return Total unlocked supply
     */
    function _totalUnlocked() internal view returns (uint256) {
        uint256 locked = initialLockedSupply;
        return _computeUnlocked(locked, block.timestamp);
    }

    /**
     * @notice Compute and return amount of initial locked tokens that have unlocked based on schedule
     * @param locked Initial locked tokens
     * @param time Time to check unlocked balance at
     * @return Amount of locked tokens that have unlocked
     */
    function _computeUnlocked(uint256 locked, uint256 time) internal view returns (uint256) {
        uint256 start = startTime;
        if (time < start) {
            return 0;
        }
        uint256 unlocked;
        uint256 scheduleLength = schedule.length;
        for (uint i; i < scheduleLength; i++) {
            uint256 portion = schedule[i].portion;
            uint256 end = schedule[i].endTime;
            if (time < end) {
                unlocked += locked * (time - start) * portion / ((end - start) * INVERSE_BASIS_POINTS);
                break;
            } else {
                unlocked += locked * portion / INVERSE_BASIS_POINTS;
                start = end;
            }
        }
        return unlocked;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

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() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        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 {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @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.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

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

interface ITokenLockup {

    struct Schedule {
        uint256 endTime;
        uint256 portion;
    }

    event Fund(
      address indexed recipient,
      uint256 amount
    );

    event Claim(
      address indexed recipient,
      uint256 claimed
    );
    event Reclaim(
      address indexed recipient,
      uint256 claimed
    );

    event ChangeRecipient(
      address indexed oldRecipient,
      address indexed newRecipient
    );

    function token() external view returns (address);

    function startTime() external view returns (uint256);
    function claimDelay() external view returns (uint256);
    function schedule(uint256 index) external view returns (uint256, uint256);

    function initialLocked(address account) external view returns (uint256);
    function totalClaimed(address account) external view returns (uint256);

    function initialLockedSupply() external view returns (uint256);
    function unallocatedSupply() external view returns (uint256);

    function addTokens(uint256 amount) external;
    function fund(address[] calldata recipients, uint256[] calldata amounts) external;

    function claim() external;
    function changeRecipient(address newRecipient) external;

    function unlockedSupply() external view returns (uint256);
    function lockedSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);
    function unlockedOf(address account) external view returns (uint256);
    function lockedOf(address account) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (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) {
        return msg.data;
    }
}

{
  "metadata": {
    "bytecodeHash": "none"
  },
  "optimizer": {
    "enabled": true,
    "runs": 800
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_startTime","type":"uint256"},{"internalType":"uint256","name":"_claimDelay","type":"uint256"},{"components":[{"internalType":"uint256","name":"endTime","type":"uint256"},{"internalType":"uint256","name":"portion","type":"uint256"}],"internalType":"struct ITokenLockup.Schedule[]","name":"_schedule","type":"tuple[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldRecipient","type":"address"},{"indexed":true,"internalType":"address","name":"newRecipient","type":"address"}],"name":"ChangeRecipient","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"claimed","type":"uint256"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Fund","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"claimed","type":"uint256"}],"name":"Reclaim","type":"event"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"addTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newRecipient","type":"address"}],"name":"changeRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimDelay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"fund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"initialLocked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialLockedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"lockedOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockedSupply","outputs":[{"internalType":"uint256","name":"","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":"uint256","name":"","type":"uint256"}],"name":"schedule","outputs":[{"internalType":"uint256","name":"endTime","type":"uint256"},{"internalType":"uint256","name":"portion","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"totalClaimed","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":[],"name":"unallocatedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"unlockedOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unlockedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000005283d291dbcf85356a21ba090e6db59121208b440000000000000000000000000000000000000000000000000000000063ebbe1000000000000000000000000000000000000000000000000000000000009e3400000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000065ccf1900000000000000000000000000000000000000000000000000000000000000fa00000000000000000000000000000000000000000000000000000000067ae25100000000000000000000000000000000000000000000000000000000000000bb800000000000000000000000000000000000000000000000000000000698f589000000000000000000000000000000000000000000000000000000000000007d0000000000000000000000000000000000000000000000000000000006b708c1000000000000000000000000000000000000000000000000000000000000003e8

-----Decoded View---------------
Arg [0] : _token (address): 0x5283D291DBCF85356A21bA090E6db59121208b44
Arg [1] : _startTime (uint256): 1676394000
Arg [2] : _claimDelay (uint256): 10368000
Arg [3] : _schedule (tuple[]): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput],System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput],System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput],System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]

-----Encoded View---------------
13 Constructor Arguments found :
Arg [0] : 0000000000000000000000005283d291dbcf85356a21ba090e6db59121208b44
Arg [1] : 0000000000000000000000000000000000000000000000000000000063ebbe10
Arg [2] : 00000000000000000000000000000000000000000000000000000000009e3400
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [5] : 0000000000000000000000000000000000000000000000000000000065ccf190
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000fa0
Arg [7] : 0000000000000000000000000000000000000000000000000000000067ae2510
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000bb8
Arg [9] : 00000000000000000000000000000000000000000000000000000000698f5890
Arg [10] : 00000000000000000000000000000000000000000000000000000000000007d0
Arg [11] : 000000000000000000000000000000000000000000000000000000006b708c10
Arg [12] : 00000000000000000000000000000000000000000000000000000000000003e8