Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2025-01-07
*/

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;




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

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @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);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

// File: LAKE_Presale_Vault.sol


pragma solidity =0.8.27;


error AlreadyLocked();
error NotTokenOwner();
error NotEnoughTokens();
error NothingToUnlock();


contract LakePresaleVault {
    address public constant XLAKE_ADDRESS = 0xf35593120A5c19D3ae3d551b5806163B367c096D;
    address public constant LAKE_ADDRESS = 0x13d074303C95a34d304F29928dC8A16dEc797e9E;
    address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
    
    uint256 public constant TIME_1_MONTH_ADJUSTED = 30 days;        // Time for each period = 30 days
    uint256 public constant TOTAL_WITHDRAWS = 12;                   // Max number of withdraws = 5
    uint256 public totalPendingToGet;                               // Total amount deposited and not withdrawn
    uint8 private constant NUM_EXTRA_PERIODS = 1;                   // To be used when calculating the unlockable amount

    mapping(address => uint64) public lockingTime;       // Depositing time by an address
    mapping(address => uint256) public depositedAmount;  // Total deposited ERC-20 tokens by an address
    mapping(address => uint256) public remainingAmount;  // Remaining locked ERC-20 tokens by an address [deposited - withdrawn]
    mapping(address => uint256) public withdrawnAmount;  // Total unlocked ERC-20 tokens by an address

    event Locked(address indexed, uint256 indexed amount);
    event Unlocked(address indexed, uint256 indexed amount);

     /*
    Allows to lock [XLAKE_ADDRESS] tokens
    */
    function lock() external {
        require(depositedAmount[msg.sender] == 0, AlreadyLocked());
        uint _balance = IERC20(XLAKE_ADDRESS).balanceOf(msg.sender);
        require(_balance > 0, NotTokenOwner());
        require(IERC20(LAKE_ADDRESS).balanceOf(address(this)) >= _balance + totalPendingToGet , NotEnoughTokens());
        uint _toSend = _balance * 3 / 20;  // 15%
        SafeERC20.safeTransferFrom(IERC20(XLAKE_ADDRESS), msg.sender, BURN_ADDRESS, _balance);
        SafeERC20.safeTransfer(IERC20(LAKE_ADDRESS), msg.sender, _toSend);
        depositedAmount[msg.sender] = _balance;
        remainingAmount[msg.sender] = _balance - _toSend;
        withdrawnAmount[msg.sender] = _toSend;
        lockingTime[msg.sender] = uint64(block.timestamp);
        totalPendingToGet += _balance - _toSend;

        emit Locked(msg.sender, _balance);
    }

    /*
    Allows to unlock all unlockable [LAKE_ADDRESS] tokens
    */
    function unlock() external {
        uint256 _amount = getUnlockableAmount(msg.sender);
        require(_amount > 0, NothingToUnlock());

        /* underflow/overflow cannot happen:
            - Max of _amount = remainingAmount
            - Max of withdrawnAmount = depositedAmount
            - Max of _amount = totalPendingToGet
        */
        
        remainingAmount[msg.sender] -= _amount;
        withdrawnAmount[msg.sender] += _amount;
        totalPendingToGet -= _amount;

        SafeERC20.safeTransfer(IERC20(LAKE_ADDRESS), msg.sender, _amount);

        emit Unlocked(msg.sender, _amount);
    }

    /*
    Get the amount of unlockable tokens [LAKE_ADDRESS]
    @param _wallet: Address to check
    */
    function getUnlockableAmount(address _wallet)
        public
        view
        returns (uint256)
    {
        if (remainingAmount[_wallet] == 0) return 0;

        uint256 numWithdraws = getNumUnlockPeriods(_wallet);
        uint256 _toSend = (numWithdraws * depositedAmount[_wallet] * 17 / 20) / TOTAL_WITHDRAWS -
            (withdrawnAmount[_wallet] - depositedAmount[_wallet] * 3 / 20);

        if (
            _toSend > remainingAmount[_wallet] || 
            remainingAmount[_wallet] - _toSend < TOTAL_WITHDRAWS // decimals check (for the last withdraw) - 0,00000000000000012
        ) {
            _toSend = remainingAmount[_wallet];
        }
        return _toSend;
    }

    /*
    Get the number of unlockable periods (30 days)
    @param _wallet: Address to check
    */
    function getNumUnlockPeriods(address _wallet)
        internal
        view
        returns (uint256)
    {   
        uint numUnloks = (block.timestamp - lockingTime[_wallet]) /
            TIME_1_MONTH_ADJUSTED;

        if (numUnloks > TOTAL_WITHDRAWS) numUnloks = TOTAL_WITHDRAWS;

        return numUnloks;
           
    }

    /*
    Get the time (in seconds) till the next unlock
    @param _wallet: Address to check
    returns 0 if remaining tokens is 0
    returns 0 if unlockable amount is greater than 0
    */
    function getTimeUntilNextUnlock(address _wallet)
        external
        view
        returns (uint256)
    {   
        uint _res = 0;
        if (
            remainingAmount[_wallet] == 0 ||
            getUnlockableAmount(_wallet) > 0 
        ){
            // must return 0
        }else{
            uint256 numPeriods = getNumUnlockPeriods(_wallet);
            _res = lockingTime[_wallet] +
               (numPeriods + NUM_EXTRA_PERIODS) *
               TIME_1_MONTH_ADJUSTED -
               block.timestamp;
        }
        return _res;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"AlreadyLocked","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"NotEnoughTokens","type":"error"},{"inputs":[],"name":"NotTokenOwner","type":"error"},{"inputs":[],"name":"NothingToUnlock","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"","type":"address"},{"indexed":true,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Locked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"","type":"address"},{"indexed":true,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Unlocked","type":"event"},{"inputs":[],"name":"BURN_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LAKE_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TIME_1_MONTH_ADJUSTED","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_WITHDRAWS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"XLAKE_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"depositedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"}],"name":"getTimeUntilNextUnlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"}],"name":"getUnlockableAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lockingTime","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"remainingAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalPendingToGet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"withdrawnAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

19222:5014:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23656:577;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20292:50;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19526:55;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19966:45;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20057:50;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19255:82;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20162:50;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19344:81;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19629:44;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21538:631;;;:::i;:::-;;22287:706;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19729:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20582:873;;;:::i;:::-;;19432:81;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23656:577;23755:7;23783:9;23795:1;23783:13;;23853:1;23825:15;:24;23841:7;23825:24;;;;;;;;;;;;;;;;:29;:78;;;;23902:1;23871:28;23891:7;23871:19;:28::i;:::-;:32;23825:78;23807:397;;23976:18;23997:28;24017:7;23997:19;:28::i;:::-;23976:49;;24177:15;19574:7;19885:1;24087:30;;:10;:30;;;;:::i;:::-;24086:72;;;;:::i;:::-;24047:11;:20;24059:7;24047:20;;;;;;;;;;;;;;;;;;;;;;;;;:111;;;;;;:::i;:::-;:145;;;;:::i;:::-;24040:152;;23961:243;23807:397;24221:4;24214:11;;;23656:577;;;:::o;20292:50::-;;;;;;;;;;;;;;;;;:::o;19526:55::-;19574:7;19526:55;:::o;19966:45::-;;;;;;;;;;;;;;;;;;;;;;:::o;20057:50::-;;;;;;;;;;;;;;;;;:::o;19255:82::-;19295:42;19255:82;:::o;20162:50::-;;;;;;;;;;;;;;;;;:::o;19344:81::-;19383:42;19344:81;:::o;19629:44::-;19671:2;19629:44;:::o;21538:631::-;21576:15;21594:31;21614:10;21594:19;:31::i;:::-;21576:49;;21654:1;21644:7;:11;21636:39;;;;;;;;;;;;;;;;;21941:7;21910:15;:27;21926:10;21910:27;;;;;;;;;;;;;;;;:38;;;;;;;:::i;:::-;;;;;;;;21990:7;21959:15;:27;21975:10;21959:27;;;;;;;;;;;;;;;;:38;;;;;;;:::i;:::-;;;;;;;;22029:7;22008:17;;:28;;;;;;;:::i;:::-;;;;;;;;22049:65;19383:42;22094:10;22106:7;22049:22;:65::i;:::-;22153:7;22141:10;22132:29;;;;;;;;;;;;21565:604;21538:631::o;22287:706::-;22381:7;22438:1;22410:15;:24;22426:7;22410:24;;;;;;;;;;;;;;;;:29;22406:43;;22448:1;22441:8;;;;22406:43;22462:20;22485:28;22505:7;22485:19;:28::i;:::-;22462:51;;22524:15;22686:2;22682:1;22655:15;:24;22671:7;22655:24;;;;;;;;;;;;;;;;:28;;;;:::i;:::-;:33;;;;:::i;:::-;22628:15;:24;22644:7;22628:24;;;;;;;;;;;;;;;;:60;;;;:::i;:::-;19671:2;22590;22585;22558:15;:24;22574:7;22558:24;;;;;;;;;;;;;;;;22543:12;:39;;;;:::i;:::-;:44;;;;:::i;:::-;:49;;;;:::i;:::-;22542:69;;;;:::i;:::-;:147;;;;:::i;:::-;22524:165;;22730:15;:24;22746:7;22730:24;;;;;;;;;;;;;;;;22720:7;:34;:104;;;;19671:2;22799:7;22772:15;:24;22788:7;22772:24;;;;;;;;;;;;;;;;:34;;;;:::i;:::-;:52;22720:104;22702:259;;;22925:15;:24;22941:7;22925:24;;;;;;;;;;;;;;;;22915:34;;22702:259;22978:7;22971:14;;;;22287:706;;;;:::o;19729:32::-;;;;:::o;20582:873::-;20657:1;20626:15;:27;20642:10;20626:27;;;;;;;;;;;;;;;;:32;20618:58;;;;;;;;;;;;;;;;;20687:13;19295:42;20703:31;;;20735:10;20703:43;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20687:59;;20776:1;20765:8;:12;20757:38;;;;;;;;;;;;;;;;;20874:17;;20863:8;:28;;;;:::i;:::-;19383:42;20814:30;;;20853:4;20814:45;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:77;;20806:106;;;;;;;;;;;;;;;;;20923:12;20953:2;20949:1;20938:8;:12;;;;:::i;:::-;:17;;;;:::i;:::-;20923:32;;20974:85;19295:42;21024:10;19471:42;21050:8;20974:26;:85::i;:::-;21070:65;19383:42;21115:10;21127:7;21070:22;:65::i;:::-;21176:8;21146:15;:27;21162:10;21146:27;;;;;;;;;;;;;;;:38;;;;21236:7;21225:8;:18;;;;:::i;:::-;21195:15;:27;21211:10;21195:27;;;;;;;;;;;;;;;:48;;;;21284:7;21254:15;:27;21270:10;21254:27;;;;;;;;;;;;;;;:37;;;;21335:15;21302:11;:23;21314:10;21302:23;;;;;;;;;;;;;;;;:49;;;;;;;;;;;;;;;;;;21394:7;21383:8;:18;;;;:::i;:::-;21362:17;;:39;;;;;;;:::i;:::-;;;;;;;;21438:8;21426:10;21419:28;;;;;;;;;;;;20607:848;;20582:873::o;19432:81::-;19471:42;19432:81;:::o;23107:341::-;23203:7;23231:14;19574:7;23267:11;:20;23279:7;23267:20;;;;;;;;;;;;;;;;;;;;;;;;;23249:38;;:15;:38;;;;:::i;:::-;23248:77;;;;:::i;:::-;23231:94;;19671:2;23342:9;:27;23338:60;;;19671:2;23371:27;;23338:60;23418:9;23411:16;;;23107:341;;;:::o;14499:162::-;14582:71;14602:5;14624;:14;;;14641:2;14645:5;14609:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14582:19;:71::i;:::-;14499:162;;;:::o;14906:190::-;15007:81;15027:5;15049;:18;;;15070:4;15076:2;15080:5;15034:53;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15007:19;:81::i;:::-;14906:190;;;;:::o;17310:638::-;17734:23;17760:33;17788:4;17768:5;17760:27;;;;:33;;;;:::i;:::-;17734:59;;17829:1;17808:10;:17;:22;;:57;;;;;17846:10;17835:30;;;;;;;;;;;;:::i;:::-;17834:31;17808:57;17804:137;;;17922:5;17889:40;;;;;;;;;;;:::i;:::-;;;;;;;;17804:137;17380:568;17310:638;;:::o;9625:153::-;9700:12;9732:38;9754:6;9762:4;9768:1;9732:21;:38::i;:::-;9725:45;;9625:153;;;;:::o;10113:398::-;10212:12;10265:5;10241:21;:29;10237:110;;;10329:4;10294:41;;;;;;;;;;;:::i;:::-;;;;;;;;10237:110;10358:12;10372:23;10399:6;:11;;10418:5;10425:4;10399:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10357:73;;;;10448:55;10475:6;10483:7;10492:10;10448:26;:55::i;:::-;10441:62;;;;10113:398;;;;;:::o;11589:597::-;11737:12;11767:7;11762:417;;11791:19;11799:10;11791:7;:19::i;:::-;11762:417;;;12040:1;12019:10;:17;:22;:49;;;;;12067:1;12045:6;:18;;;:23;12019:49;12015:121;;;12113:6;12096:24;;;;;;;;;;;:::i;:::-;;;;;;;;12015:121;12157:10;12150:17;;;;11762:417;11589:597;;;;;;:::o;12739:528::-;12892:1;12872:10;:17;:21;12868:392;;;13104:10;13098:17;13161:15;13148:10;13144:2;13140:19;13133:44;12868:392;13231:17;;;;;;;;;;;;;;88:117:1;197:1;194;187:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:329::-;900:6;949:2;937:9;928:7;924:23;920:32;917:119;;;955:79;;:::i;:::-;917:119;1075:1;1100:53;1145:7;1136:6;1125:9;1121:22;1100:53;:::i;:::-;1090:63;;1046:117;841:329;;;;:::o;1176:77::-;1213:7;1242:5;1231:16;;1176:77;;;:::o;1259:118::-;1346:24;1364:5;1346:24;:::i;:::-;1341:3;1334:37;1259:118;;:::o;1383:222::-;1476:4;1514:2;1503:9;1499:18;1491:26;;1527:71;1595:1;1584:9;1580:17;1571:6;1527:71;:::i;:::-;1383:222;;;;:::o;1611:101::-;1647:7;1687:18;1680:5;1676:30;1665:41;;1611:101;;;:::o;1718:115::-;1803:23;1820:5;1803:23;:::i;:::-;1798:3;1791:36;1718:115;;:::o;1839:218::-;1930:4;1968:2;1957:9;1953:18;1945:26;;1981:69;2047:1;2036:9;2032:17;2023:6;1981:69;:::i;:::-;1839:218;;;;:::o;2063:118::-;2150:24;2168:5;2150:24;:::i;:::-;2145:3;2138:37;2063:118;;:::o;2187:222::-;2280:4;2318:2;2307:9;2303:18;2295:26;;2331:71;2399:1;2388:9;2384:17;2375:6;2331:71;:::i;:::-;2187:222;;;;:::o;2415:180::-;2463:77;2460:1;2453:88;2560:4;2557:1;2550:15;2584:4;2581:1;2574:15;2601:191;2641:3;2660:20;2678:1;2660:20;:::i;:::-;2655:25;;2694:20;2712:1;2694:20;:::i;:::-;2689:25;;2737:1;2734;2730:9;2723:16;;2758:3;2755:1;2752:10;2749:36;;;2765:18;;:::i;:::-;2749:36;2601:191;;;;:::o;2798:410::-;2838:7;2861:20;2879:1;2861:20;:::i;:::-;2856:25;;2895:20;2913:1;2895:20;:::i;:::-;2890:25;;2950:1;2947;2943:9;2972:30;2990:11;2972:30;:::i;:::-;2961:41;;3151:1;3142:7;3138:15;3135:1;3132:22;3112:1;3105:9;3085:83;3062:139;;3181:18;;:::i;:::-;3062:139;2846:362;2798:410;;;;:::o;3214:194::-;3254:4;3274:20;3292:1;3274:20;:::i;:::-;3269:25;;3308:20;3326:1;3308:20;:::i;:::-;3303:25;;3352:1;3349;3345:9;3337:17;;3376:1;3370:4;3367:11;3364:37;;;3381:18;;:::i;:::-;3364:37;3214:194;;;;:::o;3414:180::-;3462:77;3459:1;3452:88;3559:4;3556:1;3549:15;3583:4;3580:1;3573:15;3600:185;3640:1;3657:20;3675:1;3657:20;:::i;:::-;3652:25;;3691:20;3709:1;3691:20;:::i;:::-;3686:25;;3730:1;3720:35;;3735:18;;:::i;:::-;3720:35;3777:1;3774;3770:9;3765:14;;3600:185;;;;:::o;3791:122::-;3864:24;3882:5;3864:24;:::i;:::-;3857:5;3854:35;3844:63;;3903:1;3900;3893:12;3844:63;3791:122;:::o;3919:143::-;3976:5;4007:6;4001:13;3992:22;;4023:33;4050:5;4023:33;:::i;:::-;3919:143;;;;:::o;4068:351::-;4138:6;4187:2;4175:9;4166:7;4162:23;4158:32;4155:119;;;4193:79;;:::i;:::-;4155:119;4313:1;4338:64;4394:7;4385:6;4374:9;4370:22;4338:64;:::i;:::-;4328:74;;4284:128;4068:351;;;;:::o;4425:332::-;4546:4;4584:2;4573:9;4569:18;4561:26;;4597:71;4665:1;4654:9;4650:17;4641:6;4597:71;:::i;:::-;4678:72;4746:2;4735:9;4731:18;4722:6;4678:72;:::i;:::-;4425:332;;;;;:::o;4763:442::-;4912:4;4950:2;4939:9;4935:18;4927:26;;4963:71;5031:1;5020:9;5016:17;5007:6;4963:71;:::i;:::-;5044:72;5112:2;5101:9;5097:18;5088:6;5044:72;:::i;:::-;5126;5194:2;5183:9;5179:18;5170:6;5126:72;:::i;:::-;4763:442;;;;;;:::o;5211:90::-;5245:7;5288:5;5281:13;5274:21;5263:32;;5211:90;;;:::o;5307:116::-;5377:21;5392:5;5377:21;:::i;:::-;5370:5;5367:32;5357:60;;5413:1;5410;5403:12;5357:60;5307:116;:::o;5429:137::-;5483:5;5514:6;5508:13;5499:22;;5530:30;5554:5;5530:30;:::i;:::-;5429:137;;;;:::o;5572:345::-;5639:6;5688:2;5676:9;5667:7;5663:23;5659:32;5656:119;;;5694:79;;:::i;:::-;5656:119;5814:1;5839:61;5892:7;5883:6;5872:9;5868:22;5839:61;:::i;:::-;5829:71;;5785:125;5572:345;;;;:::o;5923:98::-;5974:6;6008:5;6002:12;5992:22;;5923:98;;;:::o;6027:147::-;6128:11;6165:3;6150:18;;6027:147;;;;:::o;6180:139::-;6269:6;6264:3;6259;6253:23;6310:1;6301:6;6296:3;6292:16;6285:27;6180:139;;;:::o;6325:386::-;6429:3;6457:38;6489:5;6457:38;:::i;:::-;6511:88;6592:6;6587:3;6511:88;:::i;:::-;6504:95;;6608:65;6666:6;6661:3;6654:4;6647:5;6643:16;6608:65;:::i;:::-;6698:6;6693:3;6689:16;6682:23;;6433:278;6325:386;;;;:::o;6717:271::-;6847:3;6869:93;6958:3;6949:6;6869:93;:::i;:::-;6862:100;;6979:3;6972:10;;6717:271;;;;:::o

ipfs://1fb2fe01cb16814dbc0f8e7bd25cb0c677c9b15baf7a1f8117cc9432a6a06bef