Add extensions for erc20, erc721, and erc1155 (#126)

* Fix super()

* Update

* Fix standards with functions

* Add erc20, erc721, and erc1155 extensions

* Fix duplicate functions

Author: adam-maj

thirdweb/contracts/custom.py

@@ -7,7 +7,6 @@
 from thirdweb.abi.token_erc20 import TokenERC20
 from thirdweb.abi.token_erc721 import TokenERC721
 from thirdweb.common.error import NoSignerException
-from thirdweb.common.feature_detection import matches_interface
 from thirdweb.constants.role import ALL_ROLES
 from thirdweb.core.classes.base_contract import BaseContract
 from thirdweb.core.classes.contract_metadata import ContractMetadata
@@ -152,65 +151,37 @@ def call(self, fn: str, *args) -> Any:
     """
 
     def _detect_roles(self):
-        interface_to_match = self._get_interface_functions(IPermissionsEnumerable.abi())
-
-        if matches_interface(self.functions, interface_to_match):
-            contract_wrapper = self._get_contract_wrapper(IPermissionsEnumerable)
-            return ContractRoles(contract_wrapper, ALL_ROLES)
-        return None
+        contract_wrapper = self._get_contract_wrapper(IPermissionsEnumerable)
+        return ContractRoles(contract_wrapper, ALL_ROLES)
 
     def _detect_royalties(self):
-        interface_to_match = self._get_interface_functions(IRoyalty.abi())
-
-        if matches_interface(self.functions, interface_to_match):
-            contract_wrapper = self._get_contract_wrapper(IRoyalty)
-            metadata = ContractMetadata(
-                contract_wrapper,
-                self._storage,
-                CustomContractMetadata,
-            )
-            return ContractRoyalty(contract_wrapper, metadata)
-        return None
+        contract_wrapper = self._get_contract_wrapper(IRoyalty)
+        metadata = ContractMetadata(
+            contract_wrapper,
+            self._storage,
+            CustomContractMetadata,
+        )
+        return ContractRoyalty(contract_wrapper, metadata)
 
     def _detect_primary_sales(self):
-        interface_to_match = self._get_interface_functions(IPrimarySale.abi())
-
-        if matches_interface(self.functions, interface_to_match):
-            contract_wrapper = self._get_contract_wrapper(IPrimarySale)
-            return ContractPrimarySale(contract_wrapper)
-        return None
+        contract_wrapper = self._get_contract_wrapper(IPrimarySale)
+        return ContractPrimarySale(contract_wrapper)
 
     def _detect_platform_fee(self):
-        interface_to_match = self._get_interface_functions(IPlatformFee.abi())
-
-        if matches_interface(self.functions, interface_to_match):
-            contract_wrapper = self._get_contract_wrapper(IPlatformFee)
-            return ContractPlatformFee(contract_wrapper)
-        return None
+        contract_wrapper = self._get_contract_wrapper(IPlatformFee)
+        return ContractPlatformFee(contract_wrapper)
 
     def _detect_erc_20(self):
-        interface_to_match = self._get_interface_functions(TokenERC20.abi())
-
-        if matches_interface(self.functions, interface_to_match):
-            contract_wrapper = self._get_contract_wrapper(TokenERC20)
-            return ERC20(contract_wrapper, self._storage)
-        return None
+        contract_wrapper = self._get_contract_wrapper(TokenERC20)
+        return ERC20(contract_wrapper, self._storage)
 
     def _detect_erc_721(self):
-        interface_to_match = self._get_interface_functions(TokenERC721.abi())
-
-        if matches_interface(self.functions, interface_to_match):
-            contract_wrapper = self._get_contract_wrapper(TokenERC721)
-            return ERC721(contract_wrapper, self._storage)
-        return None
+        contract_wrapper = self._get_contract_wrapper(TokenERC721)
+        return ERC721(contract_wrapper, self._storage)
 
     def _detect_erc_1155(self):
-        interface_to_match = self._get_interface_functions(TokenERC1155.abi())
-
-        if matches_interface(self.functions, interface_to_match):
-            contract_wrapper = self._get_contract_wrapper(TokenERC1155)
-            return ERC1155(contract_wrapper, self._storage)
-        return None
+        contract_wrapper = self._get_contract_wrapper(TokenERC1155)
+        return ERC1155(contract_wrapper, self._storage)
 
     def _get_interface_functions(self, abi: str) -> ContractFunctions:
         return (

thirdweb/contracts/edition.py

@@ -94,9 +94,7 @@ def mint(
         :returns: receipt, id, and metadata of the mint
         """
 
-        return self.mint_to(
-            self._contract_wrapper.get_signer_address(), metadata_with_supply
-        )
+        return self._erc1155.mint(metadata_with_supply)
 
     def mint_to(
         self, to: str, metadata_with_supply: EditionMetadataInput
@@ -129,18 +127,7 @@ def mint_to(
         :returns: receipt, id, and metadata of the mint
         """
 
-        uri = upload_or_extract_uri(metadata_with_supply.metadata, self._storage)
-        receipt = self._contract_wrapper.send_transaction(
-            "mint_to", [to, int(MAX_INT, 16), uri, metadata_with_supply.supply]
-        )
-        events = self._contract_wrapper.get_events("TransferSingle", receipt)
-
-        if len(events) == 0:
-            raise Exception("No TransferSingle event found")
-
-        id = events[0].get("args").get("id")  # type: ignore
-
-        return TxResultWithId(receipt, id=id, data=lambda: self.get(id))
+        return self._erc1155.mint_to(to, metadata_with_supply)
 
     def mint_additional_supply(
         self, token_id: int, additional_supply: int
@@ -153,9 +140,7 @@ def mint_additional_supply(
         :returns: receipt, id, and metadata of the mint
         """
 
-        return self.mint_additional_supply_to(
-            self._contract_wrapper.get_signer_address(), token_id, additional_supply
-        )
+        return self._erc1155.mint_additional_supply(token_id, additional_supply)
 
     def mint_additional_supply_to(
         self, to: str, token_id: int, additional_supply: int
@@ -169,11 +154,7 @@ def mint_additional_supply_to(
         :returns: receipt, id, and metadata of the mint
         """
 
-        metadata = self._erc1155._get_token_metadata(token_id)
-        receipt = self._contract_wrapper.send_transaction(
-            "mint_to", [to, token_id, metadata.uri, additional_supply]
-        )
-        return TxResultWithId(receipt, id=token_id, data=lambda: self.get(token_id))
+        return self._erc1155.mint_additional_supply_to(to, token_id, additional_supply)
 
     def mint_batch(
         self, metadatas_with_supply: List[EditionMetadataInput]
@@ -185,9 +166,7 @@ def mint_batch(
         :returns: receipts, ids, and metadatas of the mint
         """
 
-        return self.mint_batch_to(
-            self._contract_wrapper.get_signer_address(), metadatas_with_supply
-        )
+        return self._erc1155.mint_batch(metadatas_with_supply)
 
     def mint_batch_to(
         self, to: str, metadatas_with_supply: List[EditionMetadataInput]
@@ -230,28 +209,4 @@ def mint_batch_to(
         :returns: receipts, ids, and metadatas of the mint
         """
 
-        metadatas = [a.metadata for a in metadatas_with_supply]
-        supplies = [a.supply for a in metadatas_with_supply]
-        uris = upload_or_extract_uris(metadatas, self._storage)
-
-        encoded = []
-        interface = self._contract_wrapper.get_contract_interface()
-        for index, uri in enumerate(uris):
-            encoded.append(
-                interface.encodeABI(
-                    "mintTo", [to, int(MAX_INT, 16), uri, supplies[index]]
-                )
-            )
-
-        receipt = self._contract_wrapper.multi_call(encoded)
-        events = self._contract_wrapper.get_events("TokensMinted", receipt)
-
-        if len(events) == 0 and len(events) < len(metadatas):
-            raise Exception("No TokensMinted event found, minting failed")
-
-        results = []
-        for event in events:
-            id = event.get("args").get("tokenIdMinted")  # type: ignore
-            results.append(TxResultWithId(receipt, id=id, data=lambda: self.get(id)))
-
-        return results
+        return self._erc1155.mint_batch_to(to, metadatas_with_supply)

thirdweb/contracts/edition_drop.py

@@ -2,8 +2,6 @@
 
 from web3 import Web3
 from thirdweb.abi import DropERC1155
-from thirdweb.abi.drop_erc721 import IDropAllowlistProof
-from thirdweb.common.claim_conditions import prepare_claim
 from thirdweb.constants.role import Role
 from thirdweb.core.classes.contract_events import ContractEvents
 from thirdweb.core.classes.contract_metadata import ContractMetadata
@@ -15,15 +13,13 @@
 from thirdweb.core.classes.erc_1155_standard import ERC1155Standard
 from thirdweb.core.classes.ipfs_storage import IpfsStorage
 from thirdweb.types.contract import ContractType
-from thirdweb.types.contracts.claim_conditions import ClaimVerification
 from thirdweb.types.nft import NFTMetadata, NFTMetadataInput
 from thirdweb.types.sdk import SDKOptions
 from thirdweb.types.settings.metadata import EditionDropContractMetadata
 from eth_account.account import LocalAccount
 from thirdweb.core.classes.drop_erc1155_claim_conditions import (
     DropERC1155ClaimConditions,
 )
-from zero_ex.contract_wrappers.tx_params import TxParams
 from thirdweb.types.tx import TxResultWithId
 from web3.eth import TxReceipt
 
@@ -123,41 +119,7 @@ def create_batch(
         :return: List of tx results with ids for created NFTs.
         """
 
-        start_file_number = (
-            self._contract_wrapper._contract_abi.next_token_id_to_mint.call()
-        )
-        batch = self._storage.upload_metadata_batch(
-            [metadata.to_json() for metadata in metadatas],
-            start_file_number,
-            self._contract_wrapper._contract_abi.contract_address,
-            self._contract_wrapper.get_signer_address(),
-        )
-        base_uri = batch.base_uri
-
-        receipt = self._contract_wrapper.send_transaction(
-            "lazy_mint",
-            [
-                len(batch.metadata_uris),
-                base_uri if base_uri.endswith("/") else base_uri + "/",
-                Web3.toBytes(text=""),
-            ],
-        )
-
-        events = self._contract_wrapper.get_events("TokensLazyMinted", receipt)
-        start_index = events[0].get("args").get("startTokenId")  # type: ignore
-        ending_index = events[0].get("args").get("endTokenId")  # type: ignore
-        results = []
-
-        for id in range(start_index, ending_index + 1):
-            results.append(
-                TxResultWithId(
-                    receipt,
-                    id=id,
-                    data=lambda: self._erc1155._get_token_metadata(id),
-                )
-            )
-
-        return results
+        return self._erc1155.create_batch(metadatas)
 
     def claim_to(
         self,
@@ -186,29 +148,7 @@ def claim_to(
         :return: tx receipt of the claim
         """
 
-        claim_verification = self._prepare_claim(token_id, quantity)
-        overrides: TxParams = TxParams(value=claim_verification.value)
-
-        proof = IDropAllowlistProof(
-            proof=claim_verification.proofs,
-            quantityLimitPerWallet=claim_verification.max_claimable,
-            pricePerToken=claim_verification.price_in_proof,
-            currency=claim_verification.currency_address_in_proof
-        )
-
-        return self._contract_wrapper.send_transaction(
-            "claim",
-            [
-                destination_address,
-                token_id,
-                quantity,
-                claim_verification.currency_address,
-                claim_verification.price,
-                proof,
-                "",
-            ],
-            overrides
-        )
+        return self._erc1155.claim_to(destination_address, token_id, quantity)
 
     def claim(
         self,
@@ -223,30 +163,4 @@ def claim(
         :param proofs: List of merkle proofs.
         :return: tx receipt of the claim
         """
-        return self.claim_to(
-            self._contract_wrapper.get_signer_address(),
-            token_id,
-            quantity,
-        )
-
-    """
-    INTERNAL FUNCTIONS
-    """
-
-    def _prepare_claim(
-        self,
-        token_id: int,
-        quantity: int,
-    ) -> ClaimVerification:
-        address_to_claim = self._contract_wrapper.get_signer_address()
-        active = self.claim_conditions.get_active(token_id)
-        merkle_metadata = self.metadata.get().merkle
-
-        return prepare_claim(
-            address_to_claim,
-            quantity,
-            active,
-            merkle_metadata,
-            self._contract_wrapper,
-            self._storage,
-        )
+        return self._erc1155.claim(token_id, quantity)

thirdweb/contracts/nft_collection.py

@@ -132,7 +132,7 @@ def mint(
         :returns: receipt, id, and metadata for the mint
         """
 
-        return self.mint_to(self._contract_wrapper.get_signer_address(), metadata)
+        return self._erc721.mint(metadata)
 
     def mint_to(
         self, to: str, metadata: Union[NFTMetadataInput, str]
@@ -162,16 +162,7 @@ def mint_to(
         :returns: receipt, id, and metadata for the mint
         """
 
-        uri = upload_or_extract_uri(metadata, self._storage)
-        receipt = self._contract_wrapper.send_transaction("mint_to", [to, uri])
-        events = self._contract_wrapper.get_events("Transfer", receipt)
-
-        if len(events) == 0:
-            raise Exception("No Transfer event found")
-
-        id = events[0].get("args").get("tokenId")  # type: ignore
-
-        return TxResultWithId(receipt, id=id, data=lambda: self.get(id))
+        return self._erc721.mint_to(to, metadata)
 
     def mint_batch(
         self, metadatas: List[Union[NFTMetadataInput, str]]
@@ -183,9 +174,7 @@ def mint_batch(
         :returns: receipts, ids, and metadatas for each mint
         """
 
-        return self.mint_batch_to(
-            self._contract_wrapper.get_signer_address(), metadatas
-        )
+        return self._erc721.mint_batch(metadatas)
 
     def mint_batch_to(
         self, to: str, metadatas: List[Union[NFTMetadataInput, str]]
@@ -222,22 +211,4 @@ def mint_batch_to(
         :returns: receipts, ids, and metadatas for each mint
         """
 
-        uris = upload_or_extract_uris(metadatas, self._storage)
-
-        encoded = []
-        interface = self._contract_wrapper.get_contract_interface()
-        for uri in uris:
-            encoded.append(interface.encodeABI("mintTo", [to, uri]))
-
-        receipt = self._contract_wrapper.multi_call(encoded)
-        events = self._contract_wrapper.get_events("TokensMinted", receipt)
-
-        if len(events) == 0 or len(events) < len(metadatas):
-            raise Exception("No TokensMinted event found, minting failed")
-
-        results = []
-        for event in events:
-            id = event.get("args").get("tokenIdMinted")  # type: ignore
-            results.append(TxResultWithId(receipt, id=id, data=lambda: self.get(id)))
-
-        return results
+        return self._erc721.mint_batch_to(to, metadatas)