ERC4907

contracts/ERC721A.sol

@@ -598,7 +598,7 @@ contract ERC721A is IERC721A {
     /**
      * @dev Returns whether the `approvedAddress` is equals to `from` or `msgSender`.
      */
-    function _isOwnerOrApproved(
+    function _isSinglyApprovedOrOwner(
         address approvedAddress,
         address from,
         address msgSender
@@ -613,6 +613,18 @@ contract ERC721A is IERC721A {
         }
     }
 
+    /**
+     * @dev Returns whether `spender` is allowed to manage `tokenId`.
+     *
+     * Requirements:
+     *
+     * - `tokenId` must exist.
+     */
+    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
+        address owner = ownerOf(tokenId);
+        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
+    }
+
     /**
      * @dev Transfers `tokenId` from `from` to `to`.
      *
@@ -635,7 +647,7 @@ contract ERC721A is IERC721A {
         (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedAddress(tokenId);
 
         // The nested ifs save around 20+ gas over a compound boolean condition.
-        if (!_isOwnerOrApproved(approvedAddress, from, _msgSenderERC721A()))
+        if (!_isSinglyApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
             if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
 
         if (to == address(0)) revert TransferToZeroAddress();
@@ -712,7 +724,7 @@ contract ERC721A is IERC721A {
 
         if (approvalCheck) {
             // The nested ifs save around 20+ gas over a compound boolean condition.
-            if (!_isOwnerOrApproved(approvedAddress, from, _msgSenderERC721A()))
+            if (!_isSinglyApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
                 if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
         }
 

contracts/extensions/ERC4907A.sol

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: MIT
+// ERC721A Contracts v4.1.0
+// Creator: Chiru Labs
+
+pragma solidity ^0.8.4;
+
+import './IERC4907A.sol';
+import '../ERC721A.sol';
+
+/**
+ * @dev ERC4907 compliant extension of ERC721A.
+ *
+ * The ERC4907 standard https://eips.ethereum.org/EIPS/eip-4907[ERC4907] allows
+ * owners and authorized addresses to add a time-limited role
+ * with restricted permissions to ERC721 tokens.
+ */
+abstract contract ERC4907A is ERC721A, IERC4907A {
+    // The bit position of `expires` in packed user info.
+    uint256 private constant _BITPOS_EXPIRES = 160;
+
+    // Mapping from token ID to user info.
+    //
+    // Bits Layout:
+    // - [0..159]   `user`
+    // - [160..223] `expires`
+    mapping(uint256 => uint256) private _packedUserInfo;
+
+    /**
+     * @dev Sets the `user` and `expires` for `tokenId`.
+     * The zero address indicates there is no user.
+     *
+     * Requirements:
+     *
+     * - The caller must own `tokenId` or be an approved operator.
+     */
+    function setUser(
+        uint256 tokenId,
+        address user,
+        uint64 expires
+    ) public {
+        if (!_isApprovedOrOwner(msg.sender, tokenId)) revert SetUserCallerNotOwnerNorApproved();
+
+        _packedUserInfo[tokenId] = (uint256(expires) << _BITPOS_EXPIRES) | uint256(uint160(user));
+
+        emit UpdateUser(tokenId, user, expires);
+    }
+
+    /**
+     * @dev Returns the user address for `tokenId`.
+     * The zero address indicates that there is no user or if the user is expired.
+     */
+    function userOf(uint256 tokenId) public view returns (address) {
+        uint256 packed = _packedUserInfo[tokenId];
+        assembly {
+            let expiry := shr(_BITPOS_EXPIRES, packed)
+            // `expires >= block.timestamp ? 1 : 0`.
+            let notExpired := iszero(lt(expiry, timestamp()))
+            // Set `packed` to zero if the user has expired.
+            packed := mul(packed, notExpired)
+        }
+        return address(uint160(packed));
+    }
+
+    /**
+     * @dev Returns the user's expires of `tokenId`.
+     */
+    function userExpires(uint256 tokenId) public view returns (uint256) {
+        return _packedUserInfo[tokenId] >> _BITPOS_EXPIRES;
+    }
+
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, IERC721A) returns (bool) {
+        // The interface ID for ERC4907 is `0xad092b5c`.
+        // See: https://eips.ethereum.org/EIPS/eip-4907
+        return super.supportsInterface(interfaceId) || interfaceId == 0xad092b5c;
+    }
+
+    /**
+     * @dev Returns the user address for `tokenId`, ignoring the expiry status.
+     */
+    function _explicitUserOf(uint256 tokenId) internal view returns (address) {
+        return address(uint160(_packedUserInfo[tokenId]));
+    }
+
+    /**
+     * @dev Overrides the `_beforeTokenTransfers` hook to clear the user info upon transfer.
+     */
+    function _beforeTokenTransfers(
+        address from,
+        address to,
+        uint256 startTokenId,
+        uint256 quantity
+    ) internal virtual override {
+        super._beforeTokenTransfers(from, to, startTokenId, quantity);
+
+        bool mayNeedClearing;
+        // For branchless boolean. Saves 60+ gas.
+        assembly {
+            // The amount of bits to left shift to clear the upper bits of addresses.
+            let addrShift := sub(256, _BITPOS_EXPIRES)
+            // Equivalent to `quantity == 1 && !(from == address(0) || from == to)`.
+            let isMint := iszero(shl(addrShift, from))
+            let fromEqTo := eq(shl(addrShift, from), shl(addrShift, to))
+            mayNeedClearing := and(eq(quantity, 1), iszero(or(isMint, fromEqTo)))
+        }
+
+        if (mayNeedClearing)
+            if (_packedUserInfo[startTokenId] != 0) {
+                delete _packedUserInfo[startTokenId];
+                emit UpdateUser(startTokenId, address(0), 0);
+            }
+    }
+}

contracts/extensions/IERC4907A.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+// ERC721A Contracts v4.1.0
+// Creator: Chiru Labs
+
+pragma solidity ^0.8.4;
+
+import '../IERC721A.sol';
+
+/**
+ * @dev Interface of an ERC4907A compliant contract.
+ */
+interface IERC4907A is IERC721A {
+    /**
+     * The caller must own the token or be an approved operator.
+     */
+    error SetUserCallerNotOwnerNorApproved();
+
+    /**
+     * @dev Emitted when the `user` of an NFT or the `expires` of the `user` is changed.
+     * The zero address for user indicates that there is no user address.
+     */
+    event UpdateUser(uint256 indexed tokenId, address indexed user, uint64 expires);
+
+    /**
+     * @dev Sets the `user` and `expires` for `tokenId`.
+     * The zero address indicates there is no user.
+     *
+     * Requirements:
+     *
+     * - The caller must own `tokenId` or be an approved operator.
+     */
+    function setUser(
+        uint256 tokenId,
+        address user,
+        uint64 expires
+    ) external;
+
+    /**
+     * @dev Returns the user address for `tokenId`.
+     * The zero address indicates that there is no user or if the user is expired.
+     */
+    function userOf(uint256 tokenId) external view returns (address);
+
+    /**
+     * @dev Returns the user's expires of `tokenId`.
+     */
+    function userExpires(uint256 tokenId) external view returns (uint256);
+}

contracts/interfaces/IERC4907A.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+// ERC721A Contracts v4.1.0
+// Creator: Chiru Labs
+
+pragma solidity ^0.8.4;
+
+import '../extensions/IERC4907A.sol';

contracts/mocks/ERC4907AMock.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+// ERC721A Contracts v4.1.0
+// Creators: Chiru Labs
+
+pragma solidity ^0.8.4;
+
+import '../extensions/ERC4907A.sol';
+
+contract ERC4907AMock is ERC721A, ERC4907A {
+    constructor(string memory name_, string memory symbol_) ERC721A(name_, symbol_) {}
+
+    function safeMint(address to, uint256 quantity) public {
+        _safeMint(to, quantity);
+    }
+
+    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC4907A) returns (bool) {
+        return super.supportsInterface(interfaceId);
+    }
+
+    function _beforeTokenTransfers(
+        address from,
+        address to,
+        uint256 startTokenId,
+        uint256 quantity
+    ) internal virtual override(ERC721A, ERC4907A) {
+        super._beforeTokenTransfers(from, to, startTokenId, quantity);
+    }
+
+    function explicitUserOf(uint256 tokenId) public view returns (address) {
+        return _explicitUserOf(tokenId);
+    }
+}