web3 7.0.0b3__py3-none-any.whl → 7.0.0b5__py3-none-any.whl

web3/contract/base_contract.py

@@ -92,7 +92,10 @@ from web3.exceptions import (
     NoABIEventsFound,
     NoABIFound,
     NoABIFunctionsFound,
+    Web3AttributeError,
+    Web3TypeError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.logs import (
     DISCARD,
@@ -125,7 +128,8 @@ if TYPE_CHECKING:
 
 
 class BaseContractEvent:
-    """Base class for contract events
+    """
+    Base class for contract events
 
     An event accessed via the api `contract.events.myEvents(*args, **kwargs)`
     is a subclass of this class.
@@ -163,7 +167,7 @@ class BaseContractEvent:
         try:
             errors.name
         except AttributeError:
-            raise AttributeError(
+            raise Web3AttributeError(
                 f"Error flag must be one of: {EventLogErrorFlags.flag_options()}"
             )
 
@@ -185,7 +189,8 @@ class BaseContractEvent:
                         f"The log with transaction hash: {log['transactionHash']!r} "
                         f"and logIndex: {log['logIndex']} encountered the following "
                         f"error during processing: {type(e).__name__}({e}). It has "
-                        "been discarded."
+                        "been discarded.",
+                        stacklevel=2,
                     )
                     continue
             yield rich_log
@@ -199,12 +204,12 @@ class BaseContractEvent:
         self,
         abi: ABIEvent,
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: Optional[BlockIdentifier] = None,
-        blockHash: Optional[HexBytes] = None,
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: Optional[BlockIdentifier] = None,
+        block_hash: Optional[HexBytes] = None,
     ) -> FilterParams:
         if not self.address:
-            raise TypeError(
+            raise Web3TypeError(
                 "This method can be only called on "
                 "an instated contract with an address"
             )
@@ -214,11 +219,12 @@ class BaseContractEvent:
 
         _filters = dict(**argument_filters)
 
-        blkhash_set = blockHash is not None
-        blknum_set = fromBlock is not None or toBlock is not None
+        blkhash_set = block_hash is not None
+        blknum_set = from_block is not None or to_block is not None
         if blkhash_set and blknum_set:
             raise Web3ValidationError(
-                "blockHash cannot be set at the same time as fromBlock or toBlock"
+                "`block_hash` cannot be set at the same time as "
+                "`from_block` or `to_block`"
             )
 
         # Construct JSON-RPC raw filter presentation based on human readable
@@ -228,13 +234,13 @@ class BaseContractEvent:
             self.w3.codec,
             contract_address=self.address,
             argument_filters=_filters,
-            fromBlock=fromBlock,
-            toBlock=toBlock,
+            from_block=from_block,
+            to_block=to_block,
             address=self.address,
         )
 
-        if blockHash is not None:
-            event_filter_params["blockHash"] = blockHash
+        if block_hash is not None:
+            event_filter_params["blockHash"] = block_hash
 
         return event_filter_params
 
@@ -251,12 +257,12 @@ class BaseContractEvent:
         for filter_name, filter_value in _filters.items():
             _input = name_indexed_inputs[filter_name]
             if is_array_type(_input["type"]):
-                raise TypeError(
+                raise Web3TypeError(
                     "createFilter no longer supports array type filter arguments. "
                     "see the build_filter method for filtering array type filters."
                 )
             if is_list_like(filter_value) and is_dynamic_sized_type(_input["type"]):
-                raise TypeError(
+                raise Web3TypeError(
                     "createFilter no longer supports setting filter argument options "
                     "for dynamic sized types. See the build_filter method for setting "
                     "filters with the match_any method."
@@ -314,15 +320,15 @@ class BaseContractEvent:
     def _set_up_filter_builder(
         self,
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: BlockIdentifier = "latest",
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: BlockIdentifier = "latest",
         address: Optional[ChecksumAddress] = None,
         topics: Optional[Sequence[Any]] = None,
         filter_builder: Union[EventFilterBuilder, AsyncEventFilterBuilder] = None,
     ) -> None:
-        if fromBlock is None:
-            raise TypeError(
-                "Missing mandatory keyword argument to create_filter: fromBlock"
+        if from_block is None:
+            raise Web3TypeError(
+                "Missing mandatory keyword argument to create_filter: `from_block`"
             )
 
         if argument_filters is None:
@@ -339,8 +345,8 @@ class BaseContractEvent:
             self.w3.codec,
             contract_address=self.address,
             argument_filters=_filters,
-            fromBlock=fromBlock,
-            toBlock=toBlock,
+            from_block=from_block,
+            to_block=to_block,
             address=address,
             topics=topics,
         )
@@ -348,8 +354,8 @@ class BaseContractEvent:
         filter_builder.address = cast(
             ChecksumAddress, event_filter_params.get("address")
         )
-        filter_builder.fromBlock = event_filter_params.get("fromBlock")
-        filter_builder.toBlock = event_filter_params.get("toBlock")
+        filter_builder.from_block = event_filter_params.get("fromBlock")
+        filter_builder.to_block = event_filter_params.get("toBlock")
         match_any_vals = {
             arg: value
             for arg, value in _filters.items()
@@ -370,7 +376,8 @@ class BaseContractEvent:
 
 
 class BaseContractEvents:
-    """Class containing contract event objects
+    """
+    Class containing contract event objects
 
     This is available via:
 
@@ -431,7 +438,8 @@ class BaseContractEvents:
         return getattr(self, event_name)
 
     def __iter__(self) -> Iterable[Type["BaseContractEvent"]]:
-        """Iterate over supported
+        """
+        Iterate over supported
 
         :return: Iterable of :class:`ContractEvent`
         """
@@ -446,7 +454,8 @@ class BaseContractEvents:
 
 
 class BaseContractFunction:
-    """Base class for contract functions
+    """
+    Base class for contract functions
 
     A function accessed via the api `contract.functions.myMethod(*args, **kwargs)`
     is a subclass of this class.
@@ -479,12 +488,9 @@ class BaseContractFunction:
         if self.function_identifier in [FallbackFn, ReceiveFn]:
             self.selector = encode_hex(b"")
         elif is_text(self.function_identifier):
-            # https://github.com/python/mypy/issues/4976
-            self.selector = encode_hex(
-                function_abi_to_4byte_selector(self.abi)  # type: ignore
-            )
+            self.selector = encode_hex(function_abi_to_4byte_selector(self.abi))
         else:
-            raise TypeError("Unsupported function identifier")
+            raise Web3TypeError("Unsupported function identifier")
 
         self.arguments = merge_args_and_kwargs(self.abi, self.args, self.kwargs)
 
@@ -495,26 +501,25 @@ class BaseContractFunction:
             call_transaction = cast(TxParams, dict(**transaction))
 
         if "data" in call_transaction:
-            raise ValueError("Cannot set 'data' field in call transaction")
+            raise Web3ValueError("Cannot set 'data' field in call transaction")
 
         if self.address:
             call_transaction.setdefault("to", self.address)
         if self.w3.eth.default_account is not empty:
-            # type ignored b/c check prevents an empty default_account
             call_transaction.setdefault(
                 "from",
-                self.w3.eth.default_account,  # type: ignore
+                self.w3.eth.default_account,
             )
 
         if "to" not in call_transaction:
             if isinstance(self, type):
-                raise ValueError(
+                raise Web3ValueError(
                     "When using `Contract.[methodtype].[method].call()` from"
                     " a contract factory you "
                     "must provide a `to` address with the transaction"
                 )
             else:
-                raise ValueError(
+                raise Web3ValueError(
                     "Please ensure that this contract instance has an address."
                 )
 
@@ -527,24 +532,21 @@ class BaseContractFunction:
             transact_transaction = cast(TxParams, dict(**transaction))
 
         if "data" in transact_transaction:
-            raise ValueError("Cannot set 'data' field in transact transaction")
+            raise Web3ValueError("Cannot set 'data' field in transact transaction")
 
         if self.address is not None:
             transact_transaction.setdefault("to", self.address)
         if self.w3.eth.default_account is not empty:
-            # type ignored b/c check prevents an empty default_account
-            transact_transaction.setdefault(
-                "from", self.w3.eth.default_account  # type: ignore
-            )
+            transact_transaction.setdefault("from", self.w3.eth.default_account)
 
         if "to" not in transact_transaction:
             if isinstance(self, type):
-                raise ValueError(
+                raise Web3ValueError(
                     "When using `Contract.transact` from a contract factory you "
                     "must provide a `to` address with the transaction"
                 )
             else:
-                raise ValueError(
+                raise Web3ValueError(
                     "Please ensure that this contract instance has an address."
                 )
         return transact_transaction
@@ -556,26 +558,23 @@ class BaseContractFunction:
             estimate_gas_transaction = cast(TxParams, dict(**transaction))
 
         if "data" in estimate_gas_transaction:
-            raise ValueError("Cannot set 'data' field in estimate_gas transaction")
+            raise Web3ValueError("Cannot set 'data' field in estimate_gas transaction")
         if "to" in estimate_gas_transaction:
-            raise ValueError("Cannot set to in estimate_gas transaction")
+            raise Web3ValueError("Cannot set to in estimate_gas transaction")
 
         if self.address:
             estimate_gas_transaction.setdefault("to", self.address)
         if self.w3.eth.default_account is not empty:
-            # type ignored b/c check prevents an empty default_account
-            estimate_gas_transaction.setdefault(
-                "from", self.w3.eth.default_account  # type: ignore
-            )
+            estimate_gas_transaction.setdefault("from", self.w3.eth.default_account)
 
         if "to" not in estimate_gas_transaction:
             if isinstance(self, type):
-                raise ValueError(
+                raise Web3ValueError(
                     "When using `Contract.estimate_gas` from a contract factory "
                     "you must provide a `to` address with the transaction"
                 )
             else:
-                raise ValueError(
+                raise Web3ValueError(
                     "Please ensure that this contract instance has an address."
                 )
         return estimate_gas_transaction
@@ -587,21 +586,23 @@ class BaseContractFunction:
             built_transaction = cast(TxParams, dict(**transaction))
 
         if "data" in built_transaction:
-            raise ValueError("Cannot set 'data' field in build transaction")
+            raise Web3ValueError("Cannot set 'data' field in build transaction")
 
         if not self.address and "to" not in built_transaction:
-            raise ValueError(
+            raise Web3ValueError(
                 "When using `ContractFunction.build_transaction` from a contract "
                 "factory you must provide a `to` address with the transaction"
             )
         if self.address and "to" in built_transaction:
-            raise ValueError("Cannot set 'to' field in contract call build transaction")
+            raise Web3ValueError(
+                "Cannot set 'to' field in contract call build transaction"
+            )
 
         if self.address:
             built_transaction.setdefault("to", self.address)
 
         if "to" not in built_transaction:
-            raise ValueError(
+            raise Web3ValueError(
                 "Please ensure that this contract instance has an address."
             )
 
@@ -679,7 +680,8 @@ class BaseContractFunctions:
 
 
 class BaseContract:
-    """Base class for Contract proxy classes.
+    """
+    Base class for Contract proxy classes.
 
     First you need to create your Contract classes using
     :meth:`web3.eth.Eth.contract` that takes compiled Solidity contract
@@ -760,7 +762,7 @@ class BaseContract:
     @combomethod
     def get_function_by_signature(self, signature: str) -> "BaseContractFunction":
         if " " in signature:
-            raise ValueError(
+            raise Web3ValueError(
                 "Function signature should not contain any spaces. "
                 f"Found spaces in input: {signature}"
             )
@@ -792,9 +794,9 @@ class BaseContract:
         self, selector: Union[bytes, int, HexStr]
     ) -> "BaseContractFunction":
         def callable_check(fn_abi: ABIFunction) -> bool:
-            # typed dict cannot be used w/ a normal Dict
-            # https://github.com/python/mypy/issues/4976
-            return encode_hex(function_abi_to_4byte_selector(fn_abi)) == to_4byte_hex(selector)  # type: ignore # noqa: E501
+            return encode_hex(function_abi_to_4byte_selector(fn_abi)) == to_4byte_hex(
+                selector
+            )
 
         fns = self.find_functions_by_identifier(
             self.abi, self.w3, self.address, callable_check
@@ -805,8 +807,7 @@ class BaseContract:
     def decode_function_input(
         self, data: HexStr
     ) -> Tuple["BaseContractFunction", Dict[str, Any]]:
-        # type ignored b/c expects data arg to be HexBytes
-        data = HexBytes(data)  # type: ignore
+        data = HexBytes(data)
         func = self.get_function_by_selector(data[:4])
         arguments = decode_transaction_data(
             func.abi, data, normalizers=BASE_RETURN_NORMALIZERS
@@ -893,7 +894,7 @@ class BaseContract:
         else:
             if args is not None or kwargs is not None:
                 msg = "Constructor args were provided, but no constructor function was provided."  # noqa: E501
-                raise TypeError(msg)
+                raise Web3TypeError(msg)
 
             deploy_data = to_hex(cls.bytecode)
 
@@ -1088,10 +1089,7 @@ class BaseContractConstructor:
             )
 
         if self.w3.eth.default_account is not empty:
-            # type ignored b/c check prevents an empty default_account
-            estimate_gas_transaction.setdefault(
-                "from", self.w3.eth.default_account  # type: ignore
-            )
+            estimate_gas_transaction.setdefault("from", self.w3.eth.default_account)
 
         estimate_gas_transaction["data"] = self.data_in_transaction
 
@@ -1107,10 +1105,7 @@ class BaseContractConstructor:
             )
 
         if self.w3.eth.default_account is not empty:
-            # type ignored b/c check prevents an empty default_account
-            transact_transaction.setdefault(
-                "from", self.w3.eth.default_account  # type: ignore
-            )
+            transact_transaction.setdefault("from", self.w3.eth.default_account)
 
         transact_transaction["data"] = self.data_in_transaction
 
@@ -1128,7 +1123,7 @@ class BaseContractConstructor:
     ) -> None:
         keys_found = transaction.keys() & forbidden_keys
         if keys_found:
-            raise ValueError(
+            raise Web3ValueError(
                 f"Cannot set '{', '.join(keys_found)}' field(s) in transaction"
             )
 

web3/contract/contract.py

@@ -81,7 +81,10 @@ from web3.exceptions import (
     ABIFunctionNotFound,
     NoABIFound,
     NoABIFunctionsFound,
+    Web3AttributeError,
+    Web3TypeError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.types import (
     ABI,
@@ -107,11 +110,12 @@ class ContractEvent(BaseContractEvent):
     def get_logs(
         self,
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: Optional[BlockIdentifier] = None,
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: Optional[BlockIdentifier] = None,
         block_hash: Optional[HexBytes] = None,
     ) -> Iterable[EventData]:
-        """Get events for this contract instance using eth_getLogs API.
+        """
+        Get events for this contract instance using eth_getLogs API.
 
         This is a stateless method, as opposed to create_filter.
         It can be safely called against nodes which do not provide
@@ -127,10 +131,10 @@ class ContractEvent(BaseContractEvent):
 
         .. code-block:: python
 
-            from = max(mycontract.web3.eth.block_number - 10, 1)
-            to = mycontract.web3.eth.block_number
+            from = max(my_contract.web3.eth.block_number - 10, 1)
+            to = my_contract.web3.eth.block_number
 
-            events = mycontract.events.Transfer.get_logs(fromBlock=from, toBlock=to)
+            events = my_contract.events.Transfer.get_logs(from_block=from, to_block=to)
 
             for e in events:
                 print(e["args"]["from"],
@@ -160,10 +164,10 @@ class ContractEvent(BaseContractEvent):
 
         :param argument_filters: Filter by argument values. Indexed arguments are
           filtered by the node while non-indexed arguments are filtered by the library.
-        :param fromBlock: block number or "latest", defaults to "latest"
-        :param toBlock: block number or "latest". Defaults to "latest"
+        :param from_block: block number or "latest", defaults to "latest"
+        :param to_block: block number or "latest". Defaults to "latest"
         :param block_hash: block hash. block_hash cannot be set at the
-          same time as fromBlock or toBlock
+          same time as ``from_block`` or ``to_block``
         :yield: Tuple of :class:`AttributeDict` instances
         """
         event_abi = self._get_event_abi()
@@ -178,7 +182,7 @@ class ContractEvent(BaseContractEvent):
                 )
 
         _filter_params = self._get_event_filter_params(
-            event_abi, argument_filters, fromBlock, toBlock, block_hash
+            event_abi, argument_filters, from_block, to_block, block_hash
         )
         # call JSON-RPC API
         logs = self.w3.eth.get_logs(_filter_params)
@@ -201,8 +205,8 @@ class ContractEvent(BaseContractEvent):
         self,
         *,  # PEP 3102
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: BlockIdentifier = "latest",
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: BlockIdentifier = "latest",
         address: Optional[ChecksumAddress] = None,
         topics: Optional[Sequence[Any]] = None,
     ) -> LogFilter:
@@ -212,8 +216,8 @@ class ContractEvent(BaseContractEvent):
         filter_builder = EventFilterBuilder(self._get_event_abi(), self.w3.codec)
         self._set_up_filter_builder(
             argument_filters,
-            fromBlock,
-            toBlock,
+            from_block,
+            to_block,
             address,
             topics,
             filter_builder,
@@ -438,11 +442,13 @@ class Contract(BaseContract):
     events: ContractEvents = None
 
     def __init__(self, address: Optional[ChecksumAddress] = None) -> None:
-        """Create a new smart contract proxy object.
-        :param address: Contract address as 0x hex string"""
+        """
+        Create a new smart contract proxy object.
+        :param address: Contract address as 0x hex string
+        """
         _w3 = self.w3
         if _w3 is None:
-            raise AttributeError(
+            raise Web3AttributeError(
                 "The `Contract` class has not been initialized.  Please use the "
                 "`web3.contract` interface to create your contract class."
             )
@@ -451,7 +457,7 @@ class Contract(BaseContract):
             self.address = normalize_address(cast("ENS", _w3.ens), address)
 
         if not self.address:
-            raise TypeError(
+            raise Web3TypeError(
                 "The address argument is required to instantiate a contract."
             )
 
@@ -528,7 +534,7 @@ class Contract(BaseContract):
         :return: a contract constructor object
         """
         if cls.bytecode is None:
-            raise ValueError(
+            raise Web3ValueError(
                 "Cannot call constructor on a contract that does not have "
                 "'bytecode' associated with it"
             )

web3/contract/utils.py

@@ -43,6 +43,7 @@ from web3._utils.transactions import (
 )
 from web3.exceptions import (
     BadFunctionCallOutput,
+    Web3ValueError,
 )
 from web3.types import (
     ABI,
@@ -185,7 +186,8 @@ def estimate_gas_for_function(
     *args: Any,
     **kwargs: Any,
 ) -> int:
-    """Estimates gas cost a function call would take.
+    """
+    Estimates gas cost a function call would take.
 
     Don't call this directly, instead use :meth:`Contract.estimate_gas`
     on your contract instance.
@@ -214,7 +216,8 @@ def build_transaction_for_function(
     *args: Any,
     **kwargs: Any,
 ) -> TxParams:
-    """Builds a dictionary with the fields required to make the given transaction
+    """
+    Builds a dictionary with the fields required to make the given transaction
 
     Don't call this directly, instead use :meth:`Contract.build_transaction`
     on your contract instance.
@@ -261,11 +264,11 @@ def get_function_by_identifier(
     fns: Sequence[TContractFn], identifier: str
 ) -> TContractFn:
     if len(fns) > 1:
-        raise ValueError(
+        raise Web3ValueError(
             f"Found multiple functions with matching {identifier}. " f"Found: {fns!r}"
         )
     elif len(fns) == 0:
-        raise ValueError(f"Could not find any function with matching {identifier}")
+        raise Web3ValueError(f"Could not find any function with matching {identifier}")
     return fns[0]
 
 
@@ -394,7 +397,8 @@ async def async_estimate_gas_for_function(
     *args: Any,
     **kwargs: Any,
 ) -> int:
-    """Estimates gas cost a function call would take.
+    """
+    Estimates gas cost a function call would take.
 
     Don't call this directly, instead use :meth:`Contract.estimate_gas`
     on your contract instance.
@@ -425,7 +429,8 @@ async def async_build_transaction_for_function(
     *args: Any,
     **kwargs: Any,
 ) -> TxParams:
-    """Builds a dictionary with the fields required to make the given transaction
+    """
+    Builds a dictionary with the fields required to make the given transaction
 
     Don't call this directly, instead use :meth:`Contract.build_transaction`
     on your contract instance.