Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.20;

import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";

/**
 * @title Locker
 * @dev A contract for locking up ERC20 and ERC1155 tokens for a specified period of time.
 */
contract Locker {
    using SafeERC20 for IERC20;

    error LockUp__InvalidParams(string param);
    error LockUp__PermissionDenied();
    error LockUp__AlreadyClaimed();
    error LockUp__NotYetUnlocked();
    error LockUp__InvalidPaginationParameters();

    event LockedUp(uint256 indexed lockUpId, address indexed token, bool isERC20, address indexed receiver, uint256 amount, uint40 unlockTime);
    event Unlocked(uint256 indexed lockUpId, address indexed token, bool isERC20, address indexed receiver, uint256 amount);


    struct LockUp {
        address token;
        bool isERC20;
        uint40 unlockTime;
        bool unlocked; // 160 + 8 + 40 + 8 = 216 bits
        uint256 amount;
        address receiver;
        string title;
    }

    LockUp[] public lockUps;

    modifier onlyReceiver(uint256 lockUpId) {
        if (msg.sender != lockUps[lockUpId].receiver) revert LockUp__PermissionDenied();
        _;
    }

    /**
     * @dev Creates a new lock-up.
     * @param token The address of the token being locked up.
     * @param isERC20 A boolean indicating whether the token is an ERC20 token.
     * @param amount The amount of tokens being locked up.
     * @param unlockTime The timestamp when the tokens can be unlocked.
     * @param receiver The address of the receiver of the locked tokens.
     * @param title The optional title of the lock-up.
     */
    function createLockUp(address token, bool isERC20, uint256 amount, uint40 unlockTime, address receiver, string calldata title) external {
        // Parameter validations
        if (token == address(0)) revert LockUp__InvalidParams('token');
        if (amount == 0) revert LockUp__InvalidParams('amount');
        if (unlockTime <= block.timestamp) revert LockUp__InvalidParams('unlockTime');
        if (receiver == address(0)) revert LockUp__InvalidParams('receiver');

        // Create a new lockUp
        lockUps.push();
        LockUp storage lockUp = lockUps[lockUps.length - 1];
        lockUp.token = token;
        lockUp.isERC20 = isERC20;
        lockUp.unlockTime = unlockTime;
        // lockUp.unlocked = false;
        lockUp.amount = amount;
        lockUp.receiver = receiver;
        lockUp.title = title;

        // Deposit total amount of tokens to this contract
        if (isERC20) {
            IERC20(token).safeTransferFrom(msg.sender, address(this), amount);
        } else {
            // Only support an ERC1155 token at id = 0
            IERC1155(token).safeTransferFrom(msg.sender, address(this), 0, amount, "");
        }

        emit LockedUp(lockUps.length - 1, token, isERC20, receiver, amount, unlockTime);
    }

    /**
     * @dev Unlocks the tokens of a lock-up.
     * @param lockUpId The ID of the lock-up.
     */
    function unlock(uint256 lockUpId) external onlyReceiver(lockUpId) {
        LockUp storage lockUp = lockUps[lockUpId];
        if (lockUp.unlocked) revert LockUp__AlreadyClaimed();
        if (lockUp.unlockTime > block.timestamp) revert LockUp__NotYetUnlocked();

        lockUp.unlocked = true;

        if (lockUp.isERC20) {
            IERC20(lockUp.token).safeTransfer(lockUp.receiver, lockUp.amount);
        } else {
            IERC1155(lockUp.token).safeTransferFrom(address(this), lockUp.receiver, 0, lockUp.amount, "");
        }

        emit Unlocked(lockUpId, lockUp.token, lockUp.isERC20, lockUp.receiver, lockUp.amount);
    }

    // MARK: - Utility functions

    /**
     * @dev Returns the length of lockUps array.
     * @return The number of lock-ups.
     */
    function lockUpCount() external view returns (uint256) {
        return lockUps.length;
    }

    /**
     * @dev Returns an array of lock-up IDs for a given token address within a specified range.
     * @param token The address of the token.
     * @param start The starting index of the range.
     * @param stop The ending index of the range.
     * @return ids An array of lock-up IDs.
     */
    function getLockUpIdsByToken(address token, uint256 start, uint256 stop) external view returns (uint256[] memory ids) {
        if (start >= stop || stop - start > 10000) revert LockUp__InvalidPaginationParameters();

        unchecked {
            uint256 lockUpsLength = lockUps.length;
            if (stop > lockUpsLength) {
                stop = lockUpsLength;
            }

            uint256 count;
            for (uint256 i = start; i < stop; ++i) {
                if (lockUps[i].token == token) ++count;
            }

            ids = new uint256[](count);
            uint256 j;
            for (uint256 i = start; i < stop; ++i) {
                if (lockUps[i].token == token) {
                    ids[j++] = i;
                    if (j == count) break;
                }
            }
        }
    }

    /**
     * @dev Returns an array of lock-up IDs for a given receiver address within a specified range.
     * @param receiver The address of the receiver.
     * @param start The starting index of the range.
     * @param stop The ending index of the range.
     * @return ids An array of lock-up IDs.
     */
    function getLockUpIdsByReceiver(address receiver, uint256 start, uint256 stop) external view returns (uint256[] memory ids) {
        if (start >= stop || stop - start > 10000) revert LockUp__InvalidPaginationParameters();

        unchecked {
            uint256 lockUpsLength = lockUps.length;
            if (stop > lockUpsLength) {
                stop = lockUpsLength;
            }

            uint256 count;
            for (uint256 i = start; i < stop; ++i) {
                if (lockUps[i].receiver == receiver) ++count;
            }

            ids = new uint256[](count);
            uint256 j;
            for (uint256 i = start; i < stop; ++i) {
                if (lockUps[i].receiver == receiver) {
                    ids[j++] = i;
                    if (j == count) break;
                }
            }
        }
    }

    // MARK: - ERC1155 Receiver

    function onERC1155Received(address, address, uint256, uint256, bytes memory) external pure returns (bytes4) {
        return this.onERC1155Received.selector;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` amount of tokens of type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the value of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] calldata accounts,
        uint256[] calldata ids
    ) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155Received} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `value` amount.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits either a {TransferSingle} or a {TransferBatch} event, depending on the length of the array arguments.
     *
     * Requirements:
     *
     * - `ids` and `values` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: MIT
// 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);
}

// SPDX-License-Identifier: MIT
// 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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../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;

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

// SPDX-License-Identifier: MIT
// 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();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

{
  "evmVersion": "paris",
  "optimizer": {
    "enabled": true,
    "runs": 50000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• 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":"FailedInnerCall","type":"error"},{"inputs":[],"name":"LockUp__AlreadyClaimed","type":"error"},{"inputs":[],"name":"LockUp__InvalidPaginationParameters","type":"error"},{"inputs":[{"internalType":"string","name":"param","type":"string"}],"name":"LockUp__InvalidParams","type":"error"},{"inputs":[],"name":"LockUp__NotYetUnlocked","type":"error"},{"inputs":[],"name":"LockUp__PermissionDenied","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"lockUpId","type":"uint256"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"bool","name":"isERC20","type":"bool"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint40","name":"unlockTime","type":"uint40"}],"name":"LockedUp","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"lockUpId","type":"uint256"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"bool","name":"isERC20","type":"bool"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Unlocked","type":"event"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"bool","name":"isERC20","type":"bool"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint40","name":"unlockTime","type":"uint40"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"string","name":"title","type":"string"}],"name":"createLockUp","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"getLockUpIdsByReceiver","outputs":[{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"getLockUpIdsByToken","outputs":[{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockUpCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"lockUps","outputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"bool","name":"isERC20","type":"bool"},{"internalType":"uint40","name":"unlockTime","type":"uint40"},{"internalType":"bool","name":"unlocked","type":"bool"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"string","name":"title","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"lockUpId","type":"uint256"}],"name":"unlock","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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