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

web3/contract/base_contract.py

@@ -38,6 +38,8 @@ from eth_utils import (
     get_normalized_abi_inputs,
     is_list_like,
     is_text,
+    keccak,
+    to_bytes,
     to_tuple,
 )
 from hexbytes import (
@@ -46,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,
 )
@@ -66,6 +71,7 @@ from web3._utils.empty import (
     empty,
 )
 from web3._utils.encoding import (
+    hexstr_if_str,
     to_4byte_hex,
     to_hex,
 )
@@ -93,7 +99,6 @@ from web3.exceptions import (
     InvalidEventABI,
     LogTopicError,
     MismatchedABI,
-    NoABIEventsFound,
     NoABIFound,
     NoABIFunctionsFound,
     Web3AttributeError,
@@ -118,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:
@@ -130,8 +135,14 @@ if TYPE_CHECKING:
         Web3,
     )
 
-    from .async_contract import AsyncContractFunction  # noqa: F401
-    from .contract import ContractFunction  # noqa: F401
+    from .async_contract import (  # noqa: F401
+        AsyncContractEvent,
+        AsyncContractFunction,
+    )
+    from .contract import (  # noqa: F401
+        ContractEvent,
+        ContractFunction,
+    )
 
 
 class BaseContractEvent:
@@ -144,29 +155,56 @@ 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]) -> 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
+
         if argument_names is None:
             # https://github.com/python/mypy/issues/6283
             self.argument_names = tuple()  # type: ignore
         else:
             self.argument_names = argument_names
 
-        self.abi = self._get_event_abi()
+    def __repr__(self) -> str:
+        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(
         self, txn_receipt: TxReceipt, errors: EventLogErrorFlags = WARN
     ) -> Iterable[EventData]:
-        return self._parse_logs(txn_receipt, errors)
+        return self._parse_logs(txn_receipt=txn_receipt, errors=errors)
 
+    @combomethod
     @to_tuple
     def _parse_logs(
         self, txn_receipt: TxReceipt, errors: EventLogErrorFlags
@@ -258,8 +296,10 @@ class BaseContractEvent:
         return event_filter_params
 
     @classmethod
-    def factory(cls, class_name: str, **kwargs: Any) -> PropertyCheckingFactory:
-        return PropertyCheckingFactory(class_name, (cls,), kwargs)
+    def factory(
+        cls, class_name: str, **kwargs: Any
+    ) -> Union["ContractEvent", "AsyncContractEvent"]:
+        return PropertyCheckingFactory(class_name, (cls,), kwargs)()
 
     @staticmethod
     def check_for_forbidden_api_filter_arguments(
@@ -349,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,
@@ -414,50 +452,29 @@ class BaseContractEvents:
         self,
         abi: ABI,
         w3: Union["Web3", "AsyncWeb3"],
-        contract_event_type: Type["BaseContractEvent"],
+        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"],
-                    ),
-                )
-
-    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:
@@ -475,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:
@@ -652,18 +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)(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,
@@ -677,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:
@@ -766,7 +807,7 @@ class BaseContract:
     ) -> HexStr:
         """
         Encodes the arguments using the Ethereum ABI for the contract function
-        that matches the given name and arguments..
+        that matches the given name and arguments.
 
         :param data: defaults to function selector
         """
@@ -786,16 +827,27 @@ class BaseContract:
 
         return encode_abi(cls.w3, element_info["abi"], element_info["arguments"], data)
 
+    #
+    # Functions API
+    #
     @combomethod
     def all_functions(
         self,
-    ) -> "BaseContractFunction":
+    ) -> List["BaseContractFunction"]:
+        """
+        Return all functions in the contract.
+        """
         return self.find_functions_by_identifier(
             self.abi, self.w3, self.address, lambda _: True
         )
 
     @combomethod
     def get_function_by_signature(self, signature: str) -> "BaseContractFunction":
+        """
+        Return a distinct function with matching signature.
+        Raises a Web3ValueError if the signature is invalid or if there is no match or
+        more than one is found.
+        """
         if " " in signature:
             raise Web3ValueError(
                 "Function signature should not contain any spaces. "
@@ -811,7 +863,12 @@ 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.
+        """
+
         def callable_check(fn_abi: ABIFunction) -> bool:
             return fn_abi["name"] == fn_name
 
@@ -821,6 +878,10 @@ class BaseContract:
 
     @combomethod
     def get_function_by_name(self, fn_name: str) -> "BaseContractFunction":
+        """
+        Return a distinct function with matching name.
+        Raises a Web3ValueError if there is no match or more than one is found.
+        """
         fns = self.find_functions_by_name(fn_name)
         return self.get_function_by_identifier(fns, "name")
 
@@ -828,6 +889,11 @@ class BaseContract:
     def get_function_by_selector(
         self, selector: Union[bytes, int, HexStr]
     ) -> "BaseContractFunction":
+        """
+        Return a distinct function with matching 4byte selector.
+        Raises a Web3ValueError if there is no match or more than one is found.
+        """
+
         def callable_check(fn_abi: ABIFunction) -> bool:
             return encode_hex(function_abi_to_4byte_selector(fn_abi)) == to_4byte_hex(
                 selector
@@ -842,6 +908,9 @@ class BaseContract:
     def decode_function_input(
         self, data: HexStr
     ) -> Tuple["BaseContractFunction", Dict[str, Any]]:
+        """
+        Return a Tuple of the function selector and decoded arguments.
+        """
         func = self.get_function_by_selector(HexBytes(data)[:4])
         arguments = decode_transaction_data(
             func.abi, data, normalizers=BASE_RETURN_NORMALIZERS
@@ -850,6 +919,11 @@ class BaseContract:
 
     @combomethod
     def find_functions_by_args(self, *args: Any) -> "BaseContractFunction":
+        """
+        Return all functions with matching args, checking each argument can be encoded
+        with the type.
+        """
+
         def callable_check(fn_abi: ABIFunction) -> bool:
             return check_if_arguments_can_be_encoded(
                 fn_abi,
@@ -864,77 +938,119 @@ class BaseContract:
 
     @combomethod
     def get_function_by_args(self, *args: Any) -> "BaseContractFunction":
+        """
+        Return a distinct function with matching args, checking each argument can be
+        encoded with the type.
+        Raises a Web3ValueError if there is no match or more than one is found.
+        """
         fns = self.find_functions_by_args(*args)
         return self.get_function_by_identifier(fns, "args")
 
     #
-    # Private Helpers
+    #  Events API
     #
-    _return_data_normalizers: Tuple[Callable[..., Any], ...] = tuple()
+    @combomethod
+    def all_events(self) -> List["BaseContractEvent"]:
+        """
+        Return all events in the contract.
+        """
+        return self.find_events_by_identifier(
+            self.abi, self.w3, self.address, lambda _: True
+        )
 
-    @classmethod
-    def _prepare_transaction(
-        cls,
-        abi_element_identifier: ABIElementIdentifier,
-        fn_args: Optional[Any] = None,
-        fn_kwargs: Optional[Any] = None,
-        transaction: Optional[TxParams] = None,
-    ) -> TxParams:
-        return prepare_transaction(
-            cls.address,
-            cls.w3,
-            abi_element_identifier=abi_element_identifier,
-            contract_abi=cls.abi,
-            transaction=transaction,
-            fn_args=fn_args,
-            fn_kwargs=fn_kwargs,
+    @combomethod
+    def get_event_by_signature(self, signature: str) -> "BaseContractEvent":
+        """
+        Return a distinct event with matching signature.
+        Raises a Web3ValueError if the signature is invalid or if there is no match or
+        more than one is found.
+        """
+
+        def callable_check(event_abi: ABIEvent) -> bool:
+            return abi_to_signature(event_abi) == signature.replace(" ", "")
+
+        events = self.find_events_by_identifier(
+            self.abi, self.w3, self.address, callable_check
         )
+        return self.get_event_by_identifier(events, "signature")
 
-    @classmethod
-    def _find_matching_fn_abi(
-        cls,
-        fn_identifier: Optional[ABIElementIdentifier] = None,
-        *args: Sequence[Any],
-        **kwargs: Dict[str, Any],
-    ) -> ABIElement:
-        return get_abi_element(
-            cls.abi,
-            fn_identifier,
-            *args,
-            abi_codec=cls.w3.codec,
-            **kwargs,
+    @combomethod
+    def find_events_by_name(self, event_name: str) -> List["BaseContractEvent"]:
+        """
+        Return all events with matching name.
+        Raises a Web3ValueError if there is no match or more than one is found.
+        """
+
+        def callable_check(fn_abi: ABIFunction) -> bool:
+            return fn_abi["name"] == event_name
+
+        return self.find_events_by_identifier(
+            self.abi, self.w3, self.address, callable_check
         )
 
-    @classmethod
-    def _get_event_abi(
-        cls,
-        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
+    @combomethod
+    def get_event_by_name(self, event_name: str) -> "BaseContractEvent":
+        """
+        Return a distinct event with matching name.
+        Raises a Web3ValueError if there is no match or more than one is found.
+        """
+        events = self.find_events_by_name(event_name)
+        return self.get_event_by_identifier(events, "name")
+
+    @combomethod
+    def find_events_by_selector(
+        self, selector: Union[bytes, int, HexStr]
+    ) -> List["BaseContractEvent"]:
+        """
+        Return all events with matching selector.
+        Raises a Web3ValueError if there is no match or more than one is found.
+        """
+
+        def callable_check(event_abi: ABIEvent) -> bool:
+            return encode_hex(
+                keccak(text=abi_to_signature(event_abi).replace(" ", ""))
+            ) == encode_hex(hexstr_if_str(to_bytes, selector))
+
+        return self.find_events_by_identifier(
+            self.abi, self.w3, self.address, callable_check
         )
 
     @combomethod
-    def _encode_constructor_data(
-        cls, *args: Sequence[Any], **kwargs: Dict[str, Any]
-    ) -> HexStr:
-        constructor_abi = find_constructor_abi_element_by_type(cls.abi)
+    def get_event_by_selector(
+        self, selector: Union[bytes, int, HexStr]
+    ) -> "BaseContractEvent":
+        """
+        Return a distinct event with matching keccak selector.
+        Raises a Web3ValueError if there is no match or more than one is found.
+        """
+        events = self.find_events_by_selector(selector)
+        return self.get_event_by_identifier(events, "selector")
 
-        if constructor_abi:
-            arguments = get_normalized_abi_inputs(constructor_abi, *args, **kwargs)
+    @combomethod
+    def find_events_by_topic(self, topic: HexStr) -> List["BaseContractEvent"]:
+        """
+        Return all events with matching topic.
+        Raises a Web3ValueError if there is no match or more than one is found.
+        """
 
-            deploy_data = add_0x_prefix(
-                encode_abi(cls.w3, constructor_abi, arguments, data=cls.bytecode)
+        def callable_check(event_abi: ABIEvent) -> bool:
+            return (
+                encode_hex(keccak(text=abi_to_signature(event_abi).replace(" ", "")))
+                == topic
             )
-        else:
-            if args or kwargs:
-                msg = "Constructor args were provided, but no constructor function was provided."  # noqa: E501
-                raise Web3TypeError(msg)
 
-            deploy_data = to_hex(cls.bytecode)
+        return self.find_events_by_identifier(
+            self.abi, self.w3, self.address, callable_check
+        )
 
-        return deploy_data
+    @combomethod
+    def get_event_by_topic(self, topic: HexStr) -> "BaseContractEvent":
+        """
+        Return a distinct event with matching topic.
+        Raises a Web3ValueError if there is no match or more than one is found.
+        """
+        events = self.find_events_by_topic(topic)
+        return self.get_event_by_identifier(events, "topic")
 
     @combomethod
     def find_functions_by_identifier(
@@ -956,6 +1072,26 @@ class BaseContract:
             "This method should be implemented in the inherited class"
         )
 
+    @combomethod
+    def find_events_by_identifier(
+        cls,
+        contract_abi: ABI,
+        w3: Union["Web3", "AsyncWeb3"],
+        address: ChecksumAddress,
+        callable_check: Callable[..., Any],
+    ) -> List[Any]:
+        raise NotImplementedError(
+            "This method should be implemented in the inherited class"
+        )
+
+    @combomethod
+    def get_event_by_identifier(
+        cls, fns: Sequence["BaseContractEvent"], identifier: str
+    ) -> "BaseContractEvent":
+        raise NotImplementedError(
+            "This method should be implemented in the inherited class"
+        )
+
     @staticmethod
     def get_fallback_function(
         abi: ABI,
@@ -992,6 +1128,83 @@ class BaseContract:
 
         return cast(function_type, NonExistentReceiveFunction())  # type: ignore
 
+    #
+    # Private Helpers
+    #
+    _return_data_normalizers: Tuple[Callable[..., Any], ...] = tuple()
+
+    @classmethod
+    def _prepare_transaction(
+        cls,
+        abi_element_identifier: ABIElementIdentifier,
+        fn_args: Optional[Any] = None,
+        fn_kwargs: Optional[Any] = None,
+        transaction: Optional[TxParams] = None,
+    ) -> TxParams:
+        return prepare_transaction(
+            cls.address,
+            cls.w3,
+            abi_element_identifier=abi_element_identifier,
+            contract_abi=cls.abi,
+            transaction=transaction,
+            fn_args=fn_args,
+            fn_kwargs=fn_kwargs,
+        )
+
+    @classmethod
+    def _find_matching_fn_abi(
+        cls,
+        fn_identifier: Optional[ABIElementIdentifier] = None,
+        *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,
+            *args,
+            abi_codec=cls.w3.codec,
+            **kwargs,
+        )
+
+    @classmethod
+    def _get_event_abi(
+        cls,
+        event_name: Optional[str] = None,
+        argument_names: Optional[Sequence[str]] = None,
+    ) -> ABIEvent:
+        return cast(
+            ABIEvent,
+            get_abi_element(
+                abi=cls.abi,
+                abi_element_identifier=event_name,
+                argument_names=argument_names,
+            ),
+        )
+
+    @combomethod
+    def _encode_constructor_data(
+        cls, *args: Sequence[Any], **kwargs: Dict[str, Any]
+    ) -> HexStr:
+        constructor_abi = find_constructor_abi_element_by_type(cls.abi)
+
+        if constructor_abi:
+            arguments = get_normalized_abi_inputs(constructor_abi, *args, **kwargs)
+
+            deploy_data = add_0x_prefix(
+                encode_abi(cls.w3, constructor_abi, arguments, data=cls.bytecode)
+            )
+        else:
+            if args or kwargs:
+                msg = "Constructor args were provided, but no constructor function was provided."  # noqa: E501
+                raise Web3TypeError(msg)
+
+            deploy_data = to_hex(cls.bytecode)
+
+        return deploy_data
+
 
 class BaseContractCaller:
     """
@@ -1034,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(
@@ -1045,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.",
@@ -1054,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