web3 6.20.3__py3-none-any.whl → 7.0.0__py3-none-any.whl

web3/_utils/decorators.py

@@ -8,6 +8,10 @@ from typing import (
 )
 import warnings
 
+from web3.exceptions import (
+    Web3ValueError,
+)
+
 TFunc = TypeVar("TFunc", bound=Callable[..., Any])
 
 
@@ -24,7 +28,7 @@ def reject_recursive_repeats(to_wrap: Callable[..., Any]) -> Callable[..., Any]:
         thread_id = threading.get_ident()
         thread_local_args = (thread_id,) + arg_instances
         if thread_local_args in to_wrap.__already_called:  # type: ignore
-            raise ValueError(f"Recursively called {to_wrap} with {args!r}")
+            raise Web3ValueError(f"Recursively called {to_wrap} with {args!r}")
         to_wrap.__already_called[thread_local_args] = True  # type: ignore
         try:
             wrapped_val = to_wrap(*args)
@@ -35,37 +39,23 @@ def reject_recursive_repeats(to_wrap: Callable[..., Any]) -> Callable[..., Any]:
     return wrapped
 
 
-def deprecate_method(
-    replacement_method: str = None, deprecation_msg: str = None
-) -> Callable[..., Any]:
+def deprecated_for(replace_message: str) -> Callable[..., Any]:
     """
-    Decorate a deprecated function with info on its replacement method OR a clarifying
-    reason for the deprecation.
-
-    @deprecate_method("to_bytes()")
-    def to_ascii(arg):
-        ...
+    Decorate a deprecated function, with info about what to use instead, like:
 
-    @deprecate_method(deprecation_msg=(
-        "This method is no longer supported and will be removed in the next release."
-    ))
-    def some_method(arg):
+    @deprecated_for("to_bytes()")
+    def toAscii(arg):
         ...
     """
-    if replacement_method is None and deprecation_msg is None:
-        raise ValueError(
-            "Must provide either `replacement_method` or `deprecation_msg`"
-        )
 
     def decorator(to_wrap: TFunc) -> TFunc:
         @functools.wraps(to_wrap)
         def wrapper(*args: Any, **kwargs: Any) -> Callable[..., Any]:
-            msg = (
-                f"{to_wrap.__name__} is deprecated in favor of {replacement_method}"
-                if replacement_method is not None
-                else deprecation_msg
+            warnings.warn(
+                f"{to_wrap.__name__} is deprecated in favor of {replace_message}",
+                category=DeprecationWarning,
+                stacklevel=2,
             )
-            warnings.warn(msg, category=DeprecationWarning)
             return to_wrap(*args, **kwargs)
 
         return cast(TFunc, wrapper)

web3/_utils/empty.py

@@ -1,4 +1,4 @@
-from web3._utils.compat import (
+from typing import (
     Literal,
 )
 

web3/_utils/encoding.py

@@ -55,6 +55,10 @@ from web3._utils.validation import (
 from web3.datastructures import (
     AttributeDict,
 )
+from web3.exceptions import (
+    Web3TypeError,
+    Web3ValueError,
+)
 
 
 def hex_encode_abi_type(
@@ -90,7 +94,7 @@ def hex_encode_abi_type(
     elif is_string_type(abi_type):
         return to_hex(text=value)
     else:
-        raise ValueError(f"Unsupported ABI type: {abi_type}")
+        raise Web3ValueError(f"Unsupported ABI type: {abi_type}")
 
 
 def to_hex_twos_compliment(value: Any, bit_size: int) -> HexStr:
@@ -169,7 +173,7 @@ def hexstr_if_str(
     if isinstance(hexstr_or_primitive, str):
         (primitive, hexstr) = (None, hexstr_or_primitive)
         if remove_0x_prefix(HexStr(hexstr)) and not is_hex(hexstr):
-            raise ValueError(
+            raise Web3ValueError(
                 "when sending a str, it must be a hex string. "
                 f"Got: {hexstr_or_primitive!r}"
             )
@@ -210,12 +214,12 @@ class FriendlyJsonSerde:
         except TypeError as full_exception:
             if hasattr(obj, "items"):
                 item_errors = "; ".join(self._json_mapping_errors(obj))
-                raise TypeError(
+                raise Web3TypeError(
                     f"dict had unencodable value at keys: {{{item_errors}}}"
                 )
             elif is_list_like(obj):
                 element_errors = "; ".join(self._json_list_errors(obj))
-                raise TypeError(
+                raise Web3TypeError(
                     f"list had unencodable value at index: [{element_errors}]"
                 )
             else:
@@ -237,14 +241,16 @@ class FriendlyJsonSerde:
         try:
             return self._friendly_json_encode(obj, cls=cls)
         except TypeError as exc:
-            raise TypeError(f"Could not encode to JSON: {exc}")
+            raise Web3TypeError(f"Could not encode to JSON: {exc}")
 
 
 def to_4byte_hex(hex_or_str_or_bytes: Union[HexStr, str, bytes, int]) -> HexStr:
     size_of_4bytes = 4 * 8
     byte_str = hexstr_if_str(to_bytes, hex_or_str_or_bytes)
     if len(byte_str) > 4:
-        raise ValueError(f"expected value of size 4 bytes. Got: {len(byte_str)} bytes")
+        raise Web3ValueError(
+            f"expected value of size 4 bytes. Got: {len(byte_str)} bytes"
+        )
     hex_str = encode_hex(byte_str)
     return pad_hex(hex_str, size_of_4bytes)
 
@@ -253,7 +259,7 @@ class DynamicArrayPackedEncoder(BaseArrayEncoder):
     is_dynamic = True
 
     def encode(self, value: Sequence[Any]) -> bytes:
-        encoded_elements = self.encode_elements(value)
+        encoded_elements = self.encode_elements(value)  # type: ignore[no-untyped-call]
         encoded_value = encoded_elements
 
         return encoded_value
@@ -272,10 +278,10 @@ def encode_single_packed(_type: TypeStr, value: Any) -> bytes:
     )
 
     abi_type = abi_type_parser.parse(_type)
-    if has_arrlist(_type):
+    if has_arrlist(_type):  # type: ignore[no-untyped-call]
         item_encoder = registry.get_encoder(abi_type.item_type.to_type_str())
         if abi_type.arrlist[-1] != 1:
-            return DynamicArrayPackedEncoder(item_encoder=item_encoder).encode(value)
+            return DynamicArrayPackedEncoder(item_encoder=item_encoder).encode(value)  # type: ignore[no-untyped-call]  # noqa: E501
         else:
             raise NotImplementedError(
                 "Fixed arrays are not implemented in this packed encoder prototype"
@@ -291,9 +297,7 @@ class Web3JsonEncoder(json.JSONEncoder):
     def default(self, obj: Any) -> Union[Dict[Any, Any], HexStr]:
         if isinstance(obj, AttributeDict):
             return obj.__dict__
-        elif isinstance(obj, HexBytes):
-            return HexStr(obj.hex())
-        elif isinstance(obj, bytes):
+        elif isinstance(obj, (HexBytes, bytes)):
             return to_hex(obj)
         return json.JSONEncoder.default(self, obj)
 

web3/_utils/ens.py

@@ -17,6 +17,7 @@ from eth_utils import (
     is_0x_prefixed,
     is_hex,
     is_hex_address,
+    to_checksum_address,
 )
 
 from ens import (
@@ -51,7 +52,7 @@ def is_ens_name(value: Any) -> bool:
 def validate_name_has_address(ens: ENS, name: str) -> ChecksumAddress:
     addr = ens.address(name)
     if addr:
-        return addr
+        return to_checksum_address(addr)
     else:
         raise NameNotFound(f"Could not find address for name {name!r}")
 

web3/_utils/error_formatters_utils.py

@@ -13,6 +13,7 @@ from web3.exceptions import (
     ContractPanicError,
     OffchainLookup,
     TransactionIndexingInProgress,
+    Web3ValueError,
 )
 from web3.types import (
     RPCResponse,
@@ -76,7 +77,9 @@ def _parse_error_with_reverted_prefix(data: str) -> str:
     try:
         error = bytes.fromhex(error).decode("utf8")
     except UnicodeDecodeError:
-        warnings.warn("Could not decode revert reason as UTF-8", RuntimeWarning)
+        warnings.warn(
+            "Could not decode revert reason as UTF-8", RuntimeWarning, stacklevel=2
+        )
         raise ContractLogicError("execution reverted", data=data)
 
     return error
@@ -140,7 +143,7 @@ def raise_contract_logic_error_on_revert(response: RPCResponse) -> RPCResponse:
     """
     error = response.get("error")
     if error is None or isinstance(error, str):
-        raise ValueError(error)
+        raise Web3ValueError(error)
 
     message = error.get("message")
     message_present = message is not None and message != ""
@@ -172,7 +175,6 @@ def raise_transaction_indexing_error_if_indexing(response: RPCResponse) -> RPCRe
     Raise an error if ``eth_getTransactionReceipt`` returns an error indicating that
     transactions are still being indexed.
     """
-
     error = response.get("error")
     if not isinstance(error, str) and error is not None:
         message = error.get("message")

web3/_utils/events.py

@@ -27,6 +27,9 @@ from eth_abi.codec import (
     ABICodec,
 )
 from eth_typing import (
+    ABIComponent,
+    ABIComponentIndexed,
+    ABIEvent,
     ChecksumAddress,
     HexStr,
     Primitives,
@@ -34,7 +37,6 @@ from eth_typing import (
 )
 from eth_utils import (
     encode_hex,
-    event_abi_to_log_topic,
     is_list_like,
     keccak,
     to_bytes,
@@ -42,6 +44,11 @@ from eth_utils import (
     to_hex,
     to_tuple,
 )
+from eth_utils.abi import (
+    collapse_if_tuple,
+    event_abi_to_log_topic,
+    get_abi_input_names,
+)
 from eth_utils.curried import (
     apply_formatter_if,
 )
@@ -57,7 +64,6 @@ import web3
 from web3._utils.abi import (
     exclude_indexed_event_inputs,
     get_indexed_event_inputs,
-    get_normalized_abi_arg_type,
     map_abi_data,
     named_tree,
     normalize_event_input_types,
@@ -75,18 +81,16 @@ from web3.datastructures import (
 from web3.exceptions import (
     InvalidEventABI,
     LogTopicError,
-    MismatchedABI,
+    Web3ValueError,
 )
 from web3.types import (
-    ABIEvent,
-    ABIEventParams,
     BlockIdentifier,
     EventData,
     FilterParams,
     LogReceipt,
 )
-from web3.utils import (
-    get_abi_input_names,
+from web3.utils.abi import (
+    get_event_log_topics,
 )
 
 if TYPE_CHECKING:
@@ -109,13 +113,13 @@ def _log_entry_data_to_bytes(
 def construct_event_topic_set(
     event_abi: ABIEvent,
     abi_codec: ABICodec,
-    arguments: Optional[Union[Sequence[Any], Dict[str, Any]]] = None,
+    arguments: Optional[Union[List[Any], Tuple[Any], Dict[str, Any]]] = None,
 ) -> List[HexStr]:
     if arguments is None:
         arguments = {}
-    if isinstance(arguments, (list, tuple)):
+    elif isinstance(arguments, (list, tuple)):
         if len(arguments) != len(event_abi["inputs"]):
-            raise ValueError(
+            raise Web3ValueError(
                 "When passing an argument list, the number of arguments must "
                 "match the event constructor."
             )
@@ -123,16 +127,12 @@ def construct_event_topic_set(
             arg["name"]: [arg_value]
             for arg, arg_value in zip(event_abi["inputs"], arguments)
         }
-
     normalized_args = {
         key: value if is_list_like(value) else [value]
-        # type ignored b/c arguments is always a dict at this point
-        for key, value in arguments.items()  # type: ignore
+        for key, value in arguments.items()
     }
 
-    # typed dict cannot be used w/ a normal Dict
-    # https://github.com/python/mypy/issues/4976
-    event_topic = encode_hex(event_abi_to_log_topic(event_abi))  # type: ignore
+    event_topic = encode_hex(event_abi_to_log_topic(event_abi))
     indexed_args = get_indexed_event_inputs(event_abi)
     zipped_abi_and_args = [
         (arg, normalized_args.get(arg["name"], [None])) for arg in indexed_args
@@ -162,7 +162,7 @@ def construct_event_data_set(
         arguments = {}
     if isinstance(arguments, (list, tuple)):
         if len(arguments) != len(event_abi["inputs"]):
-            raise ValueError(
+            raise Web3ValueError(
                 "When passing an argument list, the number of arguments must "
                 "match the event constructor."
             )
@@ -207,7 +207,7 @@ def is_dynamic_sized_type(type_str: TypeStr) -> bool:
 
 @to_tuple
 def get_event_abi_types_for_decoding(
-    event_inputs: Sequence[ABIEventParams],
+    event_inputs: Sequence[Union[ABIComponent, ABIComponentIndexed]],
 ) -> Iterable[TypeStr]:
     """
     Event logs use the `keccak(value)` for indexed inputs of type `bytes` or
@@ -215,10 +215,10 @@ def get_event_abi_types_for_decoding(
     decode the log entries using the correct types.
     """
     for input_abi in event_inputs:
-        if input_abi["indexed"] and is_dynamic_sized_type(input_abi["type"]):
+        if input_abi.get("indexed") and is_dynamic_sized_type(input_abi["type"]):
             yield "bytes32"
         else:
-            yield get_normalized_abi_arg_type(input_abi)
+            yield collapse_if_tuple(input_abi)
 
 
 @curry
@@ -231,22 +231,14 @@ def get_event_data(
     Given an event ABI and a log entry for that event, return the decoded
     event data
     """
-    if event_abi["anonymous"]:
-        log_topics = log_entry["topics"]
-    elif not log_entry["topics"]:
-        raise MismatchedABI("Expected non-anonymous event to have 1 or more topics")
-    elif event_abi_to_log_topic(dict(event_abi)) != _log_entry_data_to_bytes(
-        log_entry["topics"][0]
-    ):
-        raise MismatchedABI("The event signature did not match the provided ABI")
-    else:
-        log_topics = log_entry["topics"][1:]
-
+    log_topics = get_event_log_topics(event_abi, log_entry["topics"])
     log_topics_bytes = [_log_entry_data_to_bytes(topic) for topic in log_topics]
     log_topics_abi = get_indexed_event_inputs(event_abi)
     log_topic_normalized_inputs = normalize_event_input_types(log_topics_abi)
     log_topic_types = get_event_abi_types_for_decoding(log_topic_normalized_inputs)
-    log_topic_names = get_abi_input_names(ABIEvent({"inputs": log_topics_abi}))
+    log_topic_names = get_abi_input_names(
+        ABIEvent({"name": event_abi["name"], "type": "event", "inputs": log_topics_abi})
+    )
 
     if len(log_topics_bytes) != len(log_topic_types):
         raise LogTopicError(
@@ -257,7 +249,9 @@ def get_event_data(
     log_data_abi = exclude_indexed_event_inputs(event_abi)
     log_data_normalized_inputs = normalize_event_input_types(log_data_abi)
     log_data_types = get_event_abi_types_for_decoding(log_data_normalized_inputs)
-    log_data_names = get_abi_input_names(ABIEvent({"inputs": log_data_abi}))
+    log_data_names = get_abi_input_names(
+        ABIEvent({"name": event_abi["name"], "type": "event", "inputs": log_data_abi})
+    )
 
     # sanity check that there are not name intersections between the topic
     # names and the data argument names.
@@ -341,8 +335,8 @@ is_not_indexed = complement(is_indexed)
 
 class BaseEventFilterBuilder:
     formatter = None
-    _fromBlock = None
-    _toBlock = None
+    _from_block = None
+    _to_block = None
     _address = None
     _immutable = False
 
@@ -362,30 +356,30 @@ class BaseEventFilterBuilder:
         self._ordered_arg_names = tuple(arg["name"] for arg in event_abi["inputs"])
 
     @property
-    def fromBlock(self) -> BlockIdentifier:
-        return self._fromBlock
+    def from_block(self) -> BlockIdentifier:
+        return self._from_block
 
-    @fromBlock.setter
-    def fromBlock(self, value: BlockIdentifier) -> None:
-        if self._fromBlock is None and not self._immutable:
-            self._fromBlock = value
+    @from_block.setter
+    def from_block(self, value: BlockIdentifier) -> None:
+        if self._from_block is None and not self._immutable:
+            self._from_block = value
         else:
-            raise ValueError(
-                f"fromBlock is already set to {self._fromBlock!r}. "
+            raise Web3ValueError(
+                f"from_block is already set to {self._from_block!r}. "
                 "Resetting filter parameters is not permitted"
             )
 
     @property
-    def toBlock(self) -> BlockIdentifier:
-        return self._toBlock
+    def to_block(self) -> BlockIdentifier:
+        return self._to_block
 
-    @toBlock.setter
-    def toBlock(self, value: BlockIdentifier) -> None:
-        if self._toBlock is None and not self._immutable:
-            self._toBlock = value
+    @to_block.setter
+    def to_block(self, value: BlockIdentifier) -> None:
+        if self._to_block is None and not self._immutable:
+            self._to_block = value
         else:
-            raise ValueError(
-                f"toBlock is already set to {self._toBlock!r}. "
+            raise Web3ValueError(
+                f"toBlock is already set to {self._to_block!r}. "
                 "Resetting filter parameters is not permitted"
             )
 
@@ -398,7 +392,7 @@ class BaseEventFilterBuilder:
         if self._address is None and not self._immutable:
             self._address = value
         else:
-            raise ValueError(
+            raise Web3ValueError(
                 f"address is already set to {self.address!r}. "
                 "Resetting filter parameters is not permitted"
             )
@@ -433,8 +427,8 @@ class BaseEventFilterBuilder:
     def filter_params(self) -> FilterParams:
         params = {
             "topics": self.topics,
-            "fromBlock": self.fromBlock,
-            "toBlock": self.toBlock,
+            "fromBlock": self.from_block,
+            "toBlock": self.to_block,
             "address": self.address,
         }
         return valfilter(lambda x: x is not None, params)
@@ -443,10 +437,10 @@ class BaseEventFilterBuilder:
 class EventFilterBuilder(BaseEventFilterBuilder):
     def deploy(self, w3: "Web3") -> "LogFilter":
         if not isinstance(w3, web3.Web3):
-            raise ValueError(f"Invalid web3 argument: got: {w3!r}")
+            raise Web3ValueError(f"Invalid web3 argument: got: {w3!r}")
 
-        for arg in AttributeDict.values(self.args):  # type: ignore[arg-type]
-            arg._immutable = True  # type: ignore[attr-defined]
+        for arg in self.args.values():
+            arg._immutable = True
         self._immutable = True
 
         log_filter = cast("LogFilter", w3.eth.filter(self.filter_params))
@@ -461,10 +455,10 @@ class EventFilterBuilder(BaseEventFilterBuilder):
 class AsyncEventFilterBuilder(BaseEventFilterBuilder):
     async def deploy(self, async_w3: "AsyncWeb3") -> "AsyncLogFilter":
         if not isinstance(async_w3, web3.AsyncWeb3):
-            raise ValueError(f"Invalid web3 argument: got: {async_w3!r}")
+            raise Web3ValueError(f"Invalid web3 argument: got: {async_w3!r}")
 
-        for arg in AttributeDict.values(self.args):  # type: ignore[arg-type]
-            arg._immutable = True  # type: ignore[attr-defined]
+        for arg in self.args.values():
+            arg._immutable = True
         self._immutable = True
 
         log_filter = await async_w3.eth.filter(self.filter_params)
@@ -479,8 +473,7 @@ class AsyncEventFilterBuilder(BaseEventFilterBuilder):
 
 def initialize_event_topics(event_abi: ABIEvent) -> Union[bytes, List[Any]]:
     if event_abi["anonymous"] is False:
-        # https://github.com/python/mypy/issues/4976
-        return event_abi_to_log_topic(event_abi)  # type: ignore
+        return event_abi_to_log_topic(event_abi)
     else:
         return list()
 
@@ -492,12 +485,12 @@ def _build_argument_filters_from_event_abi(
     for item in event_abi["inputs"]:
         key = item["name"]
         value: "BaseArgumentFilter"
-        if item["indexed"] is True:
+        if item.get("indexed") is True:
             value = TopicArgumentFilter(
-                abi_codec=abi_codec, arg_type=get_normalized_abi_arg_type(item)
+                abi_codec=abi_codec, arg_type=collapse_if_tuple(item)
             )
         else:
-            value = DataArgumentFilter(arg_type=get_normalized_abi_arg_type(item))
+            value = DataArgumentFilter(arg_type=collapse_if_tuple(item))
         yield key, value
 
 
@@ -519,19 +512,23 @@ class BaseArgumentFilter(ABC):
 
     def match_single(self, value: Any) -> None:
         if self._immutable:
-            raise ValueError("Setting values is forbidden after filter is deployed.")
+            raise Web3ValueError(
+                "Setting values is forbidden after filter is deployed."
+            )
         if self._match_values is None:
             self._match_values = _normalize_match_values((value,))
         else:
-            raise ValueError("An argument match value/s has already been set.")
+            raise Web3ValueError("An argument match value/s has already been set.")
 
     def match_any(self, *values: Collection[Any]) -> None:
         if self._immutable:
-            raise ValueError("Setting values is forbidden after filter is deployed.")
+            raise Web3ValueError(
+                "Setting values is forbidden after filter is deployed."
+            )
         if self._match_values is None:
             self._match_values = _normalize_match_values(values)
         else:
-            raise ValueError("An argument match value/s has already been set.")
+            raise Web3ValueError("An argument match value/s has already been set.")
 
     @property
     @abstractmethod

web3/_utils/fee_utils.py

@@ -53,7 +53,5 @@ async def async_fee_history_priority_fee(async_eth: "AsyncEth") -> Wei:
     # This is a tested internal call so no need for type hinting. We can keep
     # better consistency between the sync and async calls by unpacking
     # PRIORITY_FEE_HISTORY_PARAMS as constants here.
-    fee_history = await async_eth.fee_history(
-        *PRIORITY_FEE_HISTORY_PARAMS  # type: ignore
-    )
+    fee_history = await async_eth.fee_history(*PRIORITY_FEE_HISTORY_PARAMS)  # type: ignore  # noqa: E501
     return _fee_history_priority_fee_estimate(fee_history)