ERC721Drop

/**
*  @notice         Returns the metadata URI for an NFT.
*  @dev            See `BatchMintMetadata` for handling of metadata in this contract.
*
*  @param _tokenId The tokenId of an NFT.
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
    (uint256 batchId, ) = _getBatchId(_tokenId);
    string memory batchUri = _getBaseURI(_tokenId);
 
    if (isEncryptedBatch(batchId)) {
        return string(abi.encodePacked(batchUri, "0"));
    } else {
        return string(abi.encodePacked(batchUri, _tokenId.toString()));
    }
}
 

/**
*  @notice                  Lets an authorized address lazy mint a given amount of NFTs.
*
*  @param _amount           The number of NFTs to lazy mint.
*  @param _baseURIForTokens The placeholder base URI for the 'n' number of NFTs being lazy minted, where the
*                           metadata for each of those NFTs is `${baseURIForTokens}/${tokenId}`.
*  @param _data             The encrypted base URI + provenance hash for the batch of NFTs being lazy minted.
*  @return batchId          A unique integer identifier for the batch of NFTs lazy minted together.
*/
function lazyMint(
    uint256 _amount,
    string calldata _baseURIForTokens,
    bytes calldata _data
) public override returns (uint256 batchId) {
    if (_data.length > 0) {
        (bytes memory encryptedURI, bytes32 provenanceHash) = abi.decode(_data, (bytes, bytes32));
        if (encryptedURI.length != 0 && provenanceHash != "") {
            _setEncryptedData(nextTokenIdToLazyMint + _amount, _data);
        }
    }
 
    return LazyMint.lazyMint(_amount, _baseURIForTokens, _data);
}

/**
*  @notice       Lets an authorized address reveal a batch of delayed reveal NFTs.
*
*  @param _index The ID for the batch of delayed-reveal NFTs to reveal.
*  @param _key   The key with which the base URI for the relevant batch of NFTs was encrypted.
*/
function reveal(uint256 _index, bytes calldata _key) public virtual override returns (string memory revealedURI) {
    require(_canReveal(), "Not authorized");
 
    uint256 batchId = getBatchIdAtIndex(_index);
    revealedURI = getRevealURI(batchId, _key);
 
    _setEncryptedData(batchId, "");
    _setBaseURI(batchId, revealedURI);
 
    emit TokenURIRevealed(_index, revealedURI);
}

/**
*  @notice         Lets an owner or approved operator burn the NFT of the given tokenId.
*  @dev            ERC721A's `_burn(uint256,bool)` internally checks for token approvals.
*
*  @param _tokenId The tokenId of the NFT to burn.
*/
function burn(uint256 _tokenId) external virtual {
    _burn(_tokenId, true);
}

/// @dev Runs before every `claim` function call.
function _beforeClaim(
    address,
    uint256 _quantity,
    address,
    uint256,
    AllowlistProof calldata,
    bytes memory
) internal view virtual override {
    if (_currentIndex + _quantity > nextTokenIdToLazyMint) {
        revert("Not enough minted tokens");
    }
}

/// @dev Collects and distributes the primary sale value of NFTs being claimed.
function _collectPriceOnClaim(
    address _primarySaleRecipient,
    uint256 _quantityToClaim,
    address _currency,
    uint256 _pricePerToken
) internal virtual override {
    if (_pricePerToken == 0) {
        return;
    }
 
    uint256 totalPrice = _quantityToClaim * _pricePerToken;
 
    if (_currency == CurrencyTransferLib.NATIVE_TOKEN) {
        if (msg.value != totalPrice) {
            revert("Must send total price");
        }
    }
 
    address saleRecipient = _primarySaleRecipient == address(0) ? primarySaleRecipient() : _primarySaleRecipient;
    CurrencyTransferLib.transferCurrency(_currency, msg.sender, saleRecipient, totalPrice);
}

/// @dev Transfers the NFTs being claimed.
function _transferTokensOnClaim(address _to, uint256 _quantityBeingClaimed)
    internal
    virtual
    override
    returns (uint256 startTokenId)
{
    startTokenId = _currentIndex;
    _safeMint(_to, _quantityBeingClaimed);
}