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.0;

import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./BokkyPooBahsDateTimeLibrary.sol";
// import "hardhat/console.sol";

contract UnmarshalTokenVesting is Ownable {
    using SafeMath for uint256;
    using BokkyPooBahsDateTimeLibrary for uint256;
    using SafeERC20 for IERC20;

    event DistributionAdded(address indexed investor, address indexed caller, uint256 allocation);

    event WithdrawnTokens(address indexed investor, uint256 value);

    event RecoverToken(address indexed token, uint256 indexed amount);

    enum DistributionType { STAKING, ECOSYSTEM, MARKETING, RESERVES, TEAM }

    uint256 private _initialTimestamp;
    IERC20 private _marshToken;

    struct Distribution {
        address beneficiary;
        uint256 withdrawnTokens;
        uint256 tokensAllotment;
        DistributionType distributionType;
    }

    mapping(DistributionType => Distribution) public distributionInfo;

    /// @dev Boolean variable that indicates whether the contract was initialized.
    bool public isInitialized = false;

    uint256 constant _SCALING_FACTOR = 10**18; // decimals

    uint256[] ecosystemVesting = [
        10000000000000000000,
        12500000000000000000,
        15000000000000000000,
        17500000000000000000,
        20000000000000000000,
        22500000000000000000,
        25000000000000000000,
        27500000000000000000,
        30000000000000000000,
        32500000000000000000,
        35000000000000000000,
        37500000000000000000,
        40000000000000000000,
        42500000000000000000,
        45000000000000000000,
        47500000000000000000,
        50000000000000000000,
        52500000000000000000,
        55000000000000000000,
        57500000000000000000,
        60000000000000000000,
        62500000000000000000,
        65000000000000000000,
        67500000000000000000,
        70000000000000000000,
        72500000000000000000,
        75000000000000000000,
        77500000000000000000,
        80000000000000000000,
        82500000000000000000,
        85000000000000000000,
        87500000000000000000,
        90000000000000000000,
        92500000000000000000,
        95000000000000000000,
        97500000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000
    ];

    uint256[] marketingReserveVesting = [
        5000000000000000000,
        8958333333000000000,
        12916666666000000000,
        16874999999000000000,
        20833333332000000000,
        24791666665000000000,
        28749999998000000000,
        32708333331000000000,
        36666666664000000000,
        40624999997000000000,
        44583333330000000000,
        48541666663000000000,
        52499999996000000000,
        56458333329000000000,
        60416666662000000000,
        64374999995000000000,
        68333333328000000000,
        72291666661000000000,
        76249999994000000000,
        80208333327000000000,
        84166666660000000000,
        88124999993000000000,
        92083333326000000000,
        96041666659000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000,
        100000000000000000000
    ];

    /// @dev Checks that the contract is initialized.
    modifier initialized() {
        require(isInitialized, "not initialized");
        _;
    }

    /// @dev Checks that the contract is initialized.
    modifier notInitialized() {
        require(!isInitialized, "initialized");
        _;
    }

    constructor(
        address _token,
        address _treasury
    ) {
        require(address(_token) != address(0x0), "Marsh token address is not valid");
        _marshToken = IERC20(_token);

        _addDistribution(
            _treasury,
            DistributionType.STAKING,
            20000000 * _SCALING_FACTOR,
            1000000 * _SCALING_FACTOR
        );
        _addDistribution(_treasury, DistributionType.ECOSYSTEM, 24000000 * _SCALING_FACTOR, 2400000 * _SCALING_FACTOR);
        _addDistribution(_treasury, DistributionType.MARKETING, 6800000 * _SCALING_FACTOR, 340000 * _SCALING_FACTOR);
        _addDistribution(_treasury, DistributionType.RESERVES, 10000000 * _SCALING_FACTOR, 500000 * _SCALING_FACTOR);
        _addDistribution(_treasury, DistributionType.TEAM, 20000000 * _SCALING_FACTOR, 0);
    }

    /// @dev Returns initial timestamp
    function getInitialTimestamp() public view returns (uint256 timestamp) {
        return _initialTimestamp;
    }

    /// @dev Adds Distribution. This function doesn't limit max gas consumption,
    /// so adding too many investors can cause it to reach the out-of-gas error.
    /// @param _beneficiary The address of distribution.
    /// @param _tokensAllotment The amounts of the tokens that belong to each investor.
    function _addDistribution(
        address _beneficiary,
        DistributionType _distributionType,
        uint256 _tokensAllotment,
        uint256 _withdrawnTokens
    ) internal {
        require(_beneficiary != address(0), "Invalid address");
        Distribution storage distribution = distributionInfo[_distributionType];
        distribution.beneficiary = _beneficiary;
        distribution.withdrawnTokens = _withdrawnTokens;
        distribution.tokensAllotment = _tokensAllotment;
        distribution.distributionType = _distributionType;

        emit DistributionAdded(_beneficiary, _msgSender(), _tokensAllotment);
    }

    function withdrawTokens(uint256 _distributionType) external onlyOwner() initialized() {
        Distribution storage distribution = distributionInfo[DistributionType(_distributionType)];

        uint256 tokensAvailable = withdrawableTokens(DistributionType(_distributionType));

        require(tokensAvailable > 0, "no tokens available for withdrawl");

        distribution.withdrawnTokens = distribution.withdrawnTokens.add(tokensAvailable);
        _marshToken.safeTransfer(distribution.beneficiary, tokensAvailable);

        emit WithdrawnTokens(_msgSender(), tokensAvailable);
    }

    /// @dev The starting time of TGE
    /// @param _timestamp The initial timestamp, this timestap should be used for vesting
    function setInitialTimestamp(uint256 _timestamp) external onlyOwner() notInitialized() {
        isInitialized = true;
        _initialTimestamp = _timestamp;
    }

    function withdrawableTokens(DistributionType distributionType) public view returns (uint256 tokens) {
        Distribution storage distribution = distributionInfo[distributionType];
        uint256 availablePercentage = _calculateAvailablePercentage(distributionType);
        // console.log("Available Percentage: %s", availablePercentage);
        uint256 noOfTokens = _calculatePercentage(distribution.tokensAllotment, availablePercentage);
        uint256 tokensAvailable = noOfTokens.sub(distribution.withdrawnTokens);

        // console.log("Withdrawable Tokens: %s",  tokensAvailable);
        return tokensAvailable;
    }

    function _calculatePercentage(uint256 _amount, uint256 _percentage) private pure returns (uint256 percentage) {
        return _amount.mul(_percentage).div(100).div(1e18);
    }

    function _calculateAvailablePercentage(DistributionType distributionType)
        private
        view
        returns (uint256 _availablePercentage)
    {
        uint256 currentTimeStamp = block.timestamp;
        uint256 noOfDays = BokkyPooBahsDateTimeLibrary.diffDays(_initialTimestamp, currentTimeStamp);
        uint256 noOfMonths = _daysToMonths(noOfDays);

        if (currentTimeStamp > _initialTimestamp) {
            if (distributionType == DistributionType.ECOSYSTEM) {
                return noOfMonths > 50 ? uint256(100).mul(1e18) : ecosystemVesting[noOfMonths];
            } else if (
                distributionType == DistributionType.MARKETING ||
                distributionType == DistributionType.RESERVES ||
                distributionType == DistributionType.STAKING
            ) {
                return noOfMonths > 38 ? uint256(100).mul(1e18) : marketingReserveVesting[noOfMonths];
            } else if (distributionType == DistributionType.TEAM) {
                uint256 _remainingDistroPercentage = 85;
                uint256 _noOfRemainingDays = 420;
                uint256 initialCliff = _initialTimestamp + 240 days;
                uint256 vestingDuration = _initialTimestamp + 660 days;
                uint256 everyDayReleasePercentage = _remainingDistroPercentage.mul(1e18).div(_noOfRemainingDays);
                // console.log("Every Day Release %: %s", everyDayReleasePercentage);
                require(currentTimeStamp >= initialCliff, "no tokens available for withdrawl");
                if (currentTimeStamp < vestingDuration) {
                    uint256 noOfDaysAfterCliff = BokkyPooBahsDateTimeLibrary.diffDays(initialCliff, currentTimeStamp);
                    uint256 currentUnlockedPercentage = noOfDaysAfterCliff.mul(everyDayReleasePercentage);
                    return uint256(15).mul(1e18).add(currentUnlockedPercentage);
                } else {
                    return uint256(100).mul(1e18);
                }
            }
        } else {
            return 0;
        }
    }

    function _daysToMonths(uint256 _days) private view returns (uint256 noOfMonths) {
        uint256 noOfDaysInMonth = uint256(30).mul(1e18);
        uint256 daysNormalized = _days.mul(1e18);
        uint256 noOfMonts = daysNormalized.div(noOfDaysInMonth);
        return noOfMonts;
    }

    function recoverExcessToken(address _token, uint256 amount) external onlyOwner {
        IERC20(_token).safeTransfer(_msgSender(), amount);
        emit RecoverToken(_token, amount);
    }
}

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

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

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

// 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;

// ----------------------------------------------------------------------------
// BokkyPooBah's DateTime Library v1.01
//
// A gas-efficient Solidity date and time library
//
// https://github.com/bokkypoobah/BokkyPooBahsDateTimeLibrary
//
// Tested date range 1970/01/01 to 2345/12/31
//
// Conventions:
// Unit      | Range         | Notes
// :-------- |:-------------:|:-----
// timestamp | >= 0          | Unix timestamp, number of seconds since 1970/01/01 00:00:00 UTC
// year      | 1970 ... 2345 |
// month     | 1 ... 12      |
// day       | 1 ... 31      |
// hour      | 0 ... 23      |
// minute    | 0 ... 59      |
// second    | 0 ... 59      |
// dayOfWeek | 1 ... 7       | 1 = Monday, ..., 7 = Sunday
//
//
// Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2018-2019. The MIT Licence.
// ----------------------------------------------------------------------------

library BokkyPooBahsDateTimeLibrary {
    uint256 constant SECONDS_PER_DAY = 24 * 60 * 60;
    uint256 constant SECONDS_PER_HOUR = 60 * 60;
    uint256 constant SECONDS_PER_MINUTE = 60;
    int256 constant OFFSET19700101 = 2440588;

    uint256 constant DOW_MON = 1;
    uint256 constant DOW_TUE = 2;
    uint256 constant DOW_WED = 3;
    uint256 constant DOW_THU = 4;
    uint256 constant DOW_FRI = 5;
    uint256 constant DOW_SAT = 6;
    uint256 constant DOW_SUN = 7;

    // ------------------------------------------------------------------------
    // Calculate the number of days from 1970/01/01 to year/month/day using
    // the date conversion algorithm from
    //   http://aa.usno.navy.mil/faq/docs/JD_Formula.php
    // and subtracting the offset 2440588 so that 1970/01/01 is day 0
    //
    // days = day
    //      - 32075
    //      + 1461 * (year + 4800 + (month - 14) / 12) / 4
    //      + 367 * (month - 2 - (month - 14) / 12 * 12) / 12
    //      - 3 * ((year + 4900 + (month - 14) / 12) / 100) / 4
    //      - offset
    // ------------------------------------------------------------------------
    function _daysFromDate(
        uint256 year,
        uint256 month,
        uint256 day
    ) internal pure returns (uint256 _days) {
        require(year >= 1970);
        int256 _year = int256(year);
        int256 _month = int256(month);
        int256 _day = int256(day);

        int256 __days =
            _day -
                32075 +
                (1461 * (_year + 4800 + (_month - 14) / 12)) /
                4 +
                (367 * (_month - 2 - ((_month - 14) / 12) * 12)) /
                12 -
                (3 * ((_year + 4900 + (_month - 14) / 12) / 100)) /
                4 -
                OFFSET19700101;

        _days = uint256(__days);
    }

    // ------------------------------------------------------------------------
    // Calculate year/month/day from the number of days since 1970/01/01 using
    // the date conversion algorithm from
    //   http://aa.usno.navy.mil/faq/docs/JD_Formula.php
    // and adding the offset 2440588 so that 1970/01/01 is day 0
    //
    // int L = days + 68569 + offset
    // int N = 4 * L / 146097
    // L = L - (146097 * N + 3) / 4
    // year = 4000 * (L + 1) / 1461001
    // L = L - 1461 * year / 4 + 31
    // month = 80 * L / 2447
    // dd = L - 2447 * month / 80
    // L = month / 11
    // month = month + 2 - 12 * L
    // year = 100 * (N - 49) + year + L
    // ------------------------------------------------------------------------
    function _daysToDate(uint256 _days)
        internal
        pure
        returns (
            uint256 year,
            uint256 month,
            uint256 day
        )
    {
        int256 __days = int256(_days);

        int256 L = __days + 68569 + OFFSET19700101;
        int256 N = (4 * L) / 146097;
        L = L - (146097 * N + 3) / 4;
        int256 _year = (4000 * (L + 1)) / 1461001;
        L = L - (1461 * _year) / 4 + 31;
        int256 _month = (80 * L) / 2447;
        int256 _day = L - (2447 * _month) / 80;
        L = _month / 11;
        _month = _month + 2 - 12 * L;
        _year = 100 * (N - 49) + _year + L;

        year = uint256(_year);
        month = uint256(_month);
        day = uint256(_day);
    }

    function timestampFromDate(
        uint256 year,
        uint256 month,
        uint256 day
    ) internal pure returns (uint256 timestamp) {
        timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY;
    }

    function timestampFromDateTime(
        uint256 year,
        uint256 month,
        uint256 day,
        uint256 hour,
        uint256 minute,
        uint256 second
    ) internal pure returns (uint256 timestamp) {
        timestamp =
            _daysFromDate(year, month, day) *
            SECONDS_PER_DAY +
            hour *
            SECONDS_PER_HOUR +
            minute *
            SECONDS_PER_MINUTE +
            second;
    }

    function timestampToDate(uint256 timestamp)
        internal
        pure
        returns (
            uint256 year,
            uint256 month,
            uint256 day
        )
    {
        (year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
    }

    function timestampToDateTime(uint256 timestamp)
        internal
        pure
        returns (
            uint256 year,
            uint256 month,
            uint256 day,
            uint256 hour,
            uint256 minute,
            uint256 second
        )
    {
        (year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
        uint256 secs = timestamp % SECONDS_PER_DAY;
        hour = secs / SECONDS_PER_HOUR;
        secs = secs % SECONDS_PER_HOUR;
        minute = secs / SECONDS_PER_MINUTE;
        second = secs % SECONDS_PER_MINUTE;
    }

    function isValidDate(
        uint256 year,
        uint256 month,
        uint256 day
    ) internal pure returns (bool valid) {
        if (year >= 1970 && month > 0 && month <= 12) {
            uint256 daysInMonth = _getDaysInMonth(year, month);
            if (day > 0 && day <= daysInMonth) {
                valid = true;
            }
        }
    }

    function isValidDateTime(
        uint256 year,
        uint256 month,
        uint256 day,
        uint256 hour,
        uint256 minute,
        uint256 second
    ) internal pure returns (bool valid) {
        if (isValidDate(year, month, day)) {
            if (hour < 24 && minute < 60 && second < 60) {
                valid = true;
            }
        }
    }

    function isLeapYear(uint256 timestamp) internal pure returns (bool leapYear) {
        (uint256 year, , ) = _daysToDate(timestamp / SECONDS_PER_DAY);
        leapYear = _isLeapYear(year);
    }

    function _isLeapYear(uint256 year) internal pure returns (bool leapYear) {
        leapYear = ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
    }

    function isWeekDay(uint256 timestamp) internal pure returns (bool weekDay) {
        weekDay = getDayOfWeek(timestamp) <= DOW_FRI;
    }

    function isWeekEnd(uint256 timestamp) internal pure returns (bool weekEnd) {
        weekEnd = getDayOfWeek(timestamp) >= DOW_SAT;
    }

    function getDaysInMonth(uint256 timestamp) internal pure returns (uint256 daysInMonth) {
        (uint256 year, uint256 month, ) = _daysToDate(timestamp / SECONDS_PER_DAY);
        daysInMonth = _getDaysInMonth(year, month);
    }

    function _getDaysInMonth(uint256 year, uint256 month) internal pure returns (uint256 daysInMonth) {
        if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
            daysInMonth = 31;
        } else if (month != 2) {
            daysInMonth = 30;
        } else {
            daysInMonth = _isLeapYear(year) ? 29 : 28;
        }
    }

    // 1 = Monday, 7 = Sunday
    function getDayOfWeek(uint256 timestamp) internal pure returns (uint256 dayOfWeek) {
        uint256 _days = timestamp / SECONDS_PER_DAY;
        dayOfWeek = ((_days + 3) % 7) + 1;
    }

    function getYear(uint256 timestamp) internal pure returns (uint256 year) {
        (year, , ) = _daysToDate(timestamp / SECONDS_PER_DAY);
    }

    function getMonth(uint256 timestamp) internal pure returns (uint256 month) {
        (, month, ) = _daysToDate(timestamp / SECONDS_PER_DAY);
    }

    function getDay(uint256 timestamp) internal pure returns (uint256 day) {
        (, , day) = _daysToDate(timestamp / SECONDS_PER_DAY);
    }

    function getHour(uint256 timestamp) internal pure returns (uint256 hour) {
        uint256 secs = timestamp % SECONDS_PER_DAY;
        hour = secs / SECONDS_PER_HOUR;
    }

    function getMinute(uint256 timestamp) internal pure returns (uint256 minute) {
        uint256 secs = timestamp % SECONDS_PER_HOUR;
        minute = secs / SECONDS_PER_MINUTE;
    }

    function getSecond(uint256 timestamp) internal pure returns (uint256 second) {
        second = timestamp % SECONDS_PER_MINUTE;
    }

    function addYears(uint256 timestamp, uint256 _years) internal pure returns (uint256 newTimestamp) {
        (uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
        year += _years;
        uint256 daysInMonth = _getDaysInMonth(year, month);
        if (day > daysInMonth) {
            day = daysInMonth;
        }
        newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
        require(newTimestamp >= timestamp);
    }

    function addMonths(uint256 timestamp, uint256 _months) internal pure returns (uint256 newTimestamp) {
        (uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
        month += _months;
        year += (month - 1) / 12;
        month = ((month - 1) % 12) + 1;
        uint256 daysInMonth = _getDaysInMonth(year, month);
        if (day > daysInMonth) {
            day = daysInMonth;
        }
        newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
        require(newTimestamp >= timestamp);
    }

    function addDays(uint256 timestamp, uint256 _days) internal pure returns (uint256 newTimestamp) {
        newTimestamp = timestamp + _days * SECONDS_PER_DAY;
        require(newTimestamp >= timestamp);
    }

    function addHours(uint256 timestamp, uint256 _hours) internal pure returns (uint256 newTimestamp) {
        newTimestamp = timestamp + _hours * SECONDS_PER_HOUR;
        require(newTimestamp >= timestamp);
    }

    function addMinutes(uint256 timestamp, uint256 _minutes) internal pure returns (uint256 newTimestamp) {
        newTimestamp = timestamp + _minutes * SECONDS_PER_MINUTE;
        require(newTimestamp >= timestamp);
    }

    function addSeconds(uint256 timestamp, uint256 _seconds) internal pure returns (uint256 newTimestamp) {
        newTimestamp = timestamp + _seconds;
        require(newTimestamp >= timestamp);
    }

    function subYears(uint256 timestamp, uint256 _years) internal pure returns (uint256 newTimestamp) {
        (uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
        year -= _years;
        uint256 daysInMonth = _getDaysInMonth(year, month);
        if (day > daysInMonth) {
            day = daysInMonth;
        }
        newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
        require(newTimestamp <= timestamp);
    }

    function subMonths(uint256 timestamp, uint256 _months) internal pure returns (uint256 newTimestamp) {
        (uint256 year, uint256 month, uint256 day) = _daysToDate(timestamp / SECONDS_PER_DAY);
        uint256 yearMonth = year * 12 + (month - 1) - _months;
        year = yearMonth / 12;
        month = (yearMonth % 12) + 1;
        uint256 daysInMonth = _getDaysInMonth(year, month);
        if (day > daysInMonth) {
            day = daysInMonth;
        }
        newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + (timestamp % SECONDS_PER_DAY);
        require(newTimestamp <= timestamp);
    }

    function subDays(uint256 timestamp, uint256 _days) internal pure returns (uint256 newTimestamp) {
        newTimestamp = timestamp - _days * SECONDS_PER_DAY;
        require(newTimestamp <= timestamp);
    }

    function subHours(uint256 timestamp, uint256 _hours) internal pure returns (uint256 newTimestamp) {
        newTimestamp = timestamp - _hours * SECONDS_PER_HOUR;
        require(newTimestamp <= timestamp);
    }

    function subMinutes(uint256 timestamp, uint256 _minutes) internal pure returns (uint256 newTimestamp) {
        newTimestamp = timestamp - _minutes * SECONDS_PER_MINUTE;
        require(newTimestamp <= timestamp);
    }

    function subSeconds(uint256 timestamp, uint256 _seconds) internal pure returns (uint256 newTimestamp) {
        newTimestamp = timestamp - _seconds;
        require(newTimestamp <= timestamp);
    }

    function diffYears(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _years) {
        require(fromTimestamp <= toTimestamp);
        (uint256 fromYear, , ) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
        (uint256 toYear, , ) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
        _years = toYear - fromYear;
    }

    function diffMonths(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _months) {
        require(fromTimestamp <= toTimestamp);
        (uint256 fromYear, uint256 fromMonth, ) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
        (uint256 toYear, uint256 toMonth, ) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
        _months = toYear * 12 + toMonth - fromYear * 12 - fromMonth;
    }

    function diffDays(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _days) {
        require(fromTimestamp <= toTimestamp);
        _days = (toTimestamp - fromTimestamp) / SECONDS_PER_DAY;
    }

    function diffHours(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _hours) {
        require(fromTimestamp <= toTimestamp);
        _hours = (toTimestamp - fromTimestamp) / SECONDS_PER_HOUR;
    }

    function diffMinutes(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _minutes) {
        require(fromTimestamp <= toTimestamp);
        _minutes = (toTimestamp - fromTimestamp) / SECONDS_PER_MINUTE;
    }

    function diffSeconds(uint256 fromTimestamp, uint256 toTimestamp) internal pure returns (uint256 _seconds) {
        require(fromTimestamp <= toTimestamp);
        _seconds = toTimestamp - fromTimestamp;
    }
}

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

// 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) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_treasury","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"investor","type":"address"},{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"uint256","name":"allocation","type":"uint256"}],"name":"DistributionAdded","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":"token","type":"address"},{"indexed":true,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RecoverToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"investor","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"WithdrawnTokens","type":"event"},{"inputs":[{"internalType":"enum UnmarshalTokenVesting.DistributionType","name":"","type":"uint8"}],"name":"distributionInfo","outputs":[{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"withdrawnTokens","type":"uint256"},{"internalType":"uint256","name":"tokensAllotment","type":"uint256"},{"internalType":"enum UnmarshalTokenVesting.DistributionType","name":"distributionType","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getInitialTimestamp","outputs":[{"internalType":"uint256","name":"timestamp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isInitialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverExcessToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_timestamp","type":"uint256"}],"name":"setInitialTimestamp","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_distributionType","type":"uint256"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum UnmarshalTokenVesting.DistributionType","name":"distributionType","type":"uint8"}],"name":"withdrawableTokens","outputs":[{"internalType":"uint256","name":"tokens","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000005a666c7d92e5fa7edcb6390e4efd6d0cdd69cf370000000000000000000000003bee11d70e5a25b16520286a7053e84dff2e0f5d

-----Decoded View---------------
Arg [0] : _token (address): 0x5a666c7d92E5fA7Edcb6390E4efD6d0CDd69cF37
Arg [1] : _treasury (address): 0x3Bee11D70e5A25b16520286A7053e84Dff2E0f5d

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000005a666c7d92e5fa7edcb6390e4efd6d0cdd69cf37
Arg [1] : 0000000000000000000000003bee11d70e5a25b16520286a7053e84dff2e0f5d