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

web3/contract/base_contract.py

@@ -49,6 +49,8 @@ from hexbytes import (
 from web3._utils.abi import (
     fallback_func_abi_exists,
     find_constructor_abi_element_by_type,
+    get_abi_element_signature,
+    get_name_from_abi_element_identifier,
     is_array_type,
     receive_func_abi_exists,
 )
@@ -96,7 +98,6 @@ from web3.exceptions import (
     InvalidEventABI,
     LogTopicError,
     MismatchedABI,
-    NoABIEventsFound,
     NoABIFound,
     NoABIFunctionsFound,
     Web3AttributeError,
@@ -121,10 +122,10 @@ from web3.types import (
     TxReceipt,
 )
 from web3.utils.abi import (
+    _get_any_abi_signature_with_name,
     check_if_arguments_can_be_encoded,
     get_abi_element,
     get_abi_element_info,
-    get_event_abi,
 )
 
 if TYPE_CHECKING:
@@ -153,26 +154,55 @@ class BaseContractEvent:
 
     address: ChecksumAddress = None
     event_name: str = None
+    name: str = None
+    abi_element_identifier: ABIElementIdentifier = None
+    signature: str = None
     w3: Union["Web3", "AsyncWeb3"] = None
     contract_abi: ABI = None
     abi: ABIEvent = None
+    argument_names: Tuple[str, ...] = tuple()
+    argument_types: Tuple[str, ...] = tuple()
+    args: Any = None
+    kwargs: Any = None
 
-    def __init__(self, *argument_names: Tuple[str], abi: ABIEvent) -> None:
-        self.abi = abi
-        self.name = type(self).__name__
+    def __init__(self, *argument_names: str, abi: Optional[ABIEvent] = None) -> None:
+        self.abi_element_identifier = type(self).__name__
+        self.name = get_name_from_abi_element_identifier(self.abi_element_identifier)
+        self.event_name = self.name
 
-        if argument_names is None:
-            # https://github.com/python/mypy/issues/6283
-            self.argument_names = tuple()  # type: ignore
-        else:
+        if abi:
+            self.abi = abi
+
+        self.signature = abi_to_signature(self.abi)
+
+        if argument_names:
             self.argument_names = argument_names
 
+        event_inputs = self.abi.get("inputs", [])
+        self.argument_names = tuple([input.get("name", None) for input in event_inputs])
+        self.argument_types = tuple([input["type"] for input in event_inputs])
+
     def __repr__(self) -> str:
-        return f"<Event {abi_to_signature(self.abi)}>"
+        if self.abi:
+            return f"<Event {abi_to_signature(self.abi)}>"
+        return f"<Event {get_abi_element_signature(self.abi_element_identifier)}>"
 
-    @classmethod
+    @combomethod
     def _get_event_abi(cls) -> ABIEvent:
-        return get_event_abi(cls.contract_abi, event_name=cls.event_name)
+        if cls.abi:
+            return cls.abi
+
+        return cast(
+            ABIEvent,
+            get_abi_element(
+                filter_abi_by_type("event", cls.contract_abi),
+                cls.abi_element_identifier,
+                abi_codec=cls.w3.codec,
+            ),
+        )
+
+    def _set_event_info(self) -> None:
+        self.abi = self._get_event_abi()
 
     @combomethod
     def process_receipt(
@@ -275,9 +305,7 @@ class BaseContractEvent:
     def factory(
         cls, class_name: str, **kwargs: Any
     ) -> Union["ContractEvent", "AsyncContractEvent"]:
-        return PropertyCheckingFactory(class_name, (cls,), kwargs)(
-            abi=kwargs.get("abi")
-        )
+        return PropertyCheckingFactory(class_name, (cls,), kwargs)()
 
     @staticmethod
     def check_for_forbidden_api_filter_arguments(
@@ -367,12 +395,10 @@ class BaseContractEvent:
 
         _filters = dict(**argument_filters)
 
-        event_abi = self._get_event_abi()
-
-        self.check_for_forbidden_api_filter_arguments(event_abi, _filters)
+        self.check_for_forbidden_api_filter_arguments(self.abi, _filters)
 
         _, event_filter_params = construct_event_filter_params(
-            self._get_event_abi(),
+            self.abi,
             self.w3.codec,
             contract_address=self.address,
             argument_filters=_filters,
@@ -435,48 +461,36 @@ class BaseContractEvents:
         contract_event_type: Union[Type["ContractEvent"], Type["AsyncContractEvent"]],
         address: Optional[ChecksumAddress] = None,
     ) -> None:
-        if abi:
-            self.abi = abi
-            self._events = filter_abi_by_type("event", self.abi)
-            for event in self._events:
-                setattr(
-                    self,
-                    event["name"],
-                    contract_event_type.factory(
-                        event["name"],
-                        w3=w3,
-                        contract_abi=self.abi,
-                        address=address,
-                        event_name=event["name"],
-                        abi=event,
-                    ),
-                )
+        self.abi = abi
+        self.w3 = w3
+        self.address = address
+        _events: Sequence[ABIEvent] = None
 
-    def __getattr__(self, event_name: str) -> Type["BaseContractEvent"]:
-        if "_events" not in self.__dict__:
-            raise NoABIEventsFound(
-                "The abi for this contract contains no event definitions. ",
-                "Are you sure you provided the correct contract abi?",
-            )
-        elif event_name not in self.__dict__["_events"]:
-            raise ABIEventNotFound(
-                f"The event '{event_name}' was not found in this contract's abi. ",
-                "Are you sure you provided the correct contract abi?",
+        if self.abi:
+            _events = sorted(
+                filter_abi_by_type("event", self.abi),
+                key=lambda evt: (evt["name"], len(evt.get("inputs", []))),
             )
-        else:
-            return super().__getattribute__(event_name)
+            for event in _events:
+                abi_signature = abi_to_signature(event)
+                event_factory = contract_event_type.factory(
+                    abi_signature,
+                    w3=self.w3,
+                    contract_abi=self.abi,
+                    address=self.address,
+                    abi=event,
+                )
 
-    def __getitem__(self, event_name: str) -> Type["BaseContractEvent"]:
-        return getattr(self, event_name)
+                # Set event name on instance if it does not already exist
+                if event["name"] not in self.__dict__:
+                    setattr(self, event["name"], event_factory)
 
-    def __iter__(self) -> Iterable[Type["BaseContractEvent"]]:
-        """
-        Iterate over supported
+                # Set underscore prefixed event signature on instance
+                # Handles ambiguity in overloaded contract events
+                setattr(self, f"_{abi_signature}", event_factory)
 
-        :return: Iterable of :class:`ContractEvent`
-        """
-        for event in self._events:
-            yield self[event["name"]]
+        if _events:
+            self._events = _events
 
     def __hasattr__(self, event_name: str) -> bool:
         try:
@@ -494,52 +508,78 @@ class BaseContractFunction:
     """
 
     address: ChecksumAddress = None
+    fn_name: str = None
+    name: str = None
+    signature: str = None
     abi_element_identifier: ABIElementIdentifier = None
     w3: Union["Web3", "AsyncWeb3"] = None
     contract_abi: ABI = None
     abi: ABIFunction = None
     transaction: TxParams = None
     arguments: Tuple[Any, ...] = None
-    decode_tuples: Optional[bool] = False
+    decode_tuples: Optional[bool] = None
+    argument_names: Tuple[str, ...] = tuple()
+    argument_types: Tuple[str, ...] = tuple()
     args: Any = None
     kwargs: Any = None
 
     def __init__(self, abi: Optional[ABIFunction] = None) -> None:
-        self.abi = abi
-        self.fn_name = type(self).__name__
+        if not self.abi_element_identifier:
+            self.abi_element_identifier = type(self).__name__
 
-    def _set_function_info(self) -> None:
-        if not self.abi:
-            self.abi = cast(
+        self.name = get_name_from_abi_element_identifier(self.abi_element_identifier)
+        self.fn_name = self.name
+
+        if abi:
+            self.abi = abi
+
+        self.signature = abi_to_signature(self.abi)
+
+        event_inputs = self.abi.get("inputs", [])
+        self.argument_names = tuple([input.get("name", None) for input in event_inputs])
+        self.argument_types = tuple([input["type"] for input in event_inputs])
+
+    @combomethod
+    def _get_abi(cls) -> ABIFunction:
+        if not cls.args and not cls.kwargs:
+            # If no args or kwargs are provided, get the ABI element by name
+            return cast(
                 ABIFunction,
                 get_abi_element(
-                    self.contract_abi,
-                    self.abi_element_identifier,
-                    *self.args,
-                    abi_codec=self.w3.codec,
-                    **self.kwargs,
+                    cls.contract_abi,
+                    get_abi_element_signature(cls.abi_element_identifier),
+                    abi_codec=cls.w3.codec,
                 ),
             )
 
-        if self.abi_element_identifier in [
-            FallbackFn,
-            ReceiveFn,
-        ]:
-            self.selector = encode_hex(b"")
-        elif is_text(self.abi_element_identifier):
-            self.selector = encode_hex(function_abi_to_4byte_selector(self.abi))
-        else:
-            raise Web3TypeError("Unsupported function identifier")
+        return cast(
+            ABIFunction,
+            get_abi_element(
+                cls.contract_abi,
+                get_name_from_abi_element_identifier(cls.abi_element_identifier),
+                *cls.args,
+                abi_codec=cls.w3.codec,
+                **cls.kwargs,
+            ),
+        )
 
+    def _set_function_info(self) -> None:
+        self.selector = encode_hex(b"")
         if self.abi_element_identifier in [
+            "fallback",
+            "receive",
             FallbackFn,
             ReceiveFn,
         ]:
+            self.selector = encode_hex(function_abi_to_4byte_selector(self.abi))
             self.arguments = None
-        else:
+        elif is_text(self.abi_element_identifier):
+            self.selector = encode_hex(function_abi_to_4byte_selector(self.abi))
             self.arguments = get_normalized_abi_inputs(
                 self.abi, *self.args, **self.kwargs
             )
+        else:
+            raise Web3TypeError("Unsupported function identifier")
 
     def _get_call_txparams(self, transaction: Optional[TxParams] = None) -> TxParams:
         if transaction is None:
@@ -671,20 +711,20 @@ class BaseContractFunction:
             if self.arguments is not None:
                 _repr += f" bound to {self.arguments!r}"
             return _repr + ">"
-        return f"<Function {self.fn_name}>"
+        return f"<Function {get_abi_element_signature(self.abi_element_identifier)}>"
 
     @classmethod
     def factory(
         cls, class_name: str, **kwargs: Any
     ) -> Union["ContractFunction", "AsyncContractFunction"]:
-        return PropertyCheckingFactory(class_name, (cls,), kwargs)(
-            abi=kwargs.get("abi")
-        )
+        return PropertyCheckingFactory(class_name, (cls,), kwargs)()
 
 
 class BaseContractFunctions:
     """Class containing contract function objects"""
 
+    _functions: Sequence[ABIFunction] = None
+
     def __init__(
         self,
         abi: ABI,
@@ -698,32 +738,38 @@ class BaseContractFunctions:
         self.abi = abi
         self.w3 = w3
         self.address = address
+        _functions: Sequence[ABIFunction] = None
 
         if self.abi:
-            self._functions = filter_abi_by_type("function", self.abi)
-            for func in self._functions:
-                setattr(
-                    self,
-                    func["name"],
-                    contract_function_class.factory(
-                        func["name"],
-                        w3=self.w3,
-                        contract_abi=self.abi,
-                        address=self.address,
-                        decode_tuples=decode_tuples,
-                        abi_element_identifier=func["name"],
-                    ),
+            # Function with least number of inputs is first
+            # This ensures ambiguity will always be deterministic
+            # Prefer function without arguments if present, otherwise
+            # just use the first available
+            _functions = sorted(
+                filter_abi_by_type("function", self.abi),
+                key=lambda fn: (fn["name"], len(fn.get("inputs", []))),
+            )
+            for func in _functions:
+                abi_signature = abi_to_signature(func)
+                function_factory = contract_function_class.factory(
+                    abi_signature,
+                    w3=self.w3,
+                    contract_abi=self.abi,
+                    address=self.address,
+                    decode_tuples=decode_tuples,
+                    abi=func,
                 )
 
-    def __iter__(self) -> Iterable["ABIFunction"]:
-        if not hasattr(self, "_functions") or not self._functions:
-            return
+                # Set function name on instance if it does not already exist
+                if func["name"] not in self.__dict__:
+                    setattr(self, func["name"], function_factory)
 
-        for func in self._functions:
-            yield self[func["name"]]
+                # Set function signature on instance
+                # Handles ambiguity in overloaded contract functions
+                setattr(self, f"_{abi_signature}", function_factory)
 
-    def __getitem__(self, function_name: str) -> ABIFunction:
-        return getattr(self, function_name)
+        if _functions:
+            self._functions = _functions
 
     def __hasattr__(self, function_name: str) -> bool:
         try:
@@ -813,7 +859,7 @@ class BaseContract:
     @combomethod
     def all_functions(
         self,
-    ) -> "BaseContractFunction":
+    ) -> List["BaseContractFunction"]:
         """
         Return all functions in the contract.
         """
@@ -843,7 +889,7 @@ class BaseContract:
         return self.get_function_by_identifier(fns, "signature")
 
     @combomethod
-    def find_functions_by_name(self, fn_name: str) -> "BaseContractFunction":
+    def find_functions_by_name(self, fn_name: str) -> List["BaseContractFunction"]:
         """
         Return all functions with matching name.
         Raises a Web3ValueError if there is no match or more than one is found.
@@ -1080,12 +1126,14 @@ class BaseContract:
         address: Optional[ChecksumAddress] = None,
     ) -> "BaseContractFunction":
         if abi and fallback_func_abi_exists(abi):
+            fallback_abi = filter_abi_by_type("fallback", abi)[0]
             return function_type.factory(
                 "fallback",
                 w3=w3,
                 contract_abi=abi,
                 address=address,
                 abi_element_identifier=FallbackFn,
+                abi=fallback_abi,
             )()
 
         return cast(function_type, NonExistentFallbackFunction())  # type: ignore
@@ -1098,12 +1146,14 @@ class BaseContract:
         address: Optional[ChecksumAddress] = None,
     ) -> "BaseContractFunction":
         if abi and receive_func_abi_exists(abi):
+            receive_abi = filter_abi_by_type("receive", abi)[0]
             return function_type.factory(
                 "receive",
                 w3=w3,
                 contract_abi=abi,
                 address=address,
                 abi_element_identifier=ReceiveFn,
+                abi=receive_abi,
             )()
 
         return cast(function_type, NonExistentReceiveFunction())  # type: ignore
@@ -1138,6 +1188,9 @@ class BaseContract:
         *args: Sequence[Any],
         **kwargs: Dict[str, Any],
     ) -> ABIElement:
+        if not args and not kwargs:
+            fn_identifier = get_abi_element_signature(fn_identifier)
+
         return get_abi_element(
             cls.abi,
             fn_identifier,
@@ -1152,8 +1205,13 @@ class BaseContract:
         event_name: Optional[str] = None,
         argument_names: Optional[Sequence[str]] = None,
     ) -> ABIEvent:
-        return get_event_abi(
-            abi=cls.abi, event_name=event_name, argument_names=argument_names
+        return cast(
+            ABIEvent,
+            get_abi_element(
+                abi=cls.abi,
+                abi_element_identifier=event_name,
+                argument_names=argument_names,
+            ),
         )
 
     @combomethod
@@ -1219,7 +1277,9 @@ class BaseContractCaller:
 
     def __getattr__(self, function_name: str) -> Any:
         function_names = [
-            fn["name"] for fn in self._functions if fn.get("type") == "function"
+            get_name_from_abi_element_identifier(fn["name"])
+            for fn in self._functions
+            if fn.get("type") == "function"
         ]
         if self.abi is None:
             raise NoABIFound(
@@ -1230,7 +1290,7 @@ class BaseContractCaller:
                 "The ABI for this contract contains no function definitions. ",
                 "Are you sure you provided the correct contract ABI?",
             )
-        elif function_name not in function_names:
+        elif get_name_from_abi_element_identifier(function_name) not in function_names:
             functions_available = ", ".join(function_names)
             raise ABIFunctionNotFound(
                 f"The function '{function_name}' was not found in this contract's ABI.",
@@ -1239,11 +1299,17 @@ class BaseContractCaller:
                 "Did you mean to call one of those functions?",
             )
         else:
-            return super().__getattribute__(function_name)
+            function_identifier = function_name
 
-    def __hasattr__(self, event_name: str) -> bool:
+            if "(" not in function_name:
+                function_identifier = _get_any_abi_signature_with_name(
+                    function_name, self._functions
+                )
+            return super().__getattribute__(function_identifier)
+
+    def __hasattr__(self, function_name: str) -> bool:
         try:
-            return event_name in self.__dict__["_events"]
+            return function_name in self.__dict__["_functions"]
         except ABIFunctionNotFound:
             return False