@rarible/external-contracts 3.11.4

package/contracts/extension/upgradeable/BatchMintMetadata.sol

@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+library BatchMintMetadataStorage {
+    /// @custom:storage-location erc7201:batch.mint.metadata.storage
+    /// @dev keccak256(abi.encode(uint256(keccak256("batch.mint.metadata.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 public constant BATCH_MINT_METADATA_STORAGE_POSITION =
+        0xf5b99f0648d517803cfbd359284c3fd81ac54e1c89b4874d917ae042d05e8500;
+
+    struct Data {
+        /// @dev Largest tokenId of each batch of tokens with the same baseURI.
+        uint256[] batchIds;
+        /// @dev Mapping from id of a batch of tokens => to base URI for the respective batch of tokens.
+        mapping(uint256 => string) baseURI;
+        /// @dev Mapping from id of a batch of tokens => to whether the base URI for the respective batch of tokens is frozen.
+        mapping(uint256 => bool) batchFrozen;
+    }
+
+    function data() internal pure returns (Data storage data_) {
+        bytes32 position = BATCH_MINT_METADATA_STORAGE_POSITION;
+        assembly {
+            data_.slot := position
+        }
+    }
+}
+
+/**
+ *  @title   Batch-mint Metadata
+ *  @notice  The `BatchMintMetadata` is a contract extension for any base NFT contract. It lets the smart contract
+ *           using this extension set metadata for `n` number of NFTs all at once. This is enabled by storing a single
+ *           base URI for a batch of `n` NFTs, where the metadata for each NFT in a relevant batch is `baseURI/tokenId`.
+ */
+
+contract BatchMintMetadata {
+    /// @dev This event emits when the metadata of all tokens are frozen.
+    /// While not currently supported by marketplaces, this event allows
+    /// future indexing if desired.
+    event MetadataFrozen();
+
+    // @dev This event emits when the metadata of a range of tokens is updated.
+    /// So that the third-party platforms such as NFT market could
+    /// timely update the images and related attributes of the NFTs.
+    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
+
+    /**
+     *  @notice         Returns the count of batches of NFTs.
+     *  @dev            Each batch of tokens has an in ID and an associated `baseURI`.
+     *                  See {batchIds}.
+     */
+    function getBaseURICount() public view returns (uint256) {
+        return _batchMintMetadataStorage().batchIds.length;
+    }
+
+    /**
+     *  @notice         Returns the ID for the batch of tokens the given tokenId belongs to.
+     *  @dev            See {getBaseURICount}.
+     *  @param _index   ID of a token.
+     */
+    function getBatchIdAtIndex(uint256 _index) public view returns (uint256) {
+        if (_index >= getBaseURICount()) {
+            revert("Invalid index");
+        }
+        return _batchMintMetadataStorage().batchIds[_index];
+    }
+
+    /// @dev Returns the id for the batch of tokens the given tokenId belongs to.
+    function _getBatchId(uint256 _tokenId) internal view returns (uint256 batchId, uint256 index) {
+        uint256 numOfTokenBatches = getBaseURICount();
+        uint256[] memory indices = _batchMintMetadataStorage().batchIds;
+
+        for (uint256 i = 0; i < numOfTokenBatches; i += 1) {
+            if (_tokenId < indices[i]) {
+                index = i;
+                batchId = indices[i];
+
+                return (batchId, index);
+            }
+        }
+
+        revert("Invalid tokenId");
+    }
+
+    /// @dev Returns the baseURI for a token. The intended metadata URI for the token is baseURI + tokenId.
+    function _getBaseURI(uint256 _tokenId) internal view returns (string memory) {
+        uint256 numOfTokenBatches = getBaseURICount();
+        uint256[] memory indices = _batchMintMetadataStorage().batchIds;
+
+        for (uint256 i = 0; i < numOfTokenBatches; i += 1) {
+            if (_tokenId < indices[i]) {
+                return _batchMintMetadataStorage().baseURI[indices[i]];
+            }
+        }
+        revert("Invalid tokenId");
+    }
+
+    /// @dev returns the starting tokenId of a given batchId.
+    function _getBatchStartId(uint256 _batchID) internal view returns (uint256) {
+        uint256 numOfTokenBatches = getBaseURICount();
+        uint256[] memory indices = _batchMintMetadataStorage().batchIds;
+
+        for (uint256 i = 0; i < numOfTokenBatches; i++) {
+            if (_batchID == indices[i]) {
+                if (i > 0) {
+                    return indices[i - 1];
+                }
+                return 0;
+            }
+        }
+        revert("Invalid batchId");
+    }
+
+    /// @dev Sets the base URI for the batch of tokens with the given batchId.
+    function _setBaseURI(uint256 _batchId, string memory _baseURI) internal {
+        require(!_batchMintMetadataStorage().batchFrozen[_batchId], "Batch frozen");
+        _batchMintMetadataStorage().baseURI[_batchId] = _baseURI;
+        emit BatchMetadataUpdate(_getBatchStartId(_batchId), _batchId);
+    }
+
+    /// @dev Freezes the base URI for the batch of tokens with the given batchId.
+    function _freezeBaseURI(uint256 _batchId) internal {
+        string memory baseURIForBatch = _batchMintMetadataStorage().baseURI[_batchId];
+        require(bytes(baseURIForBatch).length > 0, "Invalid batch");
+        _batchMintMetadataStorage().batchFrozen[_batchId] = true;
+        emit MetadataFrozen();
+    }
+
+    /// @dev Mints a batch of tokenIds and associates a common baseURI to all those Ids.
+    function _batchMintMetadata(
+        uint256 _startId,
+        uint256 _amountToMint,
+        string memory _baseURIForTokens
+    ) internal returns (uint256 nextTokenIdToMint, uint256 batchId) {
+        batchId = _startId + _amountToMint;
+        nextTokenIdToMint = batchId;
+
+        _batchMintMetadataStorage().batchIds.push(batchId);
+        _batchMintMetadataStorage().baseURI[batchId] = _baseURIForTokens;
+    }
+
+    /// @dev Returns the BatchMintMetadata storage.
+    function _batchMintMetadataStorage() internal pure returns (BatchMintMetadataStorage.Data storage data) {
+        data = BatchMintMetadataStorage.data();
+    }
+}

package/contracts/extension/upgradeable/BurnToClaim.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import { ERC1155Burnable } from "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
+import { ERC721Burnable } from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
+
+import "../../eip/interface/IERC1155.sol";
+import "../../eip/interface/IERC721.sol";
+
+import "../interface/IBurnToClaim.sol";
+
+library BurnToClaimStorage {
+    /// @custom:storage-location erc7201:burn.to.claim.storage
+    /// @dev keccak256(abi.encode(uint256(keccak256("burn.to.claim.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 public constant BURN_TO_CLAIM_STORAGE_POSITION =
+        0x6f0d20bed2d5528732497d5a17ac45087a6175b2a140eebe2a39ab447d7ad400;
+
+    struct Data {
+        IBurnToClaim.BurnToClaimInfo burnToClaimInfo;
+    }
+
+    function data() internal pure returns (Data storage data_) {
+        bytes32 position = BURN_TO_CLAIM_STORAGE_POSITION;
+        assembly {
+            data_.slot := position
+        }
+    }
+}
+
+abstract contract BurnToClaim is IBurnToClaim {
+    /// @notice Returns the confugration for burning tokens to claim new tokens.
+    function getBurnToClaimInfo() public view returns (BurnToClaimInfo memory) {
+        return _burnToClaimStorage().burnToClaimInfo;
+    }
+
+    /// @notice Sets the configuration for burning tokens to claim new tokens.
+    function setBurnToClaimInfo(BurnToClaimInfo calldata _burnToClaimInfo) external virtual {
+        require(_canSetBurnToClaim(), "Not authorized.");
+        require(_burnToClaimInfo.originContractAddress != address(0), "Origin contract not set.");
+        require(_burnToClaimInfo.currency != address(0), "Currency not set.");
+
+        _burnToClaimStorage().burnToClaimInfo = _burnToClaimInfo;
+    }
+
+    /// @notice Verifies an attempt to burn tokens to claim new tokens.
+    function verifyBurnToClaim(address _tokenOwner, uint256 _tokenId, uint256 _quantity) public view virtual {
+        BurnToClaimInfo memory _burnToClaimInfo = getBurnToClaimInfo();
+
+        if (_burnToClaimInfo.tokenType == IBurnToClaim.TokenType.ERC721) {
+            require(_quantity == 1, "Invalid amount");
+            require(IERC721(_burnToClaimInfo.originContractAddress).ownerOf(_tokenId) == _tokenOwner, "!Owner");
+        } else if (_burnToClaimInfo.tokenType == IBurnToClaim.TokenType.ERC1155) {
+            uint256 _eligible1155TokenId = _burnToClaimInfo.tokenId;
+
+            require(_tokenId == _eligible1155TokenId, "Invalid token Id");
+            require(
+                IERC1155(_burnToClaimInfo.originContractAddress).balanceOf(_tokenOwner, _tokenId) >= _quantity,
+                "!Balance"
+            );
+        }
+    }
+
+    /// @dev Burns tokens to claim new tokens.
+    function _burnTokensOnOrigin(address _tokenOwner, uint256 _tokenId, uint256 _quantity) internal virtual {
+        BurnToClaimInfo memory _burnToClaimInfo = getBurnToClaimInfo();
+
+        if (_burnToClaimInfo.tokenType == IBurnToClaim.TokenType.ERC721) {
+            ERC721Burnable(_burnToClaimInfo.originContractAddress).burn(_tokenId);
+        } else if (_burnToClaimInfo.tokenType == IBurnToClaim.TokenType.ERC1155) {
+            ERC1155Burnable(_burnToClaimInfo.originContractAddress).burn(_tokenOwner, _tokenId, _quantity);
+        }
+    }
+
+    /// @dev Returns the BurnToClaimStorage storage.
+    function _burnToClaimStorage() internal pure returns (BurnToClaimStorage.Data storage data) {
+        data = BurnToClaimStorage.data();
+    }
+
+    /// @dev Returns whether the caller can set the burn to claim configuration.
+    function _canSetBurnToClaim() internal view virtual returns (bool);
+}

package/contracts/extension/upgradeable/ContractMetadata.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "../interface/IContractMetadata.sol";
+
+/**
+ *  @author  thirdweb.com
+ *
+ *  @title   Contract Metadata
+ *  @notice  Thirdweb's `ContractMetadata` is a contract extension for any base contracts. It lets you set a metadata URI
+ *           for you contract.
+ *           Additionally, `ContractMetadata` is necessary for NFT contracts that want royalties to get distributed on OpenSea.
+ */
+
+library ContractMetadataStorage {
+    /// @custom:storage-location erc7201:contract.metadata.storage
+    /// @dev keccak256(abi.encode(uint256(keccak256("contract.metadata.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 public constant CONTRACT_METADATA_STORAGE_POSITION =
+        0x4bc804ba64359c0e35e5ed5d90ee596ecaa49a3a930ddcb1470ea0dd625da900;
+
+    struct Data {
+        /// @notice Returns the contract metadata URI.
+        string contractURI;
+    }
+
+    function data() internal pure returns (Data storage data_) {
+        bytes32 position = CONTRACT_METADATA_STORAGE_POSITION;
+        assembly {
+            data_.slot := position
+        }
+    }
+}
+
+abstract contract ContractMetadata is IContractMetadata {
+    /**
+     *  @notice         Lets a contract admin set the URI for contract-level metadata.
+     *  @dev            Caller should be authorized to setup contractURI, e.g. contract admin.
+     *                  See {_canSetContractURI}.
+     *                  Emits {ContractURIUpdated Event}.
+     *
+     *  @param _uri     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
+     */
+    function setContractURI(string memory _uri) external override {
+        if (!_canSetContractURI()) {
+            revert("Not authorized");
+        }
+
+        _setupContractURI(_uri);
+    }
+
+    /// @dev Lets a contract admin set the URI for contract-level metadata.
+    function _setupContractURI(string memory _uri) internal {
+        string memory prevURI = _contractMetadataStorage().contractURI;
+        _contractMetadataStorage().contractURI = _uri;
+
+        emit ContractURIUpdated(prevURI, _uri);
+    }
+
+    /// @notice Returns the contract metadata URI.
+    function contractURI() public view virtual override returns (string memory) {
+        return _contractMetadataStorage().contractURI;
+    }
+
+    /// @dev Returns the AccountPermissions storage.
+    function _contractMetadataStorage() internal pure returns (ContractMetadataStorage.Data storage data) {
+        data = ContractMetadataStorage.data();
+    }
+
+    /// @dev Returns whether contract metadata can be set in the given execution context.
+    function _canSetContractURI() internal view virtual returns (bool);
+}

package/contracts/extension/upgradeable/DelayedReveal.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "../interface/IDelayedReveal.sol";
+
+library DelayedRevealStorage {
+    /// @custom:storage-location erc7201:delayed.reveal.storage
+    ///@dev keccak256(abi.encode(uint256(keccak256("delayed.reveal.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 public constant DELAYED_REVEAL_STORAGE_POSITION =
+        0x29cbb6a3768b42f407b01945994a37861bf5a2179c5dea5be7e378415e755100;
+
+    struct Data {
+        /// @dev Mapping from tokenId of a batch of tokens => to delayed reveal data.
+        mapping(uint256 => bytes) encryptedData;
+    }
+
+    function data() internal pure returns (Data storage data_) {
+        bytes32 position = DELAYED_REVEAL_STORAGE_POSITION;
+        assembly {
+            data_.slot := position
+        }
+    }
+}
+
+/**
+ *  @title   Delayed Reveal
+ *  @notice  Thirdweb's `DelayedReveal` is a contract extension for base NFT contracts. It lets you create batches of
+ *           'delayed-reveal' NFTs. You can learn more about the usage of delayed reveal NFTs here - https://blog.thirdweb.com/delayed-reveal-nfts
+ */
+
+abstract contract DelayedReveal is IDelayedReveal {
+    /// @dev Mapping from tokenId of a batch of tokens => to delayed reveal data.
+    function encryptedData(uint256 _tokenId) public view returns (bytes memory) {
+        return _delayedRevealStorage().encryptedData[_tokenId];
+    }
+
+    /// @dev Sets the delayed reveal data for a batchId.
+    function _setEncryptedData(uint256 _batchId, bytes memory _encryptedData) internal {
+        _delayedRevealStorage().encryptedData[_batchId] = _encryptedData;
+    }
+
+    /**
+     *  @notice             Returns revealed URI for a batch of NFTs.
+     *  @dev                Reveal encrypted base URI for `_batchId` with caller/admin's `_key` used for encryption.
+     *                      Reverts if there's no encrypted URI for `_batchId`.
+     *                      See {encryptDecrypt}.
+     *
+     *  @param _batchId     ID of the batch for which URI is being revealed.
+     *  @param _key         Secure key used by caller/admin for encryption of baseURI.
+     *
+     *  @return revealedURI Decrypted base URI.
+     */
+    function getRevealURI(uint256 _batchId, bytes calldata _key) public view returns (string memory revealedURI) {
+        bytes memory dataForBatch = _delayedRevealStorage().encryptedData[_batchId];
+        if (dataForBatch.length == 0) {
+            revert("Nothing to reveal");
+        }
+
+        (bytes memory encryptedURI, bytes32 provenanceHash) = abi.decode(dataForBatch, (bytes, bytes32));
+
+        revealedURI = string(encryptDecrypt(encryptedURI, _key));
+
+        require(keccak256(abi.encodePacked(revealedURI, _key, block.chainid)) == provenanceHash, "Incorrect key");
+    }
+
+    /**
+     *  @notice         Encrypt/decrypt data on chain.
+     *  @dev            Encrypt/decrypt given `data` with `key`. Uses inline assembly.
+     *                  See: https://ethereum.stackexchange.com/questions/69825/decrypt-message-on-chain
+     *
+     *  @param data     Bytes of data to encrypt/decrypt.
+     *  @param key      Secure key used by caller for encryption/decryption.
+     *
+     *  @return result  Output after encryption/decryption of given data.
+     */
+    function encryptDecrypt(bytes memory data, bytes calldata key) public pure override returns (bytes memory result) {
+        // Store data length on stack for later use
+        uint256 length = data.length;
+
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            // Set result to free memory pointer
+            result := mload(0x40)
+            // Increase free memory pointer by lenght + 32
+            mstore(0x40, add(add(result, length), 32))
+            // Set result length
+            mstore(result, length)
+        }
+
+        // Iterate over the data stepping by 32 bytes
+        for (uint256 i = 0; i < length; i += 32) {
+            // Generate hash of the key and offset
+            bytes32 hash = keccak256(abi.encodePacked(key, i));
+
+            bytes32 chunk;
+            // solhint-disable-next-line no-inline-assembly
+            assembly {
+                // Read 32-bytes data chunk
+                chunk := mload(add(data, add(i, 32)))
+            }
+            // XOR the chunk with hash
+            chunk ^= hash;
+            // solhint-disable-next-line no-inline-assembly
+            assembly {
+                // Write 32-byte encrypted chunk
+                mstore(add(result, add(i, 32)), chunk)
+            }
+        }
+    }
+
+    /**
+     *  @notice         Returns whether the relvant batch of NFTs is subject to a delayed reveal.
+     *  @dev            Returns `true` if `_batchId`'s base URI is encrypted.
+     *  @param _batchId ID of a batch of NFTs.
+     */
+    function isEncryptedBatch(uint256 _batchId) public view returns (bool) {
+        return _delayedRevealStorage().encryptedData[_batchId].length > 0;
+    }
+
+    /// @dev Returns the DelayedReveal storage.
+    function _delayedRevealStorage() internal pure returns (DelayedRevealStorage.Data storage data) {
+        data = DelayedRevealStorage.data();
+    }
+}