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

web3/_utils/transactions.py

@@ -2,6 +2,7 @@ import math
 from typing import (
     TYPE_CHECKING,
     List,
+    Literal,
     Optional,
     Union,
     cast,
@@ -19,9 +20,6 @@ from hexbytes import (
     HexBytes,
 )
 
-from web3._utils.compat import (
-    Literal,
-)
 from web3._utils.utility_methods import (
     all_in_dict,
     any_in_dict,
@@ -29,6 +27,10 @@ from web3._utils.utility_methods import (
 from web3.constants import (
     DYNAMIC_FEE_TXN_PARAMS,
 )
+from web3.exceptions import (
+    Web3AttributeError,
+    Web3ValueError,
+)
 from web3.types import (
     BlockIdentifier,
     TxData,
@@ -107,7 +109,7 @@ def fill_nonce(w3: "Web3", transaction: TxParams) -> TxParams:
 @curry
 def fill_transaction_defaults(w3: "Web3", transaction: TxParams) -> TxParams:
     """
-    if w3 is None, fill as much as possible while offline
+    If w3 is None, fill as much as possible while offline
     """
     strategy_based_gas_price = w3.eth.generate_gas_price(transaction)
     is_dynamic_fee_transaction = strategy_based_gas_price is None and (
@@ -130,7 +132,7 @@ def fill_transaction_defaults(w3: "Web3", transaction: TxParams) -> TxParams:
 
             if callable(default_getter):
                 if w3 is None:
-                    raise ValueError(
+                    raise Web3ValueError(
                         f"You must specify a '{key}' value in the transaction"
                     )
                 default_val = default_getter(w3, transaction)
@@ -160,7 +162,7 @@ def get_buffered_gas_estimate(
     gas_limit = get_block_gas_limit(w3)
 
     if gas_estimate > gas_limit:
-        raise ValueError(
+        raise Web3ValueError(
             "Contract does not appear to be deployable within the "
             f"current network gas limits.  Estimated: {gas_estimate}. "
             f"Current gas limit: {gas_limit}"
@@ -172,7 +174,7 @@ def get_buffered_gas_estimate(
 def get_required_transaction(w3: "Web3", transaction_hash: _Hash32) -> TxData:
     current_transaction = w3.eth.get_transaction(transaction_hash)
     if not current_transaction:
-        raise ValueError(
+        raise Web3ValueError(
             f"Supplied transaction with hash {transaction_hash!r} does not exist"
         )
     return current_transaction
@@ -204,7 +206,7 @@ def extract_valid_transaction_params(transaction_params: TxData) -> TxParams:
                 msg = 'failure to handle this transaction due to both "input: {}" and'
                 msg += ' "data: {}" are populated. You need to resolve this conflict.'
                 err_vals = (transaction_params["input"], extracted_params["data"])
-                raise AttributeError(msg.format(*err_vals))
+                raise Web3AttributeError(msg.format(*err_vals))
             else:
                 return extracted_params
         else:
@@ -223,7 +225,7 @@ def extract_valid_transaction_params(transaction_params: TxData) -> TxParams:
 def assert_valid_transaction_params(transaction_params: TxParams) -> None:
     for param in transaction_params:
         if param not in VALID_TRANSACTION_PARAMS:
-            raise ValueError(f"{param} is not a valid transaction parameter")
+            raise Web3ValueError(f"{param} is not a valid transaction parameter")
 
 
 def prepare_replacement_transaction(
@@ -233,14 +235,14 @@ def prepare_replacement_transaction(
     gas_multiplier: float = 1.125,
 ) -> TxParams:
     if original_transaction["blockHash"] is not None:
-        raise ValueError(
+        raise Web3ValueError(
             f'Supplied transaction with hash {original_transaction["hash"]!r} '
             "has already been mined"
         )
     if "nonce" in replacement_transaction and (
         replacement_transaction["nonce"] != original_transaction["nonce"]
     ):
-        raise ValueError(
+        raise Web3ValueError(
             "Supplied nonce in new_transaction must match the pending transaction"
         )
 
@@ -259,7 +261,7 @@ def prepare_replacement_transaction(
         and original_transaction["gasPrice"] is not None
     ):
         if replacement_transaction["gasPrice"] <= original_transaction["gasPrice"]:
-            raise ValueError(
+            raise Web3ValueError(
                 "Supplied gas price must exceed existing transaction gas price"
             )
 

web3/_utils/type_conversion.py

@@ -10,6 +10,10 @@ from eth_utils import (
     to_hex,
 )
 
+from web3.exceptions import (
+    Web3ValueError,
+)
+
 
 def to_hex_if_bytes(val: Union[HexStr, str, bytes, bytearray]) -> HexStr:
     """
@@ -17,7 +21,7 @@ def to_hex_if_bytes(val: Union[HexStr, str, bytes, bytearray]) -> HexStr:
     meant to work with bytes and hex strings.
     """
     if isinstance(val, str) and not val.startswith("0x"):
-        raise ValueError(f"Expected a hex string. Got: {val!r}")
+        raise Web3ValueError(f"Expected a hex string. Got: {val!r}")
 
     return to_hex(val) if isinstance(val, (bytes, bytearray)) else to_hex(hexstr=val)
 

web3/_utils/validation.py

@@ -53,6 +53,8 @@ from web3._utils.abi import (
 )
 from web3.exceptions import (
     InvalidAddress,
+    Web3TypeError,
+    Web3ValueError,
 )
 from web3.types import (
     ABI,
@@ -74,16 +76,16 @@ def validate_abi(abi: ABI) -> None:
     Helper function for validating an ABI
     """
     if not is_list_like(abi):
-        raise ValueError("'abi' is not a list")
+        raise Web3ValueError("'abi' is not a list")
 
     if not all(is_dict(e) for e in abi):
-        raise ValueError("'abi' is not a list of dictionaries")
+        raise Web3ValueError("'abi' is not a list of dictionaries")
 
     functions = filter_by_type("function", abi)
     selectors = groupby(compose(encode_hex, function_abi_to_4byte_selector), functions)
     duplicates = valfilter(lambda funcs: len(funcs) > 1, selectors)
     if duplicates:
-        raise ValueError(
+        raise Web3ValueError(
             "Abi contains functions with colliding selectors. "
             f"Functions {_prepare_selector_collision_msg(duplicates)}"
         )
@@ -94,7 +96,7 @@ def validate_abi_type(abi_type: TypeStr) -> None:
     Helper function for validating an abi_type
     """
     if not is_recognized_type(abi_type):
-        raise ValueError(f"Unrecognized abi_type: {abi_type}")
+        raise Web3ValueError(f"Unrecognized abi_type: {abi_type}")
 
 
 def validate_abi_value(abi_type: TypeStr, value: Any) -> None:
@@ -107,12 +109,12 @@ def validate_abi_value(abi_type: TypeStr, value: Any) -> None:
         specified_length = length_of_array_type(abi_type)
         if specified_length is not None:
             if specified_length < 1:
-                raise TypeError(
+                raise Web3TypeError(
                     f"Invalid abi-type: {abi_type}. Length of fixed sized "
                     "arrays must be greater than 0."
                 )
             if specified_length != len(value):
-                raise TypeError(
+                raise Web3TypeError(
                     "The following array length does not the length specified"
                     f"by the abi-type, {abi_type}: {value}"
                 )
@@ -138,14 +140,14 @@ def validate_abi_value(abi_type: TypeStr, value: Any) -> None:
             if is_0x_prefixed(value):
                 return
             else:
-                raise TypeError(
+                raise Web3TypeError(
                     "ABI values of abi-type 'bytes' must be either"
                     "a python3 'bytes' object or an '0x' prefixed string."
                 )
     elif is_string_type(abi_type) and is_string(value):
         return
 
-    raise TypeError(f"The following abi value is not a '{abi_type}': {value}")
+    raise Web3TypeError(f"The following abi value is not a '{abi_type}': {value}")
 
 
 def is_not_address_string(value: Any) -> bool:
@@ -173,7 +175,7 @@ def validate_address(value: Any) -> None:
         return
 
     if not isinstance(value, str):
-        raise TypeError(f"Address {value} must be provided as a string")
+        raise Web3TypeError(f"Address {value} must be provided as a string")
     if not is_hex_address(value):
         raise InvalidAddress(
             "Address must be 20 bytes, as a hex string with a 0x prefix", value
@@ -204,7 +206,7 @@ def has_one_val(*args: Any, **kwargs: Any) -> bool:
 
 def assert_one_val(*args: Any, **kwargs: Any) -> None:
     if not has_one_val(*args, **kwargs):
-        raise TypeError(
+        raise Web3TypeError(
             "Exactly one of the passed values can be specified. "
             f"Instead, values were: {args!r}, {kwargs!r}"
         )

web3/contract/async_contract.py

@@ -82,7 +82,10 @@ from web3.exceptions import (
     ABIFunctionNotFound,
     NoABIFound,
     NoABIFunctionsFound,
+    Web3AttributeError,
+    Web3TypeError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.types import (
     ABI,
@@ -112,7 +115,8 @@ class AsyncContractEvent(BaseContractEvent):
         toBlock: Optional[BlockIdentifier] = None,
         block_hash: Optional[HexBytes] = None,
     ) -> Awaitable[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 createFilter.
         It can be safely called against nodes which do not provide
@@ -440,12 +444,13 @@ class AsyncContract(BaseContract):
     events: AsyncContractEvents = 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
+        """
         if self.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."
             )
@@ -454,7 +459,7 @@ class AsyncContract(BaseContract):
             self.address = normalize_address_no_ens(address)
 
         if not self.address:
-            raise TypeError(
+            raise Web3TypeError(
                 "The address argument is required to instantiate a contract."
             )
         self.functions = AsyncContractFunctions(
@@ -523,7 +528,7 @@ class AsyncContract(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/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
@@ -204,7 +209,7 @@ class BaseContractEvent:
         blockHash: 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"
             )
@@ -251,12 +256,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."
@@ -321,7 +326,7 @@ class BaseContractEvent:
         filter_builder: Union[EventFilterBuilder, AsyncEventFilterBuilder] = None,
     ) -> None:
         if fromBlock is None:
-            raise TypeError(
+            raise Web3TypeError(
                 "Missing mandatory keyword argument to create_filter: fromBlock"
             )
 
@@ -370,7 +375,8 @@ class BaseContractEvent:
 
 
 class BaseContractEvents:
-    """Class containing contract event objects
+    """
+    Class containing contract event objects
 
     This is available via:
 
@@ -431,7 +437,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 +453,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 +487,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 +500,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 +531,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 +557,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 +585,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 +679,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 +761,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 +793,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 +806,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 +893,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 +1088,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 +1104,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 +1122,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,
@@ -111,7 +114,8 @@ class ContractEvent(BaseContractEvent):
         toBlock: 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
@@ -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"
             )