web3 7.5.0__py3-none-any.whl → 7.6.0__py3-none-any.whl

web3/utils/abi.py

@@ -1,6 +1,7 @@
 import functools
 from typing import (
     Any,
+    Callable,
     Dict,
     List,
     Optional,
@@ -47,7 +48,6 @@ from eth_utils.toolz import (
 )
 from eth_utils.types import (
     is_list_like,
-    is_text,
 )
 from hexbytes import (
     HexBytes,
@@ -55,17 +55,21 @@ from hexbytes import (
 
 from web3._utils.abi import (
     filter_by_argument_name,
+    filter_by_argument_type,
+    get_abi_element_signature,
+    get_name_from_abi_element_identifier,
 )
-from web3._utils.abi_element_identifiers import (
-    FallbackFn,
-    ReceiveFn,
+from web3._utils.decorators import (
+    deprecated_for,
+)
+from web3._utils.validation import (
+    validate_abi,
 )
 from web3.exceptions import (
     ABIConstructorNotFound,
     ABIFallbackNotFound,
     ABIReceiveNotFound,
     MismatchedABI,
-    Web3TypeError,
     Web3ValidationError,
     Web3ValueError,
 )
@@ -81,9 +85,14 @@ from eth_utils.abi import (  # noqa
     function_abi_to_4byte_selector,
     get_aligned_abi_inputs,
     get_normalized_abi_inputs,
+    get_abi_input_types,
 )
 
 
+def _filter_by_signature(signature: str, contract_abi: ABI) -> List[ABIElement]:
+    return [abi for abi in contract_abi if abi_to_signature(abi) == signature]
+
+
 def _filter_by_argument_count(
     num_arguments: int, contract_abi: ABI
 ) -> List[ABIElement]:
@@ -98,9 +107,9 @@ def _filter_by_argument_count(
 
 def _filter_by_encodability(
     abi_codec: codec.ABIEncoder,
+    args: Sequence[Any],
+    kwargs: Dict[str, Any],
     contract_abi: ABI,
-    *args: Optional[Sequence[Any]],
-    **kwargs: Optional[Dict[str, Any]],
 ) -> List[ABICallable]:
     return [
         cast(ABICallable, function_abi)
@@ -158,13 +167,118 @@ def _get_fallback_function_abi(contract_abi: ABI) -> ABIFallback:
         raise ABIFallbackNotFound("No fallback function was found in the contract ABI.")
 
 
+def _get_any_abi_signature_with_name(element_name: str, contract_abi: ABI) -> str:
+    """
+    Find an ABI identifier signature by element name. A signature identifier is
+    returned, "name(arg1Type,arg2Type,...)".
+
+    This function forces one result to be returned even if multiple are found.
+    If multiple ABIs are found and all contain arguments, the first result is returned.
+    Otherwise when one of the ABIs has zero arguments, that signature is returned.
+    """
+    try:
+        # search for function abis with the same name
+        function_abi = get_abi_element(
+            contract_abi, get_name_from_abi_element_identifier(element_name)
+        )
+        return abi_to_signature(function_abi)
+    except MismatchedABI:
+        # If all matching functions have arguments, cannot determine which one
+        # to use. Instead of an exception, return the first matching function.
+        function_abis = filter_abi_by_name(element_name, contract_abi)
+        if len(function_abis) > 0 and all(
+            len(get_abi_input_types(fn)) > 0 for fn in function_abis
+        ):
+            return abi_to_signature(function_abis[0])
+
+        # Use signature for function that does not take arguments
+        return str(get_abi_element_signature(element_name))
+
+
+def _build_abi_input_error(
+    abi: ABI,
+    num_args: int,
+    *args: Any,
+    abi_codec: ABICodec,
+    **kwargs: Any,
+) -> str:
+    """
+    Build a string representation of the ABI input error.
+    """
+    errors: Dict[str, str] = dict(
+        {
+            "zero_args": "",
+            "invalid_args": "",
+            "encoding": "",
+            "unexpected_args": "",
+        }
+    )
+
+    for abi_element in abi:
+        abi_element_input_types = get_abi_input_types(abi_element)
+        abi_signature = abi_to_signature(abi_element)
+        abi_element_name = get_name_from_abi_element_identifier(abi_signature)
+        types: Tuple[str, ...] = tuple()
+        aligned_args: Tuple[Any, ...] = tuple()
+
+        if len(abi_element_input_types) == num_args:
+            if num_args == 0:
+                if not errors["zero_args"]:
+                    errors["zero_args"] += (
+                        "The provided identifier matches multiple elements.\n"
+                        f"If you meant to call `{abi_element_name}()`, "
+                        "please specify the full signature.\n"
+                    )
+
+                errors["zero_args"] += (
+                    f" - signature: {abi_to_signature(abi_element)}, "
+                    f"type: {abi_element['type']}\n"
+                )
+            else:
+                try:
+                    arguments = get_normalized_abi_inputs(abi_element, *args, **kwargs)
+                    types, aligned_args = get_aligned_abi_inputs(abi_element, arguments)
+                except TypeError as e:
+                    errors["invalid_args"] += (
+                        f"Signature: {abi_signature}, type: {abi_element['type']}\n"
+                        f"Arguments do not match types in `{abi_signature}`.\n"
+                        f"Error: {e}\n"
+                    )
+
+            argument_errors = ""
+            for position, (_type, arg) in enumerate(zip(types, aligned_args), start=1):
+                if abi_codec.is_encodable(_type, arg):
+                    argument_errors += f"Argument {position} value `{arg}` is valid.\n"
+                else:
+                    argument_errors += (
+                        f"Argument {position} value `{arg}` is not compatible with "
+                        f"type `{_type}`.\n"
+                    )
+
+            if argument_errors != "":
+                errors["encoding"] += (
+                    f"Signature: {abi_signature}, type: {abi_element['type']}\n"
+                    + argument_errors
+                )
+
+        else:
+            errors["unexpected_args"] += (
+                f"Signature: {abi_signature}, type: {abi_element['type']}\n"
+                f"Expected {len(abi_element_input_types)} argument(s) but received "
+                f"{num_args} argument(s).\n"
+            )
+
+    return "".join(errors.values())
+
+
 def _mismatched_abi_error_diagnosis(
     abi_element_identifier: ABIElementIdentifier,
-    matching_function_signatures: Sequence[str],
-    arg_count_matches: int,
-    encoding_matches: int,
-    *args: Optional[Sequence[Any]],
-    **kwargs: Optional[Dict[str, Any]],
+    abi: ABI,
+    num_matches: int = 0,
+    num_args: int = 0,
+    *args: Optional[Any],
+    abi_codec: Optional[Any] = None,
+    **kwargs: Optional[Any],
 ) -> str:
     """
     Raise a ``MismatchedABI`` when a function ABI lookup results in an error.
@@ -172,32 +286,59 @@ def _mismatched_abi_error_diagnosis(
     An error may result from multiple functions matching the provided signature and
     arguments or no functions are identified.
     """
-    diagnosis = "\n"
-    if arg_count_matches == 0:
-        diagnosis += "Function invocation failed due to improper number of arguments."
-    elif encoding_matches == 0:
-        diagnosis += "Function invocation failed due to no matching argument types."
-    elif encoding_matches > 1:
-        diagnosis += (
-            "Ambiguous argument encoding. "
-            "Provided arguments can be encoded to multiple functions "
-            "matching this call."
-        )
+    name = get_name_from_abi_element_identifier(abi_element_identifier)
+    abis_matching_names = filter_abi_by_name(name, abi)
+    abis_matching_arg_count = [
+        abi_to_signature(abi)
+        for abi in _filter_by_argument_count(num_args, abis_matching_names)
+    ]
+    num_abis_matching_arg_count = len(abis_matching_arg_count)
 
-    collapsed_args = _extract_argument_types(*args)
-    collapsed_kwargs = dict(
-        {(k, _extract_argument_types([v])) for k, v in kwargs.items()}
-    )
+    if abi_codec is None:
+        abi_codec = ABICodec(default_registry)
 
-    return (
-        f"\nCould not identify the intended function with name "
-        f"`{abi_element_identifier}`, positional arguments with type(s) "
-        f"`({collapsed_args})` and keyword arguments with type(s) "
-        f"`{collapsed_kwargs}`."
-        f"\nFound {len(matching_function_signatures)} function(s) with the name "
-        f"`{abi_element_identifier}`: {matching_function_signatures}{diagnosis}"
+    error = "ABI Not Found!\n"
+    if num_matches == 0 and num_abis_matching_arg_count == 0:
+        error += f"No element named `{name}` with {num_args} argument(s).\n"
+    elif num_matches > 1 or num_abis_matching_arg_count > 1:
+        error += (
+            f"Found multiple elements named `{name}` that accept {num_args} "
+            "argument(s).\n"
+        )
+    elif num_abis_matching_arg_count == 1:
+        error += (
+            f"Found {num_abis_matching_arg_count} element(s) named `{name}` that "
+            f"accept {num_args} argument(s).\n"
+            "The provided arguments are not valid.\n"
+        )
+    elif num_matches == 0:
+        error += (
+            f"Unable to find an element named `{name}` that matches the provided "
+            "identifier and argument types.\n"
+        )
+    arg_types = _extract_argument_types(*args)
+    kwarg_types = dict({(k, _extract_argument_types([v])) for k, v in kwargs.items()})
+    error += (
+        f"Provided argument types: ({arg_types})\n"
+        f"Provided keyword argument types: {kwarg_types}\n\n"
     )
 
+    if abis_matching_names:
+        error += (
+            f"Tried to find a matching ABI element named `{name}`, but encountered "
+            "the following problems:\n"
+        )
+
+        error += _build_abi_input_error(
+            abis_matching_names,
+            num_args,
+            *args,
+            abi_codec=abi_codec,
+            **kwargs,
+        )
+
+    return f"\n{error}"
+
 
 def _extract_argument_types(*args: Sequence[Any]) -> str:
     """
@@ -231,6 +372,102 @@ def _get_argument_readable_type(arg: Any) -> str:
     return arg.__class__.__name__
 
 
+def _build_abi_filters(
+    abi_element_identifier: ABIElementIdentifier,
+    *args: Optional[Any],
+    abi_type: Optional[str] = None,
+    argument_names: Optional[Sequence[str]] = None,
+    argument_types: Optional[Sequence[str]] = None,
+    abi_codec: Optional[Any] = None,
+    **kwargs: Optional[Any],
+) -> List[Callable[..., Sequence[ABIElement]]]:
+    """
+    Build a list of ABI filters to find an ABI element within a contract ABI. Each
+    filter is a partial function that takes a contract ABI and returns a filtered list.
+    Each parameter is checked before applying the relevant filter.
+
+    When the ``abi_element_identifier`` is a function name or signature and no arguments
+    are provided, the returned filters include the function name or signature.
+
+    A function ABI may take arguments and keyword arguments. When the ``args`` and
+    ``kwargs`` values are passed, several filters are combined together. Available
+    filters include the function name, argument count, argument name, argument type,
+    and argument encodability.
+
+    ``constructor``, ``fallback``, and ``receive`` ABI elements are handled only with a
+    filter by type.
+    """
+    if not isinstance(abi_element_identifier, str):
+        abi_element_identifier = get_abi_element_signature(abi_element_identifier)
+
+    if abi_element_identifier in ["constructor", "fallback", "receive"]:
+        return [functools.partial(filter_abi_by_type, abi_element_identifier)]
+
+    filters: List[Callable[..., Sequence[ABIElement]]] = []
+
+    if abi_type:
+        filters.append(functools.partial(filter_abi_by_type, abi_type))
+
+    arg_count = 0
+    if argument_names:
+        arg_count = len(argument_names)
+    elif args or kwargs:
+        arg_count = len(args) + len(kwargs)
+
+    if arg_count > 0:
+        filters.append(
+            functools.partial(
+                filter_abi_by_name,
+                get_name_from_abi_element_identifier(abi_element_identifier),
+            )
+        )
+        filters.append(functools.partial(_filter_by_argument_count, arg_count))
+
+        if args or kwargs:
+            if abi_codec is None:
+                abi_codec = ABICodec(default_registry)
+
+            filters.append(
+                functools.partial(
+                    _filter_by_encodability,
+                    abi_codec,
+                    args,
+                    kwargs,
+                )
+            )
+
+        if argument_names:
+            filters.append(functools.partial(filter_by_argument_name, argument_names))
+
+            if argument_types:
+                if arg_count != len(argument_types):
+                    raise Web3ValidationError(
+                        "The number of argument names and types must match."
+                    )
+
+                filters.append(
+                    functools.partial(filter_by_argument_type, argument_types)
+                )
+
+        if "(" in abi_element_identifier:
+            filters.append(
+                functools.partial(_filter_by_signature, abi_element_identifier)
+            )
+    else:
+        filters.append(
+            functools.partial(
+                filter_abi_by_name,
+                get_name_from_abi_element_identifier(abi_element_identifier),
+            )
+        )
+        if "(" in abi_element_identifier:
+            filters.append(
+                functools.partial(_filter_by_signature, abi_element_identifier)
+            )
+
+    return filters
+
+
 def get_abi_element_info(
     abi: ABI,
     abi_element_identifier: ABIElementIdentifier,
@@ -306,16 +543,21 @@ def get_abi_element_info(
 def get_abi_element(
     abi: ABI,
     abi_element_identifier: ABIElementIdentifier,
-    *args: Optional[Sequence[Any]],
+    *args: Optional[Any],
     abi_codec: Optional[Any] = None,
-    **kwargs: Optional[Dict[str, Any]],
+    **kwargs: Optional[Any],
 ) -> ABIElement:
     """
-    Return the interface for an ``ABIElement`` which matches the provided identifier
-    and arguments.
+    Return the interface for an ``ABIElement`` from the ``abi`` that matches the
+    provided identifier and arguments.
+
+    ``abi`` may be a list of all ABI elements in a contract or a subset of elements.
+    Passing only functions or events can be useful when names are not deterministic.
+    For example, if names overlap between functions and events.
 
-    The ABI which matches the provided identifier, named arguments (``args``) and
-    keyword args (``kwargs``) will be returned.
+    The ``ABIElementIdentifier`` value may be a function name, signature, or a
+    ``FallbackFn`` or ``ReceiveFn``. When named arguments (``args``) and/or keyword args
+    (``kwargs``) are provided, they are included in the search filters.
 
     The `abi_codec` may be overridden if custom encoding and decoding is required. The
     default is used if no codec is provided. More details about customizations are in
@@ -323,7 +565,9 @@ def get_abi_element(
 
     :param abi: Contract ABI.
     :type abi: `ABI`
-    :param abi_element_identifier: Find an element ABI with matching identifier.
+    :param abi_element_identifier: Find an element ABI with matching identifier. The \
+    identifier may be a function name, signature, or ``FallbackFn`` or ``ReceiveFn``. \
+    A function signature is in the form ``name(arg1Type,arg2Type,...)``.
     :type abi_element_identifier: `ABIElementIdentifier`
     :param args: Find an element ABI with matching args.
     :type args: `Optional[Sequence[Any]]`
@@ -358,55 +602,38 @@ def get_abi_element(
 'type': 'uint256'}], 'payable': False, 'stateMutability': 'nonpayable', \
 'type': 'function'}
     """
+    validate_abi(abi)
+
     if abi_codec is None:
         abi_codec = ABICodec(default_registry)
 
-    if abi_element_identifier is FallbackFn or abi_element_identifier == "fallback":
-        return _get_fallback_function_abi(abi)
-
-    if abi_element_identifier is ReceiveFn or abi_element_identifier == "receive":
-        return _get_receive_function_abi(abi)
-
-    if abi_element_identifier is None or not is_text(abi_element_identifier):
-        raise Web3TypeError("Unsupported function identifier")
-
-    filtered_abis_by_name: Sequence[ABIElement]
-    if abi_element_identifier == "constructor":
-        filtered_abis_by_name = [_get_constructor_function_abi(abi)]
-    else:
-        filtered_abis_by_name = filter_abi_by_name(
-            cast(str, abi_element_identifier), abi
-        )
-
-    arg_count = len(args) + len(kwargs)
-    filtered_abis_by_arg_count = _filter_by_argument_count(
-        arg_count, filtered_abis_by_name
-    )
-
-    if not args and not kwargs and len(filtered_abis_by_arg_count) == 1:
-        return filtered_abis_by_arg_count[0]
-
-    elements_with_encodable_args = _filter_by_encodability(
-        abi_codec, filtered_abis_by_arg_count, *args, **kwargs
+    abi_element_matches: Sequence[ABIElement] = pipe(
+        abi,
+        *_build_abi_filters(
+            abi_element_identifier,
+            *args,
+            abi_codec=abi_codec,
+            **kwargs,
+        ),
     )
 
-    if len(elements_with_encodable_args) != 1:
-        matching_function_signatures = [
-            abi_to_signature(func) for func in filtered_abis_by_name
-        ]
+    num_matches = len(abi_element_matches)
 
+    # Raise MismatchedABI when more than one found
+    if num_matches != 1:
         error_diagnosis = _mismatched_abi_error_diagnosis(
             abi_element_identifier,
-            matching_function_signatures,
-            len(filtered_abis_by_arg_count),
-            len(elements_with_encodable_args),
+            abi,
+            num_matches,
+            len(args) + len(kwargs),
             *args,
+            abi_codec=abi_codec,
             **kwargs,
         )
 
         raise MismatchedABI(error_diagnosis)
 
-    return elements_with_encodable_args[0]
+    return abi_element_matches[0]
 
 
 def check_if_arguments_can_be_encoded(
@@ -472,12 +699,17 @@ def check_if_arguments_can_be_encoded(
     )
 
 
+@deprecated_for("get_abi_element")
 def get_event_abi(
     abi: ABI,
     event_name: str,
     argument_names: Optional[Sequence[str]] = None,
 ) -> ABIEvent:
     """
+    .. warning::
+        This function is deprecated. It is unable to distinguish between
+        overloaded events. Use ``get_abi_element`` instead.
+
     Find the event interface with the given name and/or arguments.
 
     :param abi: Contract ABI.

{web3-7.5.0.dist-info → web3-7.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 7.5.0
+Version: 7.6.0
 Summary: web3: A Python library for interacting with Ethereum
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation
@@ -32,7 +32,7 @@ Requires-Dist: pydantic >=2.4.0
 Requires-Dist: requests >=2.23.0
 Requires-Dist: typing-extensions >=4.0.1
 Requires-Dist: types-requests >=2.0.0
-Requires-Dist: websockets >=10.0.0
+Requires-Dist: websockets <14.0.0,>=10.0.0
 Requires-Dist: pyunormalize >=15.0.0
 Requires-Dist: pywin32 >=223 ; platform_system == "Windows"
 Provides-Extra: dev

{web3-7.5.0.dist-info → web3-7.6.0.dist-info}/RECORD

@@ -27,13 +27,13 @@ web3/testing.py,sha256=Ury_-7XSstJ8bkCfdGEi4Cr76QzSfW7v_zfPlDlLJj0,923
 web3/tracing.py,sha256=ZcOam7t-uEZXyui6Cndv6RYeCZP5jh1TBn2hG8sv17Q,3098
 web3/types.py,sha256=IKrsUzc-w1nhTQLVW_G43VZJMOxyd_LA1AGPu8DvY-k,13630
 web3/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-web3/_utils/abi.py,sha256=faBdiPgPrS__Nh5tGruGFzLzVwNxoooXVsOeGPgGH4s,25540
+web3/_utils/abi.py,sha256=Y0vIFLEKwiMTdedxRPxVMQ1l-GbRRJia1AP1DqLBvjU,27430
 web3/_utils/abi_element_identifiers.py,sha256=m305lsvUZk-jkPixT0IJd9P5sXqMvmwlwlLeBgEAnBQ,55
 web3/_utils/async_caching.py,sha256=2XnaKCHBTTDK6B2R_YZvjJqIRUpbMDIU1uYrq-Lcyp8,486
 web3/_utils/async_transactions.py,sha256=fodlTP7zpoFhFycWQszJWN0UUAfu5neQTCYJ3eGRCA0,5581
 web3/_utils/batching.py,sha256=SbFKYFCRTrkFMFNa4HA4DkD_Qbjc6atnebMObyuQeHE,6316
 web3/_utils/blocks.py,sha256=SZ17qSJuPAH5Dz-eQPGOsZw_QtkG19zvpSYMv6mEDok,2138
-web3/_utils/contracts.py,sha256=HKYJKJedf8eO5az-YVybrqfw0K1__9Da5QyLVfqSPVE,10994
+web3/_utils/contracts.py,sha256=KxZGjQi6lqbsTzlZ2bwN_FEqSYyQ__RIK7se5BmgkKg,12081
 web3/_utils/datatypes.py,sha256=nI0C9XWl46gFj1RpwuoHfVqb4e73wlaerE1LNyMg3oo,1701
 web3/_utils/decorators.py,sha256=bYIoVL0DjHWU2-KOmg-UYg6rICeThlLVZpH9yM2NT8s,1825
 web3/_utils/empty.py,sha256=ccgxFk5qm2x2ZeD8b17wX5cCAJPkPFuHrNQNMDslytY,132
@@ -48,15 +48,15 @@ web3/_utils/http.py,sha256=2R3UOeZmwiQGc3ladf78R9AnufbGaTXAntqf-ZQlZPI,230
 web3/_utils/http_session_manager.py,sha256=Q5K9qJVOAjpO6490McC5kdO4lgjt-c-zxkp0kyDY2pI,11520
 web3/_utils/hypothesis.py,sha256=4Cm4iOWv-uP9irg_Pv63kYNDYUAGhnUH6fOPWRw3A0g,209
 web3/_utils/math.py,sha256=4oU5YdbQBXElxK00CxmUZ94ApXFu9QT_TrO0Kho1HTs,1083
-web3/_utils/method_formatters.py,sha256=s13BbZ1AjD5O7NJ1dnMcj3i1l2Gr91PrQGvJ_QzJmh0,36858
+web3/_utils/method_formatters.py,sha256=a9VxHy9KnraxT7EddFd_CIS82SIOXKoZ_SmdxGE4K-Y,36902
 web3/_utils/module.py,sha256=GuVePloTlIBZwFDOjg0zasp53HSJ32umxN1nQhqW-8Y,3175
 web3/_utils/normalizers.py,sha256=uOaGGgkFXTa5gg6mHgPhP8n035WYpo96xtrvpRPnfNk,7455
-web3/_utils/rpc_abi.py,sha256=ZilBhxXock_3EAnkHPdBcdkaVJfu1TFdxru1cS2AG8Y,8472
+web3/_utils/rpc_abi.py,sha256=zsavkWny01UC8DI_DOVWZc7XcHtlmB9XL97sL0ZcIcs,8525
 web3/_utils/threads.py,sha256=hNlSd_zheQYN0vC1faWWb9_UQxp_UzaM2fI5C8y0kB0,4245
 web3/_utils/transactions.py,sha256=aWMYWiCM_Qs6kFIRWwLGRqAAwCz5fXU8uXcsFGi_Xqo,9044
 web3/_utils/type_conversion.py,sha256=s6cg3WDCQIarQLWw_GfctaJjXhS_EcokUNO-S_ccvng,873
 web3/_utils/utility_methods.py,sha256=7VCpo5ysvPoGjFuDj5gT1Niva2l3BADUvNeJFlL3Yvg,2559
-web3/_utils/validation.py,sha256=TYfkiOIT37zvRy1PqvP9lvbdfLmn1HvlBbHvrFifx1A,6351
+web3/_utils/validation.py,sha256=VGRvM6P2um2bmGP8AgIg3WTXCynyOFIXSIxCo4opL5I,6481
 web3/_utils/windows.py,sha256=IlFUtqYSbUUfFRx60zvEwpiZd080WpOrA4ojm4tmSEE,994
 web3/_utils/caching/__init__.py,sha256=ri-5UGz5PPuYW9W1c2BX5lUJn1oZuvErbDz5NweiveA,284
 web3/_utils/caching/caching_utils.py,sha256=Miqhx1Ne9FVlQK8xVKsMzglIanr6vO887Rm5FWB0KGI,11739
@@ -71,7 +71,7 @@ web3/_utils/contract_sources/contract_data/bytes_contracts.py,sha256=jx2zkR9yqRn
 web3/_utils/contract_sources/contract_data/constructor_contracts.py,sha256=Z0meZqRuvc2eNO_K1OMruRdfMO2Wavf8KE-NSnKtjtQ,6051
 web3/_utils/contract_sources/contract_data/contract_caller_tester.py,sha256=9oeRnNpdbh2M8hNJTuqcxC3dTs3g-MWOz05fgPuB7dk,6228
 web3/_utils/contract_sources/contract_data/emitter_contract.py,sha256=skuuQAXTO57HNERqf2FYwyzoL6_1JOjwx0Z2cvdVopc,40861
-web3/_utils/contract_sources/contract_data/event_contracts.py,sha256=3sX_Yg5imXinwoD6pbNygYtC5m5tpl0-pMl0gQqb12E,5569
+web3/_utils/contract_sources/contract_data/event_contracts.py,sha256=Sy8gg4GIAcYa41dOfl34fM47YLNKA74C3Ongx-pBAzg,9405
 web3/_utils/contract_sources/contract_data/extended_resolver.py,sha256=Jq9S24aNGhLaGXXRrcwW6fC9RwthHDcHg_4YDebAwSo,15720
 web3/_utils/contract_sources/contract_data/fallback_function_contract.py,sha256=W3bnypanJDHbPaxvAglMJb3apK3RAMlU0TtPT5Gqxyg,1649
 web3/_utils/contract_sources/contract_data/function_name_tester_contract.py,sha256=kshI47e64GdSTV2nLmhkGgeZrH0cbjobs1bekEXdYdE,1894
@@ -88,7 +88,7 @@ web3/_utils/contract_sources/contract_data/storage_contract.py,sha256=fZ-4ho-fbV
 web3/_utils/contract_sources/contract_data/string_contract.py,sha256=fJHQg_CxzOt7Ojp5Af067M46tyY6CARkzycS0fL6reQ,11228
 web3/_utils/contract_sources/contract_data/tuple_contracts.py,sha256=PPzVF67kRpeNLXGjUGjpIowGyD3F6fMzqYLuOwXRZbE,23176
 web3/_utils/module_testing/__init__.py,sha256=Xr_S46cjr0mypD_Y4ZbeF1EJ-XWfNxWUks5ykhzN10c,485
-web3/_utils/module_testing/eth_module.py,sha256=Rhb6aq9G6pPVMfShPAAHoFIv_JeA1jvagCfjbLUxk78,187521
+web3/_utils/module_testing/eth_module.py,sha256=NjNFd31GqlMRY9XkHj03z_lkgct2PftZTUlNL4e97ns,187939
 web3/_utils/module_testing/go_ethereum_admin_module.py,sha256=_c-6SyzZkfAJ-7ySXUpw9FEr4cg-ShRdAGSAHWanCtY,3406
 web3/_utils/module_testing/go_ethereum_debug_module.py,sha256=BP1UjK-5ewkYMilvW9jtZX5Mc9BGh3QlJWPXqDNWizU,4144
 web3/_utils/module_testing/go_ethereum_txpool_module.py,sha256=5f8XL8-2x3keyGRaITxMQYl9oQzjgqGn8zobB-j9BPs,1176
@@ -104,14 +104,14 @@ web3/beacon/api_endpoints.py,sha256=0mHrYFYAWHfF9OGzrFdg012L_ocU2nGDXUTU1isOo7o,
 web3/beacon/async_beacon.py,sha256=CPzvyZnMibSYsoIJVrjd3XvZ9aB0bgQRtCP0X0Ekp0o,8156
 web3/beacon/beacon.py,sha256=tPA9ABPm6MyzbzutiphkhFzOAxLresmftG5UjWkuNyY,7236
 web3/contract/__init__.py,sha256=qeZRtTw9xriwoD82w6vePDuPBZ35-CMVdkzViBSH3Qs,293
-web3/contract/async_contract.py,sha256=DB4c7Pz0kZtEhwBwWP41swizVFzk_CwxDU80GDD8X2c,21893
-web3/contract/base_contract.py,sha256=vVomwlM4zfRSB9BN4ss4y0Rc8Szs4howwVushKrio7U,44025
-web3/contract/contract.py,sha256=JqxrJCq5cYGAe50RcabLXjhQab03mmJ0ykQkivYnY_Y,21298
-web3/contract/utils.py,sha256=WfheuUshKK6u1dzIL_rYT44Wv1__gFfs2VxSkw_Xxnc,19234
+web3/contract/async_contract.py,sha256=1sKG3bcG5LzIHH8rAAmcJHRFcUnCvW-btjhZ8BRa_jE,26322
+web3/contract/base_contract.py,sha256=CRFfdP8LSxE104Fo4xdCBgBuy3yD6jop2Soddl2onKE,45264
+web3/contract/contract.py,sha256=fcXKrWxDTdT9N6cYLK7MsjnLw-BTNoyYHShb3cJErFk,25699
+web3/contract/utils.py,sha256=RSdurebK9x5IZ_NJEZZbTjPLKKxgxgU6kSDMOu6XqEc,19276
 web3/eth/__init__.py,sha256=qDLxOcHHIzzPD7xzwy6Wcs0lLPQieB7WN0Ax25ctit8,197
-web3/eth/async_eth.py,sha256=elPH3Atkayk3afwepDRP3ibB7EK8MziK0fPikpKCLxI,23176
+web3/eth/async_eth.py,sha256=-onoBLCCYRBg4oZgY8WQWV3CNFFLyKfckIxdLoLkCRc,23432
 web3/eth/base_eth.py,sha256=UUH0Fw0HVa_mBEQ_CbCDO01yCVDsj33d8yOv7Oe-QD0,6905
-web3/eth/eth.py,sha256=6IL3VecOGvKKbRLvr_hBx8gpWPEf-fZHrRVGGYngYmc,19707
+web3/eth/eth.py,sha256=T-YwH-Kks4cPothiR9GyOqMh6MeMTFRmfI7M2TL4NkY,19940
 web3/gas_strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web3/gas_strategies/rpc.py,sha256=3Va-32jdmHkX7tzQCmh17ms2D6te5zZcqHP1326BdpY,352
 web3/gas_strategies/time_based.py,sha256=oGk6nBUD4iMC8wl1vzf-nhURaqyPWYdPvNU0C3RIs8g,9071
@@ -135,7 +135,7 @@ web3/providers/base.py,sha256=QtBsOCdYeIBF1d3MzQJG0Vo5LduHgAbdiNDcXs9ZQyo,6425
 web3/providers/ipc.py,sha256=3kO7GE8IxVqwpqgfLdomn-L_SeYG48Qs94FsvSdG-tI,6444
 web3/providers/legacy_websocket.py,sha256=6mFEQVlVoc71AyDvPGGt3KQudQKdMxoHvokg6Fb4VOw,4767
 web3/providers/eth_tester/__init__.py,sha256=UggyBQdeAyjy1awATW1933jkJcpqqaUYUQEFAQnA2o0,163
-web3/providers/eth_tester/defaults.py,sha256=9aPe0x2C5wahdGI_rZjiGR3Fe2LbMjKWH9o6eZPuY-Q,12577
+web3/providers/eth_tester/defaults.py,sha256=QQUdqqrkcN1AKW7WEY1A5RiPc_fmlHCLmdgB-5iY7Dc,12622
 web3/providers/eth_tester/main.py,sha256=U19sNDeHs36A4IYQ0HFGyXdZvuXiYvoSMNWVuki0WwI,7807
 web3/providers/eth_tester/middleware.py,sha256=3h8q1WBu5CLiBYwonWFeAR_5pUy_vqgiDmi7wOzuorc,12971
 web3/providers/persistent/__init__.py,sha256=X7tFKJL5BXSwciq5_bRwGRB6bfdWBkIPPWMqCjXIKrA,411
@@ -155,13 +155,13 @@ web3/scripts/parse_pygeth_version.py,sha256=BZjWOsJmYuFbAnFuB1jec9Rl6z0tJJNFFV38
 web3/scripts/release/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web3/scripts/release/test_package.py,sha256=DH0AryllcF4zfpWSd0NLPSQGHNoC-Qng5WYYbS5_4c8,1534
 web3/utils/__init__.py,sha256=zwf8bM-Dl2_L9u_cR5K22_krl0vx4QBAANoBssmbDlU,1857
-web3/utils/abi.py,sha256=iSBaCW41UxB1q1UHDPwJ1QJbdiuYmTWNu8m6E28DqlY,18672
+web3/utils/abi.py,sha256=D7AomiYzqNszLR3sHaP0ZfGtTGmAgKY3MC6ki0WgN38,27071
 web3/utils/address.py,sha256=KC_IpEbixSCuMhaW6V2QCyyJTYKYGS9c8QtI9_aH7zQ,967
 web3/utils/async_exception_handling.py,sha256=OoKbLNwWcY9dxLCbOfxcQPSB1OxWraNqcw8V0ZX-JaQ,3173
 web3/utils/caching.py,sha256=Rkt5IN8A7YBZYXlCRaWa64FiDhTXsxzTGGQdGBB4Nzw,2514
 web3/utils/exception_handling.py,sha256=n-MtO5LNzJDVzHTzO6olzfb2_qEVtVRvink0ixswg-Y,2917
-web3-7.5.0.dist-info/LICENSE,sha256=ScEyLx1vWrB0ybKiZKKTXm5QhVksHCEUtTp4lwYV45I,1095
-web3-7.5.0.dist-info/METADATA,sha256=eO2d-NpcO3F0orh5yam8ZVyXbELVZzWBfLLShYKDlhQ,5368
-web3-7.5.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-web3-7.5.0.dist-info/top_level.txt,sha256=iwupuJh7wgypXrpk_awszyri3TahRr5vxSphNyvt1bU,9
-web3-7.5.0.dist-info/RECORD,,
+web3-7.6.0.dist-info/LICENSE,sha256=ScEyLx1vWrB0ybKiZKKTXm5QhVksHCEUtTp4lwYV45I,1095
+web3-7.6.0.dist-info/METADATA,sha256=V9iF9mKsxvz57FqhU4qRdq8UayI7Km0EDkEWBW6GoXw,5376
+web3-7.6.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+web3-7.6.0.dist-info/top_level.txt,sha256=iwupuJh7wgypXrpk_awszyri3TahRr5vxSphNyvt1bU,9
+web3-7.6.0.dist-info/RECORD,,