Refactor LazyMint bases (#233)

* refactor ERC721LazyMint and ERC1155LazyMint

* update tests

* run prettier

* remove data param from claim

* ERC721Drop: nextTokenIdToClaim

* run prettier

Author: kumaryash90

contracts/base/ERC1155DelayedReveal.sol

@@ -5,10 +5,10 @@ import "./ERC1155LazyMint.sol";
 import "../extension/DelayedReveal.sol";
 
 /**
- *      BASE:      ERC1155Base
- *      EXTENSION: LazyMint, DelayedReveal
+ *      BASE:      ERC1155LazyMint
+ *      EXTENSION: DelayedReveal
  *
- *  The `ERC1155DelayedReveal` contract uses the `ERC1155Base` contract, along with the `LazyMint` and `DelayedReveal` extension.
+ *  The `ERC1155DelayedReveal` contract uses the `DelayedReveal` extension.
  *
  *  'Lazy minting' means defining the metadata of NFTs without minting it to an address. Regular 'minting'
  *  of  NFTs means actually assigning an owner to an NFT.

contracts/base/ERC1155LazyMint.sol

@@ -1,14 +1,40 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.0;
 
-import "./ERC1155Base.sol";
+import { ERC1155 } from "../eip/ERC1155.sol";
+
+import "../extension/ContractMetadata.sol";
+import "../extension/Multicall.sol";
+import "../extension/Ownable.sol";
+import "../extension/Royalty.sol";
+import "../extension/BatchMintMetadata.sol";
 import "../extension/LazyMint.sol";
 
+import "../lib/TWStrings.sol";
+
 /**
  *      BASE:      ERC1155Base
  *      EXTENSION: LazyMint
  *
- *  The `ERC1155LazyMint` contract uses the `ERC1155Base` contract, along with the `LazyMint` extension.
+ *  The `ERC1155LazyMint` smart contract implements the ERC1155 NFT standard.
+ *  It includes the following additions to standard ERC1155 logic:
+ *
+ *      - Lazy minting
+ *
+ *      - Ability to mint NFTs via the provided `mintTo` and `batchMintTo` functions.
+ *
+ *      - Contract metadata for royalty support on platforms such as OpenSea that use
+ *        off-chain information to distribute roaylties.
+ *
+ *      - Ownership of the contract, with the ability to restrict certain functions to
+ *        only be called by the contract's owner.
+ *
+ *      - Multicall capability to perform multiple actions atomically
+ *
+ *      - EIP 2981 compliance for royalty support on NFT marketplaces.
+ *
+ *
+ *  The `ERC1155LazyMint` contract uses the `LazyMint` extension.
  *
  *  'Lazy minting' means defining the metadata of NFTs without minting it to an address. Regular 'minting'
  *  of  NFTs means actually assigning an owner to an NFT.
@@ -18,7 +44,19 @@ import "../extension/LazyMint.sol";
  *
  */
 
-contract ERC1155LazyMint is ERC1155Base, LazyMint {
+contract ERC1155LazyMint is ERC1155, ContractMetadata, Ownable, Royalty, Multicall, BatchMintMetadata, LazyMint {
+    using TWStrings for uint256;
+
+    /*//////////////////////////////////////////////////////////////
+                        Mappings
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @notice Returns the total supply of NFTs of a given tokenId
+     *  @dev Mapping from tokenId => total circulating supply of NFTs of that tokenId.
+     */
+    mapping(uint256 => uint256) public totalSupply;
+
     /*//////////////////////////////////////////////////////////////
                             Constructor
     //////////////////////////////////////////////////////////////*/
@@ -28,59 +66,127 @@ contract ERC1155LazyMint is ERC1155Base, LazyMint {
         string memory _symbol,
         address _royaltyRecipient,
         uint128 _royaltyBps
-    ) ERC1155Base(_name, _symbol, _royaltyRecipient, _royaltyBps) {}
+    ) ERC1155(_name, _symbol) {
+        _setupOwner(msg.sender);
+        _setupDefaultRoyaltyInfo(_royaltyRecipient, _royaltyBps);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                    Overriden metadata logic
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Returns the metadata URI for the given tokenId.
+    function uri(uint256 _tokenId) public view virtual override returns (string memory) {
+        string memory batchUri = getBaseURI(_tokenId);
+        return string(abi.encodePacked(batchUri, _tokenId.toString()));
+    }
 
     /*//////////////////////////////////////////////////////////////
-                        OVERRIDEN MINT LOGIC
+                            CLAIM LOGIC
     //////////////////////////////////////////////////////////////*/
 
     /**
-     *  @notice          Lets an authorized address mint lazy minted NFTs to a recipient.
-     *  @dev             - The logic in the `_canMint` function determines whether the caller is authorized to mint NFTs.
+     *  @notice          Lets an address claim multiple lazy minted NFTs at once to a recipient.
+     *                   Contract creators should override this function to create custom logic for claiming,
+     *                   for e.g. price collection, allowlist, max quantity, etc.
      *
-     *  @param _to       The recipient of the NFTs to mint.
-     *  @param _tokenId  The tokenId of the lazy minted NFT to mint.
-     *  @param _amount   The amount of the same NFT to mint.
+     *  @dev             The logic in the `verifyClaim` function determines whether the caller is authorized to mint NFTs.
+     *
+     *  @param _receiver  The recipient of the tokens to mint.
+     *  @param _tokenId   The tokenId of the lazy minted NFT to mint.
+     *  @param _quantity  The number of tokens to mint.
      */
-    function mintTo(
-        address _to,
+    function claim(
+        address _receiver,
         uint256 _tokenId,
-        string memory,
-        uint256 _amount
-    ) public virtual override {
-        require(_canMint(), "Not authorized to mint.");
+        uint256 _quantity
+    ) public payable virtual {
+        verifyClaim(msg.sender, _tokenId, _quantity); // add your claim verification logic by overriding this function
+
         require(_tokenId < nextTokenIdToMint(), "invalid id");
 
-        _mint(_to, _tokenId, _amount, "");
+        _mint(_receiver, _tokenId, _quantity, "");
     }
 
     /**
-     *  @notice          Lets an authorized address mint multiple lazy minted NFTs at once to a recipient.
-     *  @dev             The logic in the `_canMint` function determines whether the caller is authorized to mint NFTs.
+     *  @notice          Override this function to add logic for claim verification, based on conditions
+     *                   such as allowlist, price, max quantity etc.
+     *
+     *  @dev             Checks a request to claim NFTs against a custom condition.
+     *
+     *  @param _claimer   Caller of the claim function.
+     *  @param _tokenId   The tokenId of the lazy minted NFT to mint.
+     *  @param _quantity  The number of NFTs being claimed.
+     */
+    function verifyClaim(
+        address _claimer,
+        uint256 _tokenId,
+        uint256 _quantity
+    ) public view virtual {}
+
+    /**
+     *  @notice         Lets an owner or approved operator burn NFTs of the given tokenId.
      *
-     *  @param _to       The recipient of the NFT to mint.
-     *  @param _tokenIds The tokenIds of the NFTs to mint.
-     *  @param _amounts  The amounts of each NFT to mint.
+     *  @param _owner   The owner of the NFT to burn.
+     *  @param _tokenId The tokenId of the NFT to burn.
+     *  @param _amount  The amount of the NFT to burn.
      */
-    function batchMintTo(
-        address _to,
+    function burn(
+        address _owner,
+        uint256 _tokenId,
+        uint256 _amount
+    ) external virtual {
+        address caller = msg.sender;
+
+        require(caller == _owner || isApprovedForAll[_owner][caller], "Unapproved caller");
+        require(balanceOf[_owner][_tokenId] >= _amount, "Not enough tokens owned");
+
+        _burn(_owner, _tokenId, _amount);
+    }
+
+    /**
+     *  @notice         Lets an owner or approved operator burn NFTs of the given tokenIds.
+     *
+     *  @param _owner    The owner of the NFTs to burn.
+     *  @param _tokenIds The tokenIds of the NFTs to burn.
+     *  @param _amounts  The amounts of the NFTs to burn.
+     */
+    function burnBatch(
+        address _owner,
         uint256[] memory _tokenIds,
-        uint256[] memory _amounts,
-        string memory
-    ) public virtual override {
-        require(_canMint(), "Not authorized to mint.");
-        require(_amounts.length > 0, "Minting zero tokens.");
+        uint256[] memory _amounts
+    ) external virtual {
+        address caller = msg.sender;
+
+        require(caller == _owner || isApprovedForAll[_owner][caller], "Unapproved caller");
         require(_tokenIds.length == _amounts.length, "Length mismatch");
 
         for (uint256 i = 0; i < _tokenIds.length; i += 1) {
-            require(_tokenIds[i] < nextTokenIdToMint(), "invalid id");
+            require(balanceOf[_owner][_tokenIds[i]] >= _amounts[i], "Not enough tokens owned");
         }
 
-        _mintBatch(_to, _tokenIds, _amounts, "");
+        _burnBatch(_owner, _tokenIds, _amounts);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                            ERC165 Logic
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Returns whether this contract supports the given interface.
+    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, IERC165) returns (bool) {
+        return
+            interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
+            interfaceId == 0xd9b67a26 || // ERC165 Interface ID for ERC1155
+            interfaceId == 0x0e89341c || // ERC165 Interface ID for ERC1155MetadataURI
+            interfaceId == type(IERC2981).interfaceId; // ERC165 ID for ERC2981
     }
 
+    /*//////////////////////////////////////////////////////////////
+                            View functions
+    //////////////////////////////////////////////////////////////*/
+
     /// @notice The tokenId assigned to the next new NFT to be lazy minted.
-    function nextTokenIdToMint() public view virtual override returns (uint256) {
+    function nextTokenIdToMint() public view virtual returns (uint256) {
         return nextTokenIdToLazyMint;
     }
 
@@ -92,4 +198,43 @@ contract ERC1155LazyMint is ERC1155Base, LazyMint {
     function _canLazyMint() internal view virtual override returns (bool) {
         return msg.sender == owner();
     }
+
+    /// @dev Returns whether contract metadata can be set in the given execution context.
+    function _canSetContractURI() internal view virtual override returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Returns whether owner can be set in the given execution context.
+    function _canSetOwner() internal view virtual override returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Returns whether royalty info can be set in the given execution context.
+    function _canSetRoyaltyInfo() internal view virtual override returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Runs before every token transfer / mint / burn.
+    function _beforeTokenTransfer(
+        address operator,
+        address from,
+        address to,
+        uint256[] memory ids,
+        uint256[] memory amounts,
+        bytes memory data
+    ) internal virtual override {
+        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
+
+        if (from == address(0)) {
+            for (uint256 i = 0; i < ids.length; ++i) {
+                totalSupply[ids[i]] += amounts[i];
+            }
+        }
+
+        if (to == address(0)) {
+            for (uint256 i = 0; i < ids.length; ++i) {
+                totalSupply[ids[i]] -= amounts[i];
+            }
+        }
+    }
 }

contracts/base/ERC721DelayedReveal.sol

@@ -6,10 +6,10 @@ import "./ERC721LazyMint.sol";
 import "../extension/DelayedReveal.sol";
 
 /**
- *      BASE:      ERC721Base
- *      EXTENSION: LazyMint, DelayedReveal
+ *      BASE:      ERC721LazyMint
+ *      EXTENSION: DelayedReveal
  *
- *  The `ERC721DelayedReveal` contract uses the `ERC721Base` contract, along with the `LazyMint` and `DelayedReveal` extension.
+ *  The `ERC721DelayedReveal` contract uses the `ERC721LazyMint` contract, along with `DelayedReveal` extension.
  *
  *  'Lazy minting' means defining the metadata of NFTs without minting it to an address. Regular 'minting'
  *  of  NFTs means actually assigning an owner to an NFT.

contracts/base/ERC721Drop.sol

@@ -137,6 +137,11 @@ contract ERC721Drop is
         return nextTokenIdToLazyMint;
     }
 
+    /// @notice The tokenId assigned to the next new NFT to be claimed.
+    function nextTokenIdToClaim() public view virtual returns (uint256) {
+        return _currentIndex;
+    }
+
     /*///////////////////////////////////////////////////////////////
                         Delayed reveal logic
     //////////////////////////////////////////////////////////////*/