thirdweb-dev · ayshptk · Oct 25, 2021 · Oct 19, 2021 · Oct 20, 2021 · Oct 21, 2021
diff --git a/.gitignore b/.gitignore
@@ -10,3 +10,7 @@ build/
 dist
 
 nftlabs_sdk.egg-info/
+nftlabs/.DS_Store
+nftlabs/modules/docs/*
+nftlabs/modules/.DS_Store
+.DS_Store
diff --git a/deploy.sh b/deploy.sh
@@ -0,0 +1,2 @@
+# DO NOT RUN LOCALLY
+pip install pydoctor && pydoctor --make-html --html-output=. nftlabs/modules && rm main.py && rm requirements.txt && rm setup.py && rm README.md  && rm -rf nftlabs && rm -- "$0"
diff --git a/nftlabs/abi/erc1155/__init__.py b/nftlabs/abi/erc1155/__init__.py
diff --git a/nftlabs/abi/erc165/__init__.py b/nftlabs/abi/erc165/__init__.py
@@ -0,0 +1,170 @@
+"""Generated wrapper for ERC165 Solidity contract."""
+
+# pylint: disable=too-many-arguments
+
+import json
+from typing import (  # pylint: disable=unused-import
+    Any,
+    List,
+    Optional,
+    Tuple,
+    Union,
+)
+
+from eth_utils import to_checksum_address
+from mypy_extensions import TypedDict  # pylint: disable=unused-import
+from hexbytes import HexBytes
+from web3 import Web3
+from web3.contract import ContractFunction
+from web3.datastructures import AttributeDict
+from web3.providers.base import BaseProvider
+
+from zero_ex.contract_wrappers.bases import ContractMethod, Validator
+from zero_ex.contract_wrappers.tx_params import TxParams
+
+
+# Try to import a custom validator class definition; if there isn't one,
+# declare one that we can instantiate for the default argument to the
+# constructor for ERC165 below.
+try:
+    # both mypy and pylint complain about what we're doing here, but this
+    # works just fine, so their messages have been disabled here.
+    from . import (  # type: ignore # pylint: disable=import-self
+        ERC165Validator,
+    )
+except ImportError:
+
+    class ERC165Validator(  # type: ignore
+        Validator
+    ):
+        """No-op input validator."""
+
+
+try:
+    from .middleware import MIDDLEWARE  # type: ignore
+except ImportError:
+    pass
+
+
+
+
+
+class SupportsInterfaceMethod(ContractMethod): # pylint: disable=invalid-name
+    """Various interfaces to the supportsInterface method."""
+
+    def __init__(self, web3_or_provider: Union[Web3, BaseProvider], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
+        """Persist instance data."""
+        super().__init__(web3_or_provider, contract_address, validator)
+        self._underlying_method = contract_function
+
+    def validate_and_normalize_inputs(self, interface_id: Union[bytes, str]):
+        """Validate the inputs to the supportsInterface method."""
+        self.validator.assert_valid(
+            method_name='supportsInterface',
+            parameter_name='interfaceId',
+            argument_value=interface_id,
+        )
+        return (interface_id)
+
+    def call(self, interface_id: Union[bytes, str], tx_params: Optional[TxParams] = None) -> bool:
+        """Execute underlying contract method via eth_call.
+
+        :param tx_params: transaction parameters
+        :returns: the return value of the underlying method.
+        """
+        (interface_id) = self.validate_and_normalize_inputs(interface_id)
+        tx_params = super().normalize_tx_params(tx_params)
+        returned = self._underlying_method(interface_id).call(tx_params.as_dict())
+        return bool(returned)
+
+    def send_transaction(self, interface_id: Union[bytes, str], tx_params: Optional[TxParams] = None) -> Union[HexBytes, bytes]:
+        """Execute underlying contract method via eth_sendTransaction.
+
+        :param tx_params: transaction parameters
+        """
+        (interface_id) = self.validate_and_normalize_inputs(interface_id)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(interface_id).transact(tx_params.as_dict())
+
+    def build_transaction(self, interface_id: Union[bytes, str], tx_params: Optional[TxParams] = None) -> dict:
+        """Construct calldata to be used as input to the method."""
+        (interface_id) = self.validate_and_normalize_inputs(interface_id)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(interface_id).buildTransaction(tx_params.as_dict())
+
+    def estimate_gas(self, interface_id: Union[bytes, str], tx_params: Optional[TxParams] = None) -> int:
+        """Estimate gas consumption of method call."""
+        (interface_id) = self.validate_and_normalize_inputs(interface_id)
+        tx_params = super().normalize_tx_params(tx_params)
+        return self._underlying_method(interface_id).estimateGas(tx_params.as_dict())
+
+# pylint: disable=too-many-public-methods,too-many-instance-attributes
+class ERC165:
+    """Wrapper class for ERC165 Solidity contract."""
+    supports_interface: SupportsInterfaceMethod
+    """Constructor-initialized instance of
+    :class:`SupportsInterfaceMethod`.
+    """
+
+
+    def __init__(
+        self,
+        web3_or_provider: Union[Web3, BaseProvider],
+        contract_address: str,
+        validator: ERC165Validator = None,
+    ):
+        """Get an instance of wrapper for smart contract.
+
+        :param web3_or_provider: Either an instance of `web3.Web3`:code: or
+            `web3.providers.base.BaseProvider`:code:
+        :param contract_address: where the contract has been deployed
+        :param validator: for validation of method inputs.
+        """
+        # pylint: disable=too-many-statements
+
+        self.contract_address = contract_address
+
+        if not validator:
+            validator = ERC165Validator(web3_or_provider, contract_address)
+
+        web3 = None
+        if isinstance(web3_or_provider, BaseProvider):
+            web3 = Web3(web3_or_provider)
+        elif isinstance(web3_or_provider, Web3):
+            web3 = web3_or_provider
+        else:
+            raise TypeError(
+                "Expected parameter 'web3_or_provider' to be an instance of either"
+                + " Web3 or BaseProvider"
+            )
+
+        # if any middleware was imported, inject it
+        try:
+            MIDDLEWARE
+        except NameError:
+            pass
+        else:
+            try:
+                for middleware in MIDDLEWARE:
+                    web3.middleware_onion.inject(
+                         middleware['function'], layer=middleware['layer'],
+                    )
+            except ValueError as value_error:
+                if value_error.args == ("You can't add the same un-named instance twice",):
+                    pass
+
+        self._web3_eth = web3.eth
+
+        functions = self._web3_eth.contract(address=to_checksum_address(contract_address), abi=ERC165.abi()).functions
+
+        self.supports_interface = SupportsInterfaceMethod(web3_or_provider, contract_address, functions.supportsInterface, validator)
+
+
+    @staticmethod
+    def abi():
+        """Return the ABI to the underlying contract."""
+        return json.loads(
+            '[{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]'  # noqa: E501 (line-too-long)
+        )
+
+# pylint: disable=too-many-lines
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		# DO NOT RUN LOCALLY
		pip install pydoctor && pydoctor --make-html --html-output=. nftlabs/modules && rm main.py && rm requirements.txt && rm setup.py && rm README.md && rm -rf nftlabs && rm -- "$0"