Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import '@openzeppelin/contracts/utils/ReentrancyGuard.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import './LockerPass.sol';
import './types/types.sol';
import './abstract/AbstractLocker.sol';
/**
 * @title ERC721Locker
 * @dev Contract for locking ERC-721 tokens for different periods of time.
 * Uses NFT (LockerPass) to represent locked positions, allowing ownership transfer.
 */
contract ERC721Locker is ReentrancyGuard, IERC721Receiver, AbstractLocker {
  // Mapping of lock position ID to locked asset data
  mapping(uint256 => ERC721LockedAsset) public lockedAssets;

  // Event for ERC-721 lock
  event ERC721Locked(
    address indexed user,
    uint256 indexed positionId,
    address indexed tokenAddress,
    uint256 tokenId,
    LockTier lockTier
  );

  // Event for ERC-721 unlock
  event ERC721Unlocked(
    address indexed user,
    uint256 indexed positionId,
    address indexed tokenAddress,
    uint256 tokenId
  );

  /**
   * @dev Constructor initializing the contract
   */
  constructor(address _lockerPassAddress) AbstractLocker(_lockerPassAddress) {}

  /**
   * @notice Locks ERC-721 (NFT) tokens in the contract
   * @dev Creates a new lock position represented by an NFT
   * @param _tokenAddress Address of the ERC-721 token contract
   * @param _tokenId ID of the NFT to lock
   * @param _lockTier Lock period chosen by the user
   * @return uint256 ID of the created lock position
   */
  function lockERC721(
    address _tokenAddress,
    uint256 _tokenId,
    LockTier _lockTier
  ) external nonReentrant returns (uint256) {
    require(_tokenAddress != address(0), 'Invalid token address');

    uint256 lockPeriod = _getLockPeriod(_lockTier);
    uint256 unlockAt = _lockTier == LockTier.FOREVER
      ? type(uint256).max
      : block.timestamp + lockPeriod;

    // Transfer NFT to this contract
    IERC721(_tokenAddress).safeTransferFrom(msg.sender, address(this), _tokenId);

    // Create new LockedAsset structure
    ERC721LockedAsset memory newLockedAsset = ERC721LockedAsset({
      tokenAddress: _tokenAddress,
      tokenId: _tokenId,
      createdAt: block.timestamp,
      unlockAt: unlockAt,
      lockTier: _lockTier
    });

    // Create new NFT representing the lock position
    uint256 newPositionId = lockerPass.nextId();
    lockerPass.mint(msg.sender);
    lockedAssets[newPositionId] = newLockedAsset;

    emit ERC721Locked(msg.sender, newPositionId, _tokenAddress, _tokenId, _lockTier);

    return newPositionId;
  }

  /**
   * @notice Unlocks assets  and returns them to the owner
   * @param _positionId ID of the lock position to unlock
   */
  function _unlock(
    uint256 _positionId
  ) internal override {
    ERC721LockedAsset memory lockedAsset = lockedAssets[_positionId];

    IERC721(lockedAsset.tokenAddress).safeTransferFrom(
      address(this),
      msg.sender,
      lockedAsset.tokenId
    );
    emit ERC721Unlocked(msg.sender, _positionId, lockedAsset.tokenAddress, lockedAsset.tokenId);

    // Delete lock position data and burn NFT
    delete lockedAssets[_positionId];
    lockerPass.burn(_positionId);
  }

  function _getPositionInfo(
    uint256 _positionId
  ) internal view override returns (LockTier lockTier, uint256 createdAt, uint256 unlockAt, bool isLinearLock) {
    {
      ERC721LockedAsset memory lockedAsset = lockedAssets[_positionId];
      return (lockedAsset.lockTier, lockedAsset.createdAt, lockedAsset.unlockAt, false);
    }
  }

  function _updateLock(
    uint256 _positionId,
    LockTier _newLockTier,
    uint256 _newUnlockAt
  ) internal override {
    ERC721LockedAsset storage lockedAsset = lockedAssets[_positionId];
    lockedAsset.lockTier = _newLockTier;
    lockedAsset.unlockAt = _newUnlockAt;
  }

  /**
   * @dev Implements the IERC721Receiver function
   * Required to allow the contract to receive ERC-721 tokens
   */
  function onERC721Received(
    address,
    address,
    uint256,
    bytes calldata
  ) external pure override returns (bytes4) {
    return IERC721Receiver.onERC721Received.selector;
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Required interface of an ERC-721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC-721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
     *   {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.20;

/**
 * @title ERC-721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC-721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be
     * reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.20;

import {IERC721} from "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * 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[ERC 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);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import '@openzeppelin/contracts/token/ERC721/IERC721.sol';
import '@openzeppelin/contracts/utils/introspection/IERC165.sol';
import '@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol';

/**
 * @title LockerPass
 * @dev Contract representing an NFT token compatible with ERC721 and ERC721Enumerable standards.
 * Enables creating, burning, and managing NFT tokens with enumeration functionality.
 */
contract LockerPass is IERC721Enumerable {
  // Address of the administrator
  address public admin;
  // ID for the next NFT to be minted
  uint256 public nextId = 0;

  // Name of the NFT collection
  string public name;
  // Symbol of the NFT collection
  string public symbol;

  // Mapping of authorized lockers with minting and burning privileges
  mapping(address => bool) public authorizedLockers;
  // Mapping of token IDs to their owners
  mapping(uint256 => address) private _owners;
  // Number of tokens owned by each address
  mapping(address => uint256) private _balances;
  // Approved addresses for specific tokens
  mapping(uint256 => address) private _tokenApprovals;
  // Approved operators for specific owners
  mapping(address => mapping(address => bool)) private _operatorApprovals;

  // Variables for IERC721Enumerable implementation
  // Mapping of owners to their tokens by index
  mapping(address owner => mapping(uint256 index => uint256)) private _ownedTokens;
  // Mapping of token IDs to their indices in the owner's token array
  mapping(uint256 tokenId => uint256) private _ownedTokensIndex;
  // Array of all tokens
  uint256[] private _allTokens;
  // Mapping of token IDs to their indices in the all tokens array
  mapping(uint256 tokenId => uint256) private _allTokensIndex;

  // Custom contract errors
  error ERC721NonexistentToken(uint256 tokenId);
  error ERC721InvalidReceiver(address receiver);
  error ERC721InvalidAddress(address target);
  error ERC721OutOfBoundsIndex(address owner, uint256 index);
  error ERC721InvalidOperator(address operator);

  /**
   * @dev Modifier checking if the token exists
   */
  modifier requireMinted(uint256 _tokenId) {
    if (_ownerOf(_tokenId) == address(0)) {
      revert ERC721NonexistentToken(_tokenId);
    }
    _;
  }

  /**
   * @dev Modifier restricting access to administrator only
   */
  modifier onlyAdmin() {
    require(msg.sender == admin, 'Access denied!');
    _;
  }

  /**
   * @dev Modifier restricting access to locker only
   */
  modifier onlyLocker() {
    require(authorizedLockers[msg.sender], 'Access denied!');
    _;
  }

  /**
   * @dev Modifier restricting access to token owner only
   */
  modifier onlyOwner(uint256 _tokenId) {
    require(_ownerOf(_tokenId) == msg.sender, 'Access denied!');
    _;
  }

  /**
   * @dev Constructor initializing the contract
   * @param _admin Address of the contract administrator
   * @param _name Name of the NFT collection
   * @param _symbol Symbol of the NFT collection
   */
  constructor(address _admin, string memory _name, string memory _symbol) {
    admin = _admin;
    name = _name;
    symbol = _symbol;
  }

  /**
   * @dev Add locker to the contract
   * @param _locker Address of the locker to add
   */
  function addLocker(address _locker) external onlyAdmin {
    authorizedLockers[_locker] = true;
  }

  /**
   * @dev Remove locker from the contract
   * @param _locker Address of the locker to remove
   */
  function removeLocker(address _locker) external onlyAdmin {
    authorizedLockers[_locker] = false;
  }

  /**
   * @dev Transfer ownership of the contract
   * @param _newAdmin Address of the new admin
   */
  function transferOwnership(address _newAdmin) external onlyAdmin {
    require(_newAdmin != address(0), "New admin cannot be zero address");
    admin = _newAdmin;
  }

  /**
   * @dev Checks if the contract supports a given interface
   * @param interfaceId ID of the interface to check
   * @return bool Whether the interface is supported
   */
  function supportsInterface(bytes4 interfaceId) public pure returns (bool) {
    return
      interfaceId == type(IERC721).interfaceId ||
      interfaceId == type(IERC165).interfaceId ||
      interfaceId == type(IERC721Enumerable).interfaceId;
  }

  /**
   * @dev Returns the number of tokens owned by an address
   * @param _owner Address of the owner
   * @return uint256 Number of tokens
   */
  function balanceOf(address _owner) public view returns (uint256) {
    if (_owner == address(0)) {
      revert ERC721InvalidAddress(_owner);
    }

    return _balances[_owner];
  }

  /**
   * @dev Returns the total amount of tokens stored by the contract.
   */
  function totalSupply() public view returns (uint256) {
    return _allTokens.length;
  }

  /**
   * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
   * Use along with {totalSupply} to enumerate all tokens.
   */
  function tokenByIndex(uint256 index) external view returns (uint256) {
    if (index >= totalSupply()) {
      revert ERC721OutOfBoundsIndex(address(0), index);
    }
    return _allTokens[index];
  }

  /**
   * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
   * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
   */
  function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256) {
    if (index >= balanceOf(owner)) {
      revert ERC721OutOfBoundsIndex(owner, index);
    }
    return _ownedTokens[owner][index];
  }

  /**
   * @dev Returns the address of the owner of the token with the given ID
   * @param _tokenId Token ID
   * @return address Owner address
   */
  function ownerOf(uint256 _tokenId) external view requireMinted(_tokenId) returns (address) {
    return _ownerOf(_tokenId);
  }

  /**
   * @dev Internal function returning the token owner
   * @param _tokenId Token ID
   * @return address Owner address
   */
  function _ownerOf(uint256 _tokenId) internal view returns (address) {
    return _owners[_tokenId];
  }

  /**
   * @dev Creates a new NFT token and assigns it to a specific address
   * @param _to Address of the new token recipient
   */
  function mint(address _to) external onlyLocker {
    _owners[nextId] = _to;

    emit Transfer(address(0), _to, nextId);

    unchecked {
      _balances[_to] += 1;
    }

    _addTokenToAllTokensEnumeration(nextId);
    _addTokenToOwnerEnumeration(_to, nextId);

    unchecked {
      nextId = nextId + 1;
    }
  }

  /**
   * @dev Destroys (burns) the specified NFT token
   * @param _tokenId ID of the token to destroy
   */
  function burn(uint256 _tokenId) external requireMinted(_tokenId) onlyLocker {
    address owner = _ownerOf(_tokenId);

    _removeTokenFromOwnerEnumeration(owner, _tokenId);
    _removeTokenFromAllTokensEnumeration(_tokenId);

    unchecked {
      _balances[owner] -= 1;
    }
    _owners[_tokenId] = address(0);
    _tokenApprovals[_tokenId] = address(0);

    emit Transfer(owner, address(0), _tokenId);
  }

  /**
   * @dev Approves another address to manage a specific token
   * @param _to Address to be approved
   * @param _tokenId Token ID
   */
  function approve(
    address _to,
    uint256 _tokenId
  ) external requireMinted(_tokenId) onlyOwner(_tokenId) {
    emit Approval(msg.sender, _to, _tokenId);
    _tokenApprovals[_tokenId] = _to;
  }

  /**
   * @dev Returns the approved address for a specific token
   * @param _tokenId Token ID
   * @return address Approved address
   */
  function getApproved(uint256 _tokenId) external view requireMinted(_tokenId) returns (address) {
    return _tokenApprovals[_tokenId];
  }

  /**
   * @dev Sets or removes approval for an operator to manage all of the owner's tokens
   * @param _operator Operator address
   * @param _approved Whether the operator is approved
   */
  function setApprovalForAll(address _operator, bool _approved) public {
    if (_operator == address(0)) {
      revert ERC721InvalidOperator(_operator);
    }
    emit ApprovalForAll(msg.sender, _operator, _approved);
    _operatorApprovals[msg.sender][_operator] = _approved;
  }

  /**
   * @dev Checks if an address is an approved operator for the owner
   * @param _owner Owner address
   * @param _operator Operator address
   * @return bool Whether the operator is approved
   */
  function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
    return _operatorApprovals[_owner][_operator];
  }

  /**
   * @dev Transfers token ownership from one address to another
   * @param _from Address from which the token is being transferred
   * @param _to Address to which the token is being transferred
   * @param _tokenId ID of the token being transferred
   */
  function transferFrom(address _from, address _to, uint256 _tokenId) public {
    if (_to == address(0)) {
      revert ERC721InvalidAddress(_to);
    }
    _checkAuthorized(msg.sender, _tokenId);

    if (_from != _ownerOf(_tokenId)) {
      revert ERC721NonexistentToken(_tokenId);
    }

    if (_from != _to) {
      if (_from != address(0)) {
        _removeTokenFromOwnerEnumeration(_from, _tokenId);
        unchecked {
          _balances[_from] -= 1;
        }
      }

      if (_to != address(0)) {
        unchecked {
          _balances[_to] += 1;
        }
        _addTokenToOwnerEnumeration(_to, _tokenId);
      }
    }

    _tokenApprovals[_tokenId] = address(0);

    _owners[_tokenId] = _to;

    emit Transfer(_from, _to, _tokenId);
  }

  /**
   * @dev Safely transfers token ownership, checking if the recipient can receive tokens
   * @param _from Address from which the token is being transferred
   * @param _to Address to which the token is being transferred
   * @param _tokenId ID of the token being transferred
   */
  function safeTransferFrom(address _from, address _to, uint256 _tokenId) public {
    transferFrom(_from, _to, _tokenId);
    _checkOnERC721Received(_from, _to, _tokenId, '');
  }

  /**
   * @dev Safely transfers token ownership, checking if the recipient can receive tokens
   * @param _from Address from which the token is being transferred
   * @param _to Address to which the token is being transferred
   * @param _tokenId ID of the token being transferred
   * @param _data Additional data passed to the recipient
   */
  function safeTransferFrom(
    address _from,
    address _to,
    uint256 _tokenId,
    bytes calldata _data
  ) public {
    transferFrom(_from, _to, _tokenId);
    _checkOnERC721Received(_from, _to, _tokenId, _data);
  }

  /**
   * @dev Checks if the operator is authorized to manage the token
   * @param _operator Operator address
   * @param _tokenId Token ID
   */
  function _checkAuthorized(address _operator, uint256 _tokenId) internal view {
    address tokenOwner = _owners[_tokenId];
    bool isOwner = tokenOwner == _operator;
    bool isApproved = _tokenApprovals[_tokenId] == _operator;
    bool approvedForAll = _operatorApprovals[tokenOwner][_operator];
    require(isOwner || isApproved || approvedForAll, 'Access denied');
  }

  /**
   * @dev Checks if the recipient contract address properly handles receiving ERC721 tokens
   * @param _from Sender address
   * @param _to Recipient address
   * @param _tokenId Token ID
   * @param _data Additional data
   */
  function _checkOnERC721Received(
    address _from,
    address _to,
    uint256 _tokenId,
    bytes memory _data
  ) private {
    if (_to.code.length > 0) {
      try IERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data) returns (
        bytes4 retval
      ) {
        if (retval != IERC721Receiver.onERC721Received.selector) {
          revert ERC721InvalidReceiver(_to);
        }
      } catch (bytes memory reason) {
        if (reason.length == 0) {
          revert ERC721InvalidReceiver(_to);
        } else {
          /// @solidity memory-safe-assembly
          assembly {
            revert(add(32, reason), mload(reason))
          }
        }
      }
    }
  }

  /**
   * @dev Private function to add a token to this extension's ownership-tracking data structures.
   * @param to address representing the new owner of the given token ID
   * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
   */
  function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
    uint256 length = balanceOf(to) - 1;
    _ownedTokens[to][length] = tokenId;
    _ownedTokensIndex[tokenId] = length;
  }

  /**
   * @dev Private function to add a token to this extension's token tracking structures
   * @param tokenId ID of the token to be added to the tokens list
   */
  function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
    _allTokensIndex[tokenId] = _allTokens.length;
    _allTokens.push(tokenId);
  }

  /**
   * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
   * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
   * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
   * This has O(1) time complexity, but alters the order of the _ownedTokens array.
   * @param from address representing the previous owner of the given token ID
   * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
   */
  function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
    // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
    // then delete the last slot (swap and pop).

    uint256 lastTokenIndex = balanceOf(from) -1;
    uint256 tokenIndex = _ownedTokensIndex[tokenId];

    mapping(uint256 index => uint256) storage _ownedTokensByOwner = _ownedTokens[from];

    // When the token to delete is the last token, the swap operation is unnecessary
    if (tokenIndex != lastTokenIndex) {
      uint256 lastTokenId = _ownedTokensByOwner[lastTokenIndex];

      _ownedTokensByOwner[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
      _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
    }

    // This also deletes the contents at the last position of the array
    delete _ownedTokensIndex[tokenId];
    delete _ownedTokensByOwner[lastTokenIndex];
  }

  /**
   * @dev Private function to remove a token from this extension's token tracking data structures.
   * This has O(1) time complexity, but alters the order of the _allTokens array.
   * @param tokenId uint256 ID of the token to be removed from the tokens list
   */
  function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
    // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
    // then delete the last slot (swap and pop).

    uint256 lastTokenIndex = _allTokens.length - 1;
    uint256 tokenIndex = _allTokensIndex[tokenId];

    // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
    // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
    // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
    uint256 lastTokenId = _allTokens[lastTokenIndex];

    _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
    _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

    // This also deletes the contents at the last position of the array
    delete _allTokensIndex[tokenId];
    _allTokens.pop();
  }
}

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

import '@openzeppelin/contracts/utils/ReentrancyGuard.sol';
import '../LockerPass.sol';
import '../types/types.sol';

abstract contract AbstractLocker is ReentrancyGuard {
  // NFT contract representing lock positions
  LockerPass public lockerPass;

  // Mapping of LockTier to lock period in seconds
  mapping(LockTier => uint256) private lockPeriods;

  // Error for unconfigured lock positions
  string private constant ERRNOTCONFIGURED = 'Lock position not configured.';

  // Event for when a lock is extended
  event LockExtended(uint256 indexed positionId, LockTier newLockTier, uint256 newUnlockAt);

  constructor(address _lockerPassAddress) {
    lockerPass = LockerPass(_lockerPassAddress);
    _initLockPeriods();
  }

  /**
   * @dev Modifier restricting access to lock position owner
   * @param _account Address claiming to be the owner
   * @param _positionId ID of the lock position
   */
  modifier onlyPositionOwner(address _account, uint256 _positionId) {
    require(lockerPass.ownerOf(_positionId) == _account, 'Access denied');
    (, uint256 createdAt, , ) = _getPositionInfo(_positionId);
    require(createdAt != 0, ERRNOTCONFIGURED);
    _;
  }

  /**
   * @notice Unlocks assets and returns them to the owner
   * @dev Can only be called by the owner of the lock position after the lock period has passed
   * @param _positionId ID of the lock position to unlock
   */
  function unlock(
    uint256 _positionId
  ) external nonReentrant onlyPositionOwner(msg.sender, _positionId) {
    (, , uint256 currentUnlockAt,) = _getPositionInfo(
      _positionId
    );
    require(currentUnlockAt <= block.timestamp, 'You can\'t unlock yet!');
    _unlock(_positionId);
  }

  /**
   * @notice Extends an existing lock with a new period
   * @param _positionId ID of the lock position to extend
   * @param _newLockTier New lock period
   */
  function extendLock(
    uint256 _positionId,
    LockTier _newLockTier
  ) external nonReentrant onlyPositionOwner(msg.sender, _positionId) {
    (, , uint256 currentUnlockAt, bool isLinearLock) = _getPositionInfo(
      _positionId
    );

    if (isLinearLock) {
      require(_newLockTier != LockTier.FOREVER, 'Linear lock cannot be forever');
    }

    uint256 lockPeriod = _getLockPeriod(_newLockTier);
    uint256 newUnlockAt;

    if (_newLockTier == LockTier.FOREVER) {
      newUnlockAt = type(uint256).max;
    } else {
      if (currentUnlockAt <= block.timestamp) {
        newUnlockAt = block.timestamp + lockPeriod;
      } else {
        newUnlockAt = currentUnlockAt + lockPeriod;
      }
    }

    _updateLock(_positionId, _newLockTier, newUnlockAt);

    emit LockExtended(_positionId, _newLockTier, newUnlockAt);
  }

  function _unlock(uint256 _positionId) internal virtual;

  function _getPositionInfo(
    uint256 _positionId
  )
    internal
    view
    virtual
    returns (LockTier lockTier, uint256 createdAt, uint256 unlockAt, bool isLinearLock);

  function _updateLock(
    uint256 _positionId,
    LockTier _newLockTier,
    uint256 _newUnlockAt
  ) internal virtual;

  /**
   * @dev Internal function converting lock period to actual period in seconds
   * @param _tier Lock period chosen by the user
   * @return uint256 Lock period in seconds
   */
  function _getLockPeriod(LockTier _tier) internal view returns (uint256) {
    uint256 period = lockPeriods[_tier];
    require(period > 0, 'Invalid lock tier');
    return period;
  }

  // Initialize lock periods mapping
  function _initLockPeriods() private {
    lockPeriods[LockTier.SEVEN_DAYS] = LOCK_PERIOD_7_DAYS;
    lockPeriods[LockTier.FOURTEEN_DAYS] = LOCK_PERIOD_14_DAYS;
    lockPeriods[LockTier.ONE_MONTH] = LOCK_PERIOD_1_MONTH;
    lockPeriods[LockTier.THREE_MONTHS] = LOCK_PERIOD_3_MONTHS;
    lockPeriods[LockTier.SIX_MONTHS] = LOCK_PERIOD_6_MONTHS;
    lockPeriods[LockTier.NINE_MONTHS] = LOCK_PERIOD_9_MONTHS;
    lockPeriods[LockTier.ONE_YEAR] = LOCK_PERIOD_1_YEAR;
    lockPeriods[LockTier.TWO_YEARS] = LOCK_PERIOD_2_YEARS;
    lockPeriods[LockTier.THREE_YEARS] = LOCK_PERIOD_3_YEARS;
    lockPeriods[LockTier.FOUR_YEARS] = LOCK_PERIOD_4_YEARS;
    lockPeriods[LockTier.FOREVER] = LOCK_PERIOD_FOREVER;
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

/// @title LockType
/// @notice Enum representing different types of locks
enum LockType {
    STANDARD, // Standard lock - everything unlocked after the time has passed
    LINEAR // Linear unlocking - gradual unlocking for ERC-20
}

/// @title LockTier
/// @notice Enum representing different lock periods
enum LockTier {
    SEVEN_DAYS,
    FOURTEEN_DAYS,
    ONE_MONTH,
    THREE_MONTHS,
    SIX_MONTHS,
    NINE_MONTHS,
    ONE_YEAR,
    TWO_YEARS,
    THREE_YEARS,
    FOUR_YEARS,
    FOREVER
}

// Lock period constants in seconds
uint256 constant LOCK_PERIOD_7_DAYS = 7 days;
uint256 constant LOCK_PERIOD_14_DAYS = 14 days;
uint256 constant LOCK_PERIOD_1_MONTH = 30 days;
uint256 constant LOCK_PERIOD_3_MONTHS = 90 days;
uint256 constant LOCK_PERIOD_6_MONTHS = 180 days;
uint256 constant LOCK_PERIOD_9_MONTHS = 270 days;
uint256 constant LOCK_PERIOD_1_YEAR = 365 days;
uint256 constant LOCK_PERIOD_2_YEARS = 730 days;
uint256 constant LOCK_PERIOD_3_YEARS = 1095 days;
uint256 constant LOCK_PERIOD_4_YEARS = 1460 days;
uint256 constant LOCK_PERIOD_FOREVER = type(uint256).max;

/// @title ERC20LockedAsset
/// @notice Structure representing locked ERC20 asset
/// @param tokenAddress Address of token contract
/// @param initialAmount Initial amount of locked tokens
/// @param currentAmount Current amount of locked tokens
/// @param lockType Type of lock (standard or linear)
/// @param createdAt Timestamp of creation of the lock
/// @param unlockAt Timestamp when the lock can be unlocked
/// @param lockTier Lock period
/// @param lastWithdrawalAt Timestamp of the last withdrawal (used only for linear lock)
struct ERC20LockedAsset {
    address tokenAddress;
    uint256 initialAmount;
    uint256 currentAmount;
    LockType lockType;
    uint256 createdAt;
    uint256 unlockAt;
    LockTier lockTier;
    uint256 lastWithdrawalAt;
}

/// @title ERC721LockedAsset
/// @notice Structure representing locked ERC721 asset
/// @param tokenAddress Address of token contract
/// @param tokenId ID of token
/// @param createdAt Timestamp of creation of the lock
/// @param unlockAt Timestamp when the lock can be unlocked
/// @param lockTier Lock period
struct ERC721LockedAsset {
    address tokenAddress;
    uint256 tokenId;
    uint256 createdAt;
    uint256 unlockAt;
    LockTier lockTier;
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_lockerPassAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"positionId","type":"uint256"},{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"enum LockTier","name":"lockTier","type":"uint8"}],"name":"ERC721Locked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"positionId","type":"uint256"},{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721Unlocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"positionId","type":"uint256"},{"indexed":false,"internalType":"enum LockTier","name":"newLockTier","type":"uint8"},{"indexed":false,"internalType":"uint256","name":"newUnlockAt","type":"uint256"}],"name":"LockExtended","type":"event"},{"inputs":[{"internalType":"uint256","name":"_positionId","type":"uint256"},{"internalType":"enum LockTier","name":"_newLockTier","type":"uint8"}],"name":"extendLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenAddress","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"enum LockTier","name":"_lockTier","type":"uint8"}],"name":"lockERC721","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"lockedAssets","outputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"createdAt","type":"uint256"},{"internalType":"uint256","name":"unlockAt","type":"uint256"},{"internalType":"enum LockTier","name":"lockTier","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockerPass","outputs":[{"internalType":"contract LockerPass","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"_positionId","type":"uint256"}],"name":"unlock","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000267b83bcdf57f05216945308c78565cc9396dce7

-----Decoded View---------------
Arg [0] : _lockerPassAddress (address): 0x267B83BCDF57f05216945308c78565cC9396DcE7

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000267b83bcdf57f05216945308c78565cc9396dce7