Burn-to-claim drop ERC721 contract (#404)

* burn to claim drop contract

* tests

* tests for burn and claim

* more tests

* Move BurnToClaimDropERC721 to unaudited dir

---------

Co-authored-by: nkrishang <62195808+nkrishang@users.noreply.github.com>
Co-authored-by: Krishang <krishang@thirdweb.com>

Author: kumaryash90

contracts/dynamic-contracts/eip/ERC721AUpgradeable.sol

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+library BatchMintMetadataStorage {
+    bytes32 public constant BATCH_MINT_METADATA_STORAGE_POSITION = keccak256("batch.mint.metadata.storage");
+
+    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;
+    }
+
+    function batchMintMetadataStorage() internal pure returns (Data storage batchMintMetadataData) {
+        bytes32 position = BATCH_MINT_METADATA_STORAGE_POSITION;
+        assembly {
+            batchMintMetadataData.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 {
+    /**
+     *  @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) {
+        BatchMintMetadataStorage.Data storage data = BatchMintMetadataStorage.batchMintMetadataStorage();
+        return data.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) {
+        BatchMintMetadataStorage.Data storage data = BatchMintMetadataStorage.batchMintMetadataStorage();
+
+        if (_index >= getBaseURICount()) {
+            revert("Invalid index");
+        }
+        return data.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) {
+        BatchMintMetadataStorage.Data storage data = BatchMintMetadataStorage.batchMintMetadataStorage();
+
+        uint256 numOfTokenBatches = getBaseURICount();
+        uint256[] memory indices = data.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) {
+        BatchMintMetadataStorage.Data storage data = BatchMintMetadataStorage.batchMintMetadataStorage();
+
+        uint256 numOfTokenBatches = getBaseURICount();
+        uint256[] memory indices = data.batchIds;
+
+        for (uint256 i = 0; i < numOfTokenBatches; i += 1) {
+            if (_tokenId < indices[i]) {
+                return data.baseURI[indices[i]];
+            }
+        }
+        revert("Invalid tokenId");
+    }
+
+    /// @dev Sets the base URI for the batch of tokens with the given batchId.
+    function _setBaseURI(uint256 _batchId, string memory _baseURI) internal {
+        BatchMintMetadataStorage.Data storage data = BatchMintMetadataStorage.batchMintMetadataStorage();
+        data.baseURI[_batchId] = _baseURI;
+    }
+
+    /// @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.Data storage data = BatchMintMetadataStorage.batchMintMetadataStorage();
+
+        data.batchIds.push(batchId);
+        data.baseURI[batchId] = _baseURIForTokens;
+    }
+}

contracts/dynamic-contracts/extension/BatchMintMetadata.sol

@@ -0,0 +1,80 @@
+// 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 "../../extension/interface/IBurnToClaim.sol";
+
+library BurnToClaimStorage {
+    bytes32 public constant BURN_TO_CLAIM_STORAGE_POSITION = keccak256("burn.to.claim.storage");
+
+    struct Data {
+        IBurnToClaim.BurnToClaimInfo burnToClaimInfo;
+    }
+
+    function burnToClaimStorage() internal pure returns (Data storage burnToClaimData) {
+        bytes32 position = BURN_TO_CLAIM_STORAGE_POSITION;
+        assembly {
+            burnToClaimData.slot := position
+        }
+    }
+}
+
+abstract contract BurnToClaim is IBurnToClaim {
+    function getBurnToClaimInfo() public view returns (BurnToClaimInfo memory) {
+        BurnToClaimStorage.Data storage data = BurnToClaimStorage.burnToClaimStorage();
+
+        return data.burnToClaimInfo;
+    }
+
+    function setBurnToClaimInfo(BurnToClaimInfo calldata _burnToClaimInfo) external virtual {
+        require(_canSetBurnToClaim(), "Not authorized.");
+
+        BurnToClaimStorage.Data storage data = BurnToClaimStorage.burnToClaimStorage();
+        data.burnToClaimInfo = _burnToClaimInfo;
+    }
+
+    function verifyBurnToClaim(
+        address _tokenOwner,
+        uint256 _tokenId,
+        uint256 _quantity
+    ) public view virtual {
+        BurnToClaimInfo memory _burnToClaimInfo = getBurnToClaimInfo();
+        require(_burnToClaimInfo.originContractAddress != address(0), "Origin contract not set.");
+
+        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"
+            );
+        }
+    }
+
+    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);
+        }
+    }
+
+    function _canSetBurnToClaim() internal view virtual returns (bool);
+}

contracts/dynamic-contracts/extension/BurnToClaim.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache 2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import { OperatorFiltererUpgradeable } from "./OperatorFiltererUpgradeable.sol";
+
+abstract contract DefaultOperatorFiltererUpgradeable is OperatorFiltererUpgradeable {
+    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
+
+    function __DefaultOperatorFilterer_init() internal {
+        OperatorFiltererUpgradeable.__OperatorFilterer_init(DEFAULT_SUBSCRIPTION, true);
+    }
+}

contracts/dynamic-contracts/extension/DefaultOperatorFiltererUpgradeable.sol

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "../../extension/interface/IDelayedReveal.sol";
+
+library DelayedRevealStorage {
+    bytes32 public constant DELAYED_REVEAL_STORAGE_POSITION = keccak256("delayed.reveal.storage");
+
+    struct Data {
+        /// @dev Mapping from tokenId of a batch of tokens => to delayed reveal data.
+        mapping(uint256 => bytes) encryptedData;
+    }
+
+    function delayedRevealStorage() internal pure returns (Data storage delayedRevealData) {
+        bytes32 position = DELAYED_REVEAL_STORAGE_POSITION;
+        assembly {
+            delayedRevealData.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) {
+        DelayedRevealStorage.Data storage data = DelayedRevealStorage.delayedRevealStorage();
+        return data.encryptedData[_tokenId];
+    }
+
+    /// @dev Sets the delayed reveal data for a batchId.
+    function _setEncryptedData(uint256 _batchId, bytes memory _encryptedData) internal {
+        DelayedRevealStorage.Data storage data = DelayedRevealStorage.delayedRevealStorage();
+        data.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) {
+        DelayedRevealStorage.Data storage data = DelayedRevealStorage.delayedRevealStorage();
+
+        bytes memory dataForBatch = data.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) {
+        DelayedRevealStorage.Data storage data = DelayedRevealStorage.delayedRevealStorage();
+        return data.encryptedData[_batchId].length > 0;
+    }
+}