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

web3/contract/base_contract.py

@@ -48,7 +48,10 @@ from hexbytes import (
 
 from web3._utils.abi import (
     fallback_func_abi_exists,
+    filter_by_types,
     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 +99,6 @@ from web3.exceptions import (
     InvalidEventABI,
     LogTopicError,
     MismatchedABI,
-    NoABIEventsFound,
     NoABIFound,
     NoABIFunctionsFound,
     Web3AttributeError,
@@ -121,10 +123,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,13 +155,20 @@ class BaseContractEvent:
 
     address: ChecksumAddress = None
     event_name: str = None
+    abi_element_identifier: ABIElementIdentifier = None
     w3: Union["Web3", "AsyncWeb3"] = None
     contract_abi: ABI = None
     abi: ABIEvent = None
+    argument_types: Tuple[str] = None
+    args: Any = None
+    kwargs: Any = None
 
-    def __init__(self, *argument_names: Tuple[str], abi: ABIEvent) -> None:
+    def __init__(self, *argument_names: Tuple[str]) -> None:
+        self.event_name = get_name_from_abi_element_identifier(type(self).__name__)
+        self.abi_element_identifier = type(self).__name__
+        abi = self._get_event_abi()
+        self.name = abi_to_signature(abi)
         self.abi = abi
-        self.name = type(self).__name__
 
         if argument_names is None:
             # https://github.com/python/mypy/issues/6283
@@ -168,11 +177,26 @@ class BaseContractEvent:
             self.argument_names = argument_names
 
     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 +299,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 +389,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 +455,26 @@ 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,
-                    ),
-                )
-
-    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?",
-            )
-        else:
-            return super().__getattribute__(event_name)
-
-    def __getitem__(self, event_name: str) -> Type["BaseContractEvent"]:
-        return getattr(self, event_name)
+        self.abi = abi
+        self.w3 = w3
+        self.address = address
+        _events: Sequence[ABIEvent] = None
 
-    def __iter__(self) -> Iterable[Type["BaseContractEvent"]]:
-        """
-        Iterate over supported
+        if self.abi:
+            _events = filter_abi_by_type("event", abi)
+            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,
+                    event_name=event["name"],
+                )
+                setattr(self, 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 +492,80 @@ class BaseContractFunction:
     """
 
     address: ChecksumAddress = None
+    fn_name: str = None
+    name: 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
     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__
+
+        self.fn_name = get_name_from_abi_element_identifier(self.abi_element_identifier)
+        self.abi = cast(
+            ABIFunction,
+            get_abi_element(
+                filter_by_types(
+                    ["function", "constructor", "fallback", "receive"],
+                    self.contract_abi,
+                ),
+                self.abi_element_identifier,
+            ),
+        )
+        self.name = abi_to_signature(self.abi)
 
-    def _set_function_info(self) -> None:
-        if not self.abi:
-            self.abi = cast(
+    @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.abi = self._get_abi()
+
+            self.selector = encode_hex(function_abi_to_4byte_selector(self.abi))
             self.arguments = None
-        else:
+        elif is_text(self.abi_element_identifier):
+            self.abi = self._get_abi()
+
+            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 +697,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 +724,26 @@ 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:
+            _functions = filter_abi_by_type("function", self.abi)
+            for func in _functions:
+                abi_signature = abi_to_signature(func)
                 setattr(
                     self,
-                    func["name"],
+                    abi_signature,
                     contract_function_class.factory(
-                        func["name"],
+                        abi_signature,
                         w3=self.w3,
                         contract_abi=self.abi,
                         address=self.address,
                         decode_tuples=decode_tuples,
-                        abi_element_identifier=func["name"],
                     ),
                 )
 
-    def __iter__(self) -> Iterable["ABIFunction"]:
-        if not hasattr(self, "_functions") or not self._functions:
-            return
-
-        for func in self._functions:
-            yield self[func["name"]]
-
-    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 +833,7 @@ class BaseContract:
     @combomethod
     def all_functions(
         self,
-    ) -> "BaseContractFunction":
+    ) -> List["BaseContractFunction"]:
         """
         Return all functions in the contract.
         """
@@ -843,7 +863,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.
@@ -1138,6 +1158,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 +1175,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 +1247,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 +1260,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 +1269,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