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

web3/contract/contract.py

@@ -13,14 +13,14 @@ from typing import (
 
 from eth_typing import (
     ABI,
+    ABIFunction,
     ChecksumAddress,
 )
 from eth_utils import (
     abi_to_signature,
     combomethod,
+    filter_abi_by_type,
     get_abi_input_names,
-    get_abi_input_types,
-    get_all_function_abis,
 )
 from eth_utils.toolz import (
     partial,
@@ -31,8 +31,6 @@ from hexbytes import (
 
 from web3._utils.abi import (
     fallback_func_abi_exists,
-    filter_by_types,
-    get_abi_element_signature,
     get_name_from_abi_element_identifier,
     receive_func_abi_exists,
 )
@@ -90,6 +88,7 @@ from web3.contract.utils import (
 from web3.exceptions import (
     ABIEventNotFound,
     ABIFunctionNotFound,
+    MismatchedABI,
     NoABIEventsFound,
     NoABIFound,
     NoABIFunctionsFound,
@@ -105,8 +104,9 @@ from web3.types import (
     TxParams,
 )
 from web3.utils.abi import (
+    _filter_by_argument_count,
     _get_any_abi_signature_with_name,
-    filter_abi_by_type,
+    _mismatched_abi_error_diagnosis,
     get_abi_element,
 )
 
@@ -120,26 +120,7 @@ class ContractEvent(BaseContractEvent):
     w3: "Web3"
 
     def __call__(self, *args: Any, **kwargs: Any) -> "ContractEvent":
-        event_abi = get_abi_element(
-            filter_abi_by_type("event", self.contract_abi),
-            self.name,
-            *args,
-            abi_codec=self.w3.codec,
-            **kwargs,
-        )
-        argument_types = get_abi_input_types(event_abi)
-        event_signature = str(
-            get_abi_element_signature(self.abi_element_identifier, argument_types)
-        )
-        contract_event = ContractEvent.factory(
-            event_signature,
-            w3=self.w3,
-            contract_abi=self.contract_abi,
-            address=self.address,
-            abi_element_identifier=event_signature,
-        )
-
-        return copy_contract_event(contract_event, *args, **kwargs)
+        return copy_contract_event(self, *args, **kwargs)
 
     @combomethod
     def get_logs(
@@ -290,7 +271,7 @@ class ContractEvents(BaseContractEvents):
             raise NoABIFound(
                 "There is no ABI found for this contract.",
             )
-        if "_events" not in self.__dict__ or len(self._events) == 0:
+        elif "_events" not in self.__dict__ or len(self._events) == 0:
             raise NoABIEventsFound(
                 "The abi for this contract contains no event definitions. ",
                 "Are you sure you provided the correct contract abi?",
@@ -303,18 +284,23 @@ class ContractEvents(BaseContractEvents):
                 f"The event '{event_name}' was not found in this contract's abi. ",
                 "Are you sure you provided the correct contract abi?",
             )
+
+        if "(" not in event_name:
+            event_name = _get_any_abi_signature_with_name(event_name, self._events)
         else:
-            event_abi = get_abi_element(self._events, event_name)
-            argument_types = get_abi_input_types(event_abi)
-            event_signature = str(get_abi_element_signature(event_name, argument_types))
-            return super().__getattribute__(event_signature)
+            event_name = f"_{event_name}"
+
+        return super().__getattribute__(event_name)
 
     def __getitem__(self, event_name: str) -> "ContractEvent":
         return getattr(self, event_name)
 
     def __iter__(self) -> Iterable["ContractEvent"]:
+        if not hasattr(self, "_events") or not self._events:
+            return
+
         for event in self._events:
-            yield self[event["name"]]
+            yield self[abi_to_signature(event)]
 
 
 class ContractFunction(BaseContractFunction):
@@ -322,39 +308,103 @@ class ContractFunction(BaseContractFunction):
     w3: "Web3"
 
     def __call__(self, *args: Any, **kwargs: Any) -> "ContractFunction":
-        element_name = self.abi_element_identifier
-        if element_name in ["fallback", "receive"] or len(args) + len(kwargs):
-            # Use only the name if a fallback, receive function
-            # or when args/kwargs are present to find the proper element
-            element_name = self.fn_name
-
-        function_abi = get_abi_element(
-            filter_by_types(
-                ["function", "constructor", "fallback", "receive"],
+        # When a function is called, check arguments to obtain the correct function
+        # in the contract. self will be used if all args and kwargs are
+        # encodable to self.abi, otherwise the correct function is obtained from
+        # the contract.
+        if (
+            self.abi_element_identifier in [FallbackFn, ReceiveFn]
+            or self.abi_element_identifier == "constructor"
+        ):
+            return copy_contract_function(self, *args, **kwargs)
+
+        all_functions = cast(
+            List[ABIFunction],
+            filter_abi_by_type(
+                "function",
                 self.contract_abi,
             ),
-            element_name,
-            *args,
-            abi_codec=self.w3.codec,
-            **kwargs,
         )
-
-        argument_types = None
-        if function_abi["type"] not in ["fallback", "receive"]:
-            argument_types = get_abi_input_types(function_abi)
-
-        function_signature = str(
-            get_abi_element_signature(self.abi_element_identifier, argument_types)
+        # Filter functions by name to obtain function signatures
+        function_name = get_name_from_abi_element_identifier(
+            self.abi_element_identifier
         )
-        contract_function = ContractFunction.factory(
-            function_signature,
-            w3=self.w3,
-            contract_abi=self.contract_abi,
-            address=self.address,
-            abi_element_identifier=function_signature,
-            decode_tuples=self.decode_tuples,
+        function_abis = [
+            function for function in all_functions if function["name"] == function_name
+        ]
+        num_args = len(args) + len(kwargs)
+        function_abis_with_arg_count = cast(
+            List[ABIFunction],
+            _filter_by_argument_count(
+                num_args,
+                function_abis,
+            ),
         )
 
+        if not len(function_abis_with_arg_count):
+            # Build an ABI without arguments to determine if one exists
+            function_abis_with_arg_count = [
+                ABIFunction({"type": "function", "name": function_name})
+            ]
+
+        # Check that arguments in call match a function ABI
+        num_attempts = 0
+        function_abi_matches = []
+        contract_function = None
+        for abi in function_abis_with_arg_count:
+            try:
+                num_attempts += 1
+
+                # Search for a function ABI that matches the arguments used
+                function_abi_matches.append(
+                    cast(
+                        ABIFunction,
+                        get_abi_element(
+                            function_abis,
+                            abi_to_signature(abi),
+                            *args,
+                            abi_codec=self.w3.codec,
+                            **kwargs,
+                        ),
+                    )
+                )
+            except MismatchedABI:
+                # ignore exceptions
+                continue
+
+        if len(function_abi_matches) == 1:
+            function_abi = function_abi_matches[0]
+            if abi_to_signature(self.abi) == abi_to_signature(function_abi):
+                contract_function = self
+            else:
+                # Found a match that is not self
+                contract_function = ContractFunction.factory(
+                    abi_to_signature(function_abi),
+                    w3=self.w3,
+                    contract_abi=self.contract_abi,
+                    address=self.address,
+                    abi_element_identifier=abi_to_signature(function_abi),
+                    abi=function_abi,
+                )
+        else:
+            for abi in function_abi_matches:
+                if abi_to_signature(self.abi) == abi_to_signature(abi):
+                    contract_function = self
+                    break
+            else:
+                # Raise exception if multiple found
+                raise MismatchedABI(
+                    _mismatched_abi_error_diagnosis(
+                        function_name,
+                        self.contract_abi,
+                        len(function_abi_matches),
+                        num_args,
+                        *args,
+                        abi_codec=self.w3.codec,
+                        **kwargs,
+                    )
+                )
+
         return copy_contract_function(contract_function, *args, **kwargs)
 
     @classmethod
@@ -364,7 +414,7 @@ class ContractFunction(BaseContractFunction):
     def call(
         self,
         transaction: Optional[TxParams] = None,
-        block_identifier: BlockIdentifier = None,
+        block_identifier: Optional[BlockIdentifier] = None,
         state_override: Optional[StateOverride] = None,
         ccip_read_enabled: Optional[bool] = None,
     ) -> Any:
@@ -389,9 +439,9 @@ class ContractFunction(BaseContractFunction):
             addr = contract.functions.owner().call()
 
         :param transaction: Dictionary of transaction info for web3 interface
-        :param block_identifier: TODO
-        :param state_override TODO
-        :param ccip_read_enabled TODO
+        :param block_identifier: Block number or string "latest", "pending", "earliest"
+        :param state_override: Dictionary of state override values
+        :param ccip_read_enabled: Enable CCIP read operations for the call
         :return: ``Caller`` object that has contract public functions
             and variables exposed as Python methods
         """
@@ -475,12 +525,14 @@ class ContractFunction(BaseContractFunction):
         address: Optional[ChecksumAddress] = None,
     ) -> "ContractFunction":
         if abi and fallback_func_abi_exists(abi):
+            fallback_abi = filter_abi_by_type("fallback", abi)[0]
             return ContractFunction.factory(
                 "fallback",
                 w3=w3,
                 contract_abi=abi,
                 address=address,
                 abi_element_identifier=FallbackFn,
+                abi=fallback_abi,
             )()
         return cast(ContractFunction, NonExistentFallbackFunction())
 
@@ -491,12 +543,14 @@ class ContractFunction(BaseContractFunction):
         address: Optional[ChecksumAddress] = None,
     ) -> "ContractFunction":
         if abi and receive_func_abi_exists(abi):
+            receive_abi = filter_abi_by_type("receive", abi)[0]
             return ContractFunction.factory(
                 "receive",
                 w3=w3,
                 contract_abi=abi,
                 address=address,
                 abi_element_identifier=ReceiveFn,
+                abi=receive_abi,
             )()
         return cast(ContractFunction, NonExistentReceiveFunction())
 
@@ -533,19 +587,19 @@ class ContractFunctions(BaseContractFunctions):
             for function in self._functions
         ]:
             raise ABIFunctionNotFound(
-                f"The function '{function_name}' was not found in this contract's "
-                "abi. Are you sure you provided the correct contract abi?",
+                f"The function '{function_name}' was not found in this ",
+                "contract's abi.",
             )
 
-        function_identifier = function_name
-
         if "(" not in function_name:
-            function_identifier = _get_any_abi_signature_with_name(
+            function_name = _get_any_abi_signature_with_name(
                 function_name, self._functions
             )
+        else:
+            function_name = f"_{function_name}"
 
         return super().__getattribute__(
-            function_identifier,
+            function_name,
         )
 
     def __getitem__(self, function_name: str) -> "ContractFunction":
@@ -574,7 +628,8 @@ class Contract(BaseContract):
             )
 
         if address:
-            self.address = normalize_address(cast("ENS", _w3.ens), address)
+            # invoke ``w3._ens`` over ``w3.ens`` to avoid premature instantiation
+            self.address = normalize_address(cast("ENS", _w3._ens), address)
 
         if not self.address:
             raise Web3TypeError(
@@ -585,7 +640,11 @@ class Contract(BaseContract):
             self.abi, _w3, self.address, decode_tuples=self.decode_tuples
         )
         self.caller = ContractCaller(
-            self.abi, _w3, self.address, decode_tuples=self.decode_tuples
+            self.abi,
+            _w3,
+            self.address,
+            decode_tuples=self.decode_tuples,
+            contract_functions=self.functions,
         )
         self.events = ContractEvents(self.abi, _w3, self.address)
         self.fallback = Contract.get_fallback_function(
@@ -609,7 +668,8 @@ class Contract(BaseContract):
 
         normalizers = {
             "abi": normalize_abi,
-            "address": partial(normalize_address, w3.ens),
+            # invoke ``w3._ens`` over ``w3.ens`` to avoid premature instantiation
+            "address": partial(normalize_address, w3._ens),
             "bytecode": normalize_bytecode,
             "bytecode_runtime": normalize_bytecode,
         }
@@ -641,6 +701,7 @@ class Contract(BaseContract):
             contract.w3,
             contract.address,
             decode_tuples=contract.decode_tuples,
+            contract_functions=contract.functions,
         )
         contract.events = ContractEvents(contract.abi, contract.w3)
         contract.fallback = Contract.get_fallback_function(
@@ -706,7 +767,7 @@ class Contract(BaseContract):
 
     @combomethod
     def get_event_by_identifier(
-        cls, events: Sequence["ContractEvent"], identifier: str
+        self, events: Sequence["ContractEvent"], identifier: str
     ) -> "ContractEvent":
         return get_event_by_identifier(events, identifier)
 
@@ -724,6 +785,7 @@ class ContractCaller(BaseContractCaller):
         block_identifier: BlockIdentifier = None,
         ccip_read_enabled: Optional[bool] = None,
         decode_tuples: Optional[bool] = False,
+        contract_functions: Optional[ContractFunctions] = None,
     ) -> None:
         super().__init__(abi, w3, address, decode_tuples=decode_tuples)
 
@@ -731,18 +793,13 @@ class ContractCaller(BaseContractCaller):
             if transaction is None:
                 transaction = {}
 
-            self._functions = get_all_function_abis(self.abi)
-
-            for func in self._functions:
-                abi_signature = abi_to_signature(func)
-                fn = ContractFunction.factory(
-                    abi_signature,
-                    w3=w3,
-                    contract_abi=self.abi,
-                    address=self.address,
-                    decode_tuples=decode_tuples,
+            if contract_functions is None:
+                contract_functions = ContractFunctions(
+                    abi, w3, address=address, decode_tuples=decode_tuples
                 )
 
+            self._functions = contract_functions._functions
+            for fn in contract_functions.__iter__():
                 caller_method = partial(
                     self.call_function,
                     fn,
@@ -750,8 +807,7 @@ class ContractCaller(BaseContractCaller):
                     block_identifier=block_identifier,
                     ccip_read_enabled=ccip_read_enabled,
                 )
-
-                setattr(self, abi_signature, caller_method)
+                setattr(self, str(fn.abi_element_identifier), caller_method)
 
     def __call__(
         self,

web3/contract/utils.py

@@ -343,7 +343,10 @@ def find_functions_by_identifier(
     """
     Given a contract ABI, return a list of TContractFunction instances.
     """
-    fns_abi = filter_abi_by_type("function", contract_abi)
+    fns_abi = sorted(
+        filter_abi_by_type("function", contract_abi),
+        key=lambda fn: (fn["name"], len(fn.get("inputs", []))),
+    )
     return [
         function_type.factory(
             abi_to_signature(fn_abi),

web3/providers/ipc.py

@@ -164,7 +164,7 @@ class IPCProvider(JSONBaseProvider):
     def _make_request(self, request: bytes) -> RPCResponse:
         with self._lock, self._socket as sock:
             try:
-                sock.sendall(request)
+                sock.sendall(request + b"\n")
             except BrokenPipeError:
                 # one extra attempt, then give up
                 sock = self._socket.reset()

web3/providers/persistent/async_ipc.py

@@ -116,7 +116,7 @@ class AsyncIPCProvider(PersistentConnectionProvider):
 
     async def _socket_send(self, request_data: bytes) -> None:
         try:
-            self._writer.write(request_data)
+            self._writer.write(request_data + b"\n")
             await self._writer.drain()
         except OSError as e:
             # Broken pipe

web3/utils/abi.py

@@ -32,6 +32,16 @@ from eth_typing import (
     HexStr,
     Primitives,
 )
+from eth_utils.abi import (
+    abi_to_signature,
+    event_abi_to_log_topic,
+    filter_abi_by_name,
+    filter_abi_by_type,
+    function_abi_to_4byte_selector,
+    get_abi_input_types,
+    get_aligned_abi_inputs,
+    get_normalized_abi_inputs,
+)
 from eth_utils.address import (
     is_binary_address,
     is_checksum_address,
@@ -55,7 +65,6 @@ 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,
 )
@@ -77,17 +86,6 @@ from web3.types import (
     ABIElementIdentifier,
 )
 
-from eth_utils.abi import (  # noqa
-    abi_to_signature,
-    event_abi_to_log_topic,
-    filter_abi_by_name,
-    filter_abi_by_type,
-    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]
@@ -167,32 +165,35 @@ 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:
+def _get_any_abi_signature_with_name(
+    element_name: str, elements: Sequence[ABIElement]
+) -> 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.
+    If multiple ABIs match the name and every one contain arguments, the first
+    result is returned. Otherwise the signature without arguments is returned.
+    Returns None if no ABI exists with the provided name.
     """
-    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])
+    element_signatures_with_name = [
+        abi_to_signature(element)
+        for element in elements
+        if element.get("name", "") == get_name_from_abi_element_identifier(element_name)
+    ]
 
-        # Use signature for function that does not take arguments
-        return str(get_abi_element_signature(element_name))
+    if len(element_signatures_with_name) == 1:
+        return element_signatures_with_name[0]
+    elif len(element_signatures_with_name) > 1:
+        # Check for function signature without args
+        signature_without_args = f"{element_name}()"
+        if signature_without_args not in element_signatures_with_name:
+            # Element without arguments not found, use the first available signature
+            return element_signatures_with_name[0]
+        else:
+            return signature_without_args
+    else:
+        return None
 
 
 def _build_abi_input_error(
@@ -375,9 +376,6 @@ def _get_argument_readable_type(arg: Any) -> str:
 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]]]:
@@ -405,15 +403,14 @@ def _build_abi_filters(
 
     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:
+    if args or kwargs:
         arg_count = len(args) + len(kwargs)
 
+    # Filter by arg count only if the identifier contains arguments
+    if "()" not in abi_element_identifier and arg_count:
+        filters.append(functools.partial(_filter_by_argument_count, arg_count))
+
     if arg_count > 0:
         filters.append(
             functools.partial(
@@ -421,7 +418,6 @@ def _build_abi_filters(
                 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:
@@ -436,19 +432,6 @@ def _build_abi_filters(
                 )
             )
 
-        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)
@@ -619,7 +602,7 @@ def get_abi_element(
 
     num_matches = len(abi_element_matches)
 
-    # Raise MismatchedABI when more than one found
+    # Raise MismatchedABI unless one match is found
     if num_matches != 1:
         error_diagnosis = _mismatched_abi_error_diagnosis(
             abi_element_identifier,

web3/utils/address.py

@@ -9,6 +9,9 @@ from eth_utils import (
 )
 import rlp
 
+from web3.exceptions import (
+    Web3ValidationError,
+)
 from web3.types import (
     HexStr,
     Nonce,
@@ -30,6 +33,11 @@ def get_create2_address(
     Determine the resulting `CREATE2` opcode contract address for a sender, salt and
     bytecode.
     """
+    if len(to_bytes(hexstr=salt)) != 32:
+        raise Web3ValidationError(
+            f"`salt` must be 32 bytes, {len(to_bytes(hexstr=salt))} != 32"
+        )
+
     contract_address = keccak(
         b"\xff"
         + to_bytes(hexstr=sender)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 7.6.0
+Version: 7.6.1
 Summary: web3: A Python library for interacting with Ethereum
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation
@@ -56,8 +56,8 @@ Requires-Dist: hypothesis >=3.31.2 ; extra == 'dev'
 Requires-Dist: tox >=4.0.0 ; extra == 'dev'
 Requires-Dist: mypy ==1.10.0 ; extra == 'dev'
 Requires-Dist: pre-commit >=3.4.0 ; extra == 'dev'
-Requires-Dist: eth-tester[py-evm] <0.13.0b1,>=0.11.0b1 ; extra == 'dev'
-Requires-Dist: py-geth >=5.0.0 ; extra == 'dev'
+Requires-Dist: eth-tester[py-evm] <0.13.0b1,>=0.12.0b1 ; extra == 'dev'
+Requires-Dist: py-geth >=5.1.0 ; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: sphinx >=6.0.0 ; extra == 'docs'
 Requires-Dist: sphinx-autobuild >=2021.3.14 ; extra == 'docs'
@@ -73,11 +73,11 @@ Requires-Dist: hypothesis >=3.31.2 ; extra == 'test'
 Requires-Dist: tox >=4.0.0 ; extra == 'test'
 Requires-Dist: mypy ==1.10.0 ; extra == 'test'
 Requires-Dist: pre-commit >=3.4.0 ; extra == 'test'
-Requires-Dist: eth-tester[py-evm] <0.13.0b1,>=0.11.0b1 ; extra == 'test'
-Requires-Dist: py-geth >=5.0.0 ; extra == 'test'
+Requires-Dist: eth-tester[py-evm] <0.13.0b1,>=0.12.0b1 ; extra == 'test'
+Requires-Dist: py-geth >=5.1.0 ; extra == 'test'
 Provides-Extra: tester
-Requires-Dist: eth-tester[py-evm] <0.13.0b1,>=0.11.0b1 ; extra == 'tester'
-Requires-Dist: py-geth >=5.0.0 ; extra == 'tester'
+Requires-Dist: eth-tester[py-evm] <0.13.0b1,>=0.12.0b1 ; extra == 'tester'
+Requires-Dist: py-geth >=5.1.0 ; extra == 'tester'
 
 # web3.py