web3 6.20.3__py3-none-any.whl → 7.0.0__py3-none-any.whl

web3/contract/base_contract.py

@@ -4,7 +4,6 @@ from typing import (
     Callable,
     Collection,
     Dict,
-    Generator,
     Iterable,
     List,
     NoReturn,
@@ -17,16 +16,27 @@ from typing import (
 )
 import warnings
 
+from eth_abi.exceptions import (
+    InsufficientDataBytes,
+)
 from eth_typing import (
+    ABI,
+    ABIComponentIndexed,
+    ABIElement,
+    ABIEvent,
+    ABIFunction,
     Address,
     ChecksumAddress,
     HexStr,
 )
 from eth_utils import (
+    abi_to_signature,
     add_0x_prefix,
     combomethod,
     encode_hex,
+    filter_abi_by_type,
     function_abi_to_4byte_selector,
+    get_normalized_abi_inputs,
     is_list_like,
     is_text,
     to_tuple,
@@ -36,29 +46,23 @@ from hexbytes import (
 )
 
 from web3._utils.abi import (
-    abi_to_signature,
-    check_if_arguments_can_be_encoded,
     fallback_func_abi_exists,
-    filter_by_type,
-    get_constructor_abi,
+    find_constructor_abi_element_by_type,
     is_array_type,
-    merge_args_and_kwargs,
     receive_func_abi_exists,
 )
+from web3._utils.abi_element_identifiers import (
+    FallbackFn,
+    ReceiveFn,
+)
 from web3._utils.contracts import (
     decode_transaction_data,
     encode_abi,
-    find_matching_event_abi,
-    find_matching_fn_abi,
-    get_function_info,
     prepare_transaction,
 )
 from web3._utils.datatypes import (
     PropertyCheckingFactory,
 )
-from web3._utils.decorators import (
-    deprecate_method,
-)
 from web3._utils.empty import (
     empty,
 )
@@ -75,10 +79,6 @@ from web3._utils.events import (
 from web3._utils.filters import (
     construct_event_filter_params,
 )
-from web3._utils.function_identifiers import (
-    FallbackFn,
-    ReceiveFn,
-)
 from web3._utils.normalizers import (
     BASE_RETURN_NORMALIZERS,
 )
@@ -87,16 +87,20 @@ from web3.datastructures import (
     MutableAttributeDict,
 )
 from web3.exceptions import (
-    ABIEventFunctionNotFound,
+    ABIEventNotFound,
+    ABIFallbackNotFound,
     ABIFunctionNotFound,
-    FallbackNotFound,
+    ABIReceiveNotFound,
     InvalidEventABI,
     LogTopicError,
     MismatchedABI,
     NoABIEventsFound,
     NoABIFound,
     NoABIFunctionsFound,
+    Web3AttributeError,
+    Web3TypeError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.logs import (
     DISCARD,
@@ -106,17 +110,20 @@ from web3.logs import (
     EventLogErrorFlags,
 )
 from web3.types import (
-    ABI,
-    ABIEvent,
-    ABIFunction,
+    ABIElementIdentifier,
     BlockIdentifier,
     EventData,
     FilterParams,
-    FunctionIdentifier,
     TContractFn,
     TxParams,
     TxReceipt,
 )
+from web3.utils.abi import (
+    check_if_arguments_can_be_encoded,
+    get_abi_element,
+    get_abi_element_info,
+    get_event_abi,
+)
 
 if TYPE_CHECKING:
     from web3 import (  # noqa: F401
@@ -129,7 +136,8 @@ if TYPE_CHECKING:
 
 
 class BaseContractEvent:
-    """Base class for contract events
+    """
+    Base class for contract events
 
     An event accessed via the api `contract.events.myEvents(*args, **kwargs)`
     is a subclass of this class.
@@ -152,7 +160,7 @@ class BaseContractEvent:
 
     @classmethod
     def _get_event_abi(cls) -> ABIEvent:
-        return find_matching_event_abi(cls.contract_abi, event_name=cls.event_name)
+        return get_event_abi(cls.contract_abi, event_name=cls.event_name)
 
     @combomethod
     def process_receipt(
@@ -167,14 +175,20 @@ class BaseContractEvent:
         try:
             errors.name
         except AttributeError:
-            raise AttributeError(
+            raise Web3AttributeError(
                 f"Error flag must be one of: {EventLogErrorFlags.flag_options()}"
             )
 
         for log in txn_receipt["logs"]:
             try:
                 rich_log = get_event_data(self.w3.codec, self.abi, log)
-            except (MismatchedABI, LogTopicError, InvalidEventABI, TypeError) as e:
+            except (
+                MismatchedABI,
+                LogTopicError,
+                InvalidEventABI,
+                TypeError,
+                InsufficientDataBytes,
+            ) as e:
                 if errors == DISCARD:
                     continue
                 elif errors == IGNORE:
@@ -189,7 +203,8 @@ class BaseContractEvent:
                         f"The log with transaction hash: {log['transactionHash']!r} "
                         f"and logIndex: {log['logIndex']} encountered the following "
                         f"error during processing: {type(e).__name__}({e}). It has "
-                        "been discarded."
+                        "been discarded.",
+                        stacklevel=2,
                     )
                     continue
             yield rich_log
@@ -203,12 +218,12 @@ class BaseContractEvent:
         self,
         abi: ABIEvent,
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: Optional[BlockIdentifier] = None,
-        blockHash: Optional[HexBytes] = None,
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: Optional[BlockIdentifier] = None,
+        block_hash: Optional[HexBytes] = None,
     ) -> FilterParams:
         if not self.address:
-            raise TypeError(
+            raise Web3TypeError(
                 "This method can be only called on "
                 "an instated contract with an address"
             )
@@ -218,11 +233,12 @@ class BaseContractEvent:
 
         _filters = dict(**argument_filters)
 
-        blkhash_set = blockHash is not None
-        blknum_set = fromBlock is not None or toBlock is not None
+        blkhash_set = block_hash is not None
+        blknum_set = from_block is not None or to_block is not None
         if blkhash_set and blknum_set:
             raise Web3ValidationError(
-                "blockHash cannot be set at the same time as fromBlock or toBlock"
+                "`block_hash` cannot be set at the same time as "
+                "`from_block` or `to_block`"
             )
 
         # Construct JSON-RPC raw filter presentation based on human readable
@@ -232,13 +248,13 @@ class BaseContractEvent:
             self.w3.codec,
             contract_address=self.address,
             argument_filters=_filters,
-            fromBlock=fromBlock,
-            toBlock=toBlock,
+            from_block=from_block,
+            to_block=to_block,
             address=self.address,
         )
 
-        if blockHash is not None:
-            event_filter_params["blockHash"] = blockHash
+        if block_hash is not None:
+            event_filter_params["blockHash"] = block_hash
 
         return event_filter_params
 
@@ -255,12 +271,12 @@ class BaseContractEvent:
         for filter_name, filter_value in _filters.items():
             _input = name_indexed_inputs[filter_name]
             if is_array_type(_input["type"]):
-                raise TypeError(
+                raise Web3TypeError(
                     "createFilter no longer supports array type filter arguments. "
                     "see the build_filter method for filtering array type filters."
                 )
             if is_list_like(filter_value) and is_dynamic_sized_type(_input["type"]):
-                raise TypeError(
+                raise Web3TypeError(
                     "createFilter no longer supports setting filter argument options "
                     "for dynamic sized types. See the build_filter method for setting "
                     "filters with the match_any method."
@@ -279,7 +295,7 @@ class BaseContractEvent:
             # if no non-indexed args in argument filters, since indexed args are
             # filtered pre-call to ``eth_getLogs`` by building specific ``topics``.
             not any(
-                not arg["indexed"]
+                not cast(ABIComponentIndexed, arg)["indexed"]
                 for arg in event_abi["inputs"]
                 if arg["name"] in argument_filters
             )
@@ -318,15 +334,15 @@ class BaseContractEvent:
     def _set_up_filter_builder(
         self,
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: BlockIdentifier = "latest",
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: BlockIdentifier = "latest",
         address: Optional[ChecksumAddress] = None,
         topics: Optional[Sequence[Any]] = None,
         filter_builder: Union[EventFilterBuilder, AsyncEventFilterBuilder] = None,
     ) -> None:
-        if fromBlock is None:
-            raise TypeError(
-                "Missing mandatory keyword argument to create_filter: fromBlock"
+        if from_block is None:
+            raise Web3TypeError(
+                "Missing mandatory keyword argument to create_filter: `from_block`"
             )
 
         if argument_filters is None:
@@ -343,8 +359,8 @@ class BaseContractEvent:
             self.w3.codec,
             contract_address=self.address,
             argument_filters=_filters,
-            fromBlock=fromBlock,
-            toBlock=toBlock,
+            from_block=from_block,
+            to_block=to_block,
             address=address,
             topics=topics,
         )
@@ -352,8 +368,8 @@ class BaseContractEvent:
         filter_builder.address = cast(
             ChecksumAddress, event_filter_params.get("address")
         )
-        filter_builder.fromBlock = event_filter_params.get("fromBlock")
-        filter_builder.toBlock = event_filter_params.get("toBlock")
+        filter_builder.from_block = event_filter_params.get("fromBlock")
+        filter_builder.to_block = event_filter_params.get("toBlock")
         match_any_vals = {
             arg: value
             for arg, value in _filters.items()
@@ -374,7 +390,8 @@ class BaseContractEvent:
 
 
 class BaseContractEvents:
-    """Class containing contract event objects
+    """
+    Class containing contract event objects
 
     This is available via:
 
@@ -403,7 +420,7 @@ class BaseContractEvents:
     ) -> None:
         if abi:
             self.abi = abi
-            self._events = filter_by_type("event", self.abi)
+            self._events = filter_abi_by_type("event", self.abi)
             for event in self._events:
                 setattr(
                     self,
@@ -424,7 +441,7 @@ class BaseContractEvents:
                 "Are you sure you provided the correct contract abi?",
             )
         elif event_name not in self.__dict__["_events"]:
-            raise ABIEventFunctionNotFound(
+            raise ABIEventNotFound(
                 f"The event '{event_name}' was not found in this contract's abi. ",
                 "Are you sure you provided the correct contract abi?",
             )
@@ -435,7 +452,8 @@ class BaseContractEvents:
         return getattr(self, event_name)
 
     def __iter__(self) -> Iterable[Type["BaseContractEvent"]]:
-        """Iterate over supported
+        """
+        Iterate over supported
 
         :return: Iterable of :class:`ContractEvent`
         """
@@ -445,19 +463,20 @@ class BaseContractEvents:
     def __hasattr__(self, event_name: str) -> bool:
         try:
             return event_name in self.__dict__["_events"]
-        except ABIEventFunctionNotFound:
+        except ABIEventNotFound:
             return False
 
 
 class BaseContractFunction:
-    """Base class for contract functions
+    """
+    Base class for contract functions
 
     A function accessed via the api `contract.functions.myMethod(*args, **kwargs)`
     is a subclass of this class.
     """
 
     address: ChecksumAddress = None
-    function_identifier: FunctionIdentifier = None
+    abi_element_identifier: ABIElementIdentifier = None
     w3: Union["Web3", "AsyncWeb3"] = None
     contract_abi: ABI = None
     abi: ABIFunction = None
@@ -473,24 +492,36 @@ class BaseContractFunction:
 
     def _set_function_info(self) -> None:
         if not self.abi:
-            self.abi = find_matching_fn_abi(
-                self.contract_abi,
-                self.w3.codec,
-                self.function_identifier,
-                self.args,
-                self.kwargs,
+            self.abi = cast(
+                ABIFunction,
+                get_abi_element(
+                    self.contract_abi,
+                    self.abi_element_identifier,
+                    *self.args,
+                    abi_codec=self.w3.codec,
+                    **self.kwargs,
+                ),
             )
-        if self.function_identifier in [FallbackFn, ReceiveFn]:
+
+        if self.abi_element_identifier in [
+            FallbackFn,
+            ReceiveFn,
+        ]:
             self.selector = encode_hex(b"")
-        elif is_text(self.function_identifier):
-            # https://github.com/python/mypy/issues/4976
-            self.selector = encode_hex(
-                function_abi_to_4byte_selector(self.abi)  # type: ignore
-            )
+        elif is_text(self.abi_element_identifier):
+            self.selector = encode_hex(function_abi_to_4byte_selector(self.abi))
         else:
-            raise TypeError("Unsupported function identifier")
+            raise Web3TypeError("Unsupported function identifier")
 
-        self.arguments = merge_args_and_kwargs(self.abi, self.args, self.kwargs)
+        if self.abi_element_identifier in [
+            FallbackFn,
+            ReceiveFn,
+        ]:
+            self.arguments = None
+        else:
+            self.arguments = get_normalized_abi_inputs(
+                self.abi, *self.args, **self.kwargs
+            )
 
     def _get_call_txparams(self, transaction: Optional[TxParams] = None) -> TxParams:
         if transaction is None:
@@ -499,26 +530,25 @@ class BaseContractFunction:
             call_transaction = cast(TxParams, dict(**transaction))
 
         if "data" in call_transaction:
-            raise ValueError("Cannot set 'data' field in call transaction")
+            raise Web3ValueError("Cannot set 'data' field in call transaction")
 
         if self.address:
             call_transaction.setdefault("to", self.address)
         if self.w3.eth.default_account is not empty:
-            # type ignored b/c check prevents an empty default_account
             call_transaction.setdefault(
                 "from",
-                self.w3.eth.default_account,  # type: ignore
+                cast(ChecksumAddress, self.w3.eth.default_account),
             )
 
         if "to" not in call_transaction:
             if isinstance(self, type):
-                raise ValueError(
+                raise Web3ValueError(
                     "When using `Contract.[methodtype].[method].call()` from"
                     " a contract factory you "
                     "must provide a `to` address with the transaction"
                 )
             else:
-                raise ValueError(
+                raise Web3ValueError(
                     "Please ensure that this contract instance has an address."
                 )
 
@@ -531,24 +561,23 @@ class BaseContractFunction:
             transact_transaction = cast(TxParams, dict(**transaction))
 
         if "data" in transact_transaction:
-            raise ValueError("Cannot set 'data' field in transact transaction")
+            raise Web3ValueError("Cannot set 'data' field in transact transaction")
 
         if self.address is not None:
             transact_transaction.setdefault("to", self.address)
         if self.w3.eth.default_account is not empty:
-            # type ignored b/c check prevents an empty default_account
             transact_transaction.setdefault(
-                "from", self.w3.eth.default_account  # type: ignore
+                "from", cast(ChecksumAddress, self.w3.eth.default_account)
             )
 
         if "to" not in transact_transaction:
             if isinstance(self, type):
-                raise ValueError(
+                raise Web3ValueError(
                     "When using `Contract.transact` from a contract factory you "
                     "must provide a `to` address with the transaction"
                 )
             else:
-                raise ValueError(
+                raise Web3ValueError(
                     "Please ensure that this contract instance has an address."
                 )
         return transact_transaction
@@ -560,26 +589,25 @@ class BaseContractFunction:
             estimate_gas_transaction = cast(TxParams, dict(**transaction))
 
         if "data" in estimate_gas_transaction:
-            raise ValueError("Cannot set 'data' field in estimate_gas transaction")
+            raise Web3ValueError("Cannot set 'data' field in estimate_gas transaction")
         if "to" in estimate_gas_transaction:
-            raise ValueError("Cannot set to in estimate_gas transaction")
+            raise Web3ValueError("Cannot set to in estimate_gas transaction")
 
         if self.address:
             estimate_gas_transaction.setdefault("to", self.address)
         if self.w3.eth.default_account is not empty:
-            # type ignored b/c check prevents an empty default_account
             estimate_gas_transaction.setdefault(
-                "from", self.w3.eth.default_account  # type: ignore
+                "from", cast(ChecksumAddress, self.w3.eth.default_account)
             )
 
         if "to" not in estimate_gas_transaction:
             if isinstance(self, type):
-                raise ValueError(
+                raise Web3ValueError(
                     "When using `Contract.estimate_gas` from a contract factory "
                     "you must provide a `to` address with the transaction"
                 )
             else:
-                raise ValueError(
+                raise Web3ValueError(
                     "Please ensure that this contract instance has an address."
                 )
         return estimate_gas_transaction
@@ -591,21 +619,23 @@ class BaseContractFunction:
             built_transaction = cast(TxParams, dict(**transaction))
 
         if "data" in built_transaction:
-            raise ValueError("Cannot set 'data' field in build transaction")
+            raise Web3ValueError("Cannot set 'data' field in build transaction")
 
         if not self.address and "to" not in built_transaction:
-            raise ValueError(
+            raise Web3ValueError(
                 "When using `ContractFunction.build_transaction` from a contract "
                 "factory you must provide a `to` address with the transaction"
             )
         if self.address and "to" in built_transaction:
-            raise ValueError("Cannot set 'to' field in contract call build transaction")
+            raise Web3ValueError(
+                "Cannot set 'to' field in contract call build transaction"
+            )
 
         if self.address:
             built_transaction.setdefault("to", self.address)
 
         if "to" not in built_transaction:
-            raise ValueError(
+            raise Web3ValueError(
                 "Please ensure that this contract instance has an address."
             )
 
@@ -650,7 +680,7 @@ class BaseContractFunctions:
         self.address = address
 
         if self.abi:
-            self._functions = filter_by_type("function", self.abi)
+            self._functions = filter_abi_by_type("function", self.abi)
             for func in self._functions:
                 setattr(
                     self,
@@ -661,16 +691,16 @@ class BaseContractFunctions:
                         contract_abi=self.abi,
                         address=self.address,
                         decode_tuples=decode_tuples,
-                        function_identifier=func["name"],
+                        abi_element_identifier=func["name"],
                     ),
                 )
 
-    def __iter__(self) -> Generator[str, None, None]:
+    def __iter__(self) -> Iterable["ABIFunction"]:
         if not hasattr(self, "_functions") or not self._functions:
             return
 
         for func in self._functions:
-            yield func["name"]
+            yield self[func["name"]]
 
     def __getitem__(self, function_name: str) -> ABIFunction:
         return getattr(self, function_name)
@@ -683,7 +713,8 @@ class BaseContractFunctions:
 
 
 class BaseContract:
-    """Base class for Contract proxy classes.
+    """
+    Base class for Contract proxy classes.
 
     First you need to create your Contract classes using
     :meth:`web3.eth.Eth.contract` that takes compiled Solidity contract
@@ -726,21 +757,10 @@ class BaseContract:
 
     #  Public API
     #
-    @combomethod
-    @deprecate_method("encode_abi()")
-    def encodeABI(
-        cls,
-        fn_name: str,
-        args: Optional[Any] = None,
-        kwargs: Optional[Any] = None,
-        data: Optional[HexStr] = None,
-    ) -> HexStr:
-        return cls.encode_abi(fn_name, args, kwargs, data)
-
     @combomethod
     def encode_abi(
         cls,
-        fn_name: str,
+        abi_element_identifier: str,
         args: Optional[Any] = None,
         kwargs: Optional[Any] = None,
         data: Optional[HexStr] = None,
@@ -751,18 +771,21 @@ class BaseContract:
 
         :param data: defaults to function selector
         """
-        fn_abi, fn_selector, fn_arguments = get_function_info(
-            fn_name,
-            cls.w3.codec,
-            contract_abi=cls.abi,
-            args=args,
-            kwargs=kwargs,
+        args = args or tuple()
+        kwargs = kwargs or {}
+
+        element_info = get_abi_element_info(
+            cls.abi,
+            abi_element_identifier,
+            *args,
+            abi_codec=cls.w3.codec,
+            **kwargs,
         )
 
         if data is None:
-            data = fn_selector
+            data = element_info["selector"]
 
-        return encode_abi(cls.w3, fn_abi, fn_arguments, data)
+        return encode_abi(cls.w3, element_info["abi"], element_info["arguments"], data)
 
     @combomethod
     def all_functions(
@@ -775,7 +798,7 @@ class BaseContract:
     @combomethod
     def get_function_by_signature(self, signature: str) -> "BaseContractFunction":
         if " " in signature:
-            raise ValueError(
+            raise Web3ValueError(
                 "Function signature should not contain any spaces. "
                 f"Found spaces in input: {signature}"
             )
@@ -807,9 +830,9 @@ class BaseContract:
         self, selector: Union[bytes, int, HexStr]
     ) -> "BaseContractFunction":
         def callable_check(fn_abi: ABIFunction) -> bool:
-            # typed dict cannot be used w/ a normal Dict
-            # https://github.com/python/mypy/issues/4976
-            return encode_hex(function_abi_to_4byte_selector(fn_abi)) == to_4byte_hex(selector)  # type: ignore # noqa: E501
+            return encode_hex(function_abi_to_4byte_selector(fn_abi)) == to_4byte_hex(
+                selector
+            )
 
         fns = self.find_functions_by_identifier(
             self.abi, self.w3, self.address, callable_check
@@ -820,9 +843,7 @@ class BaseContract:
     def decode_function_input(
         self, data: HexStr
     ) -> Tuple["BaseContractFunction", Dict[str, Any]]:
-        # type ignored b/c expects data arg to be HexBytes
-        data = HexBytes(data)  # type: ignore
-        func = self.get_function_by_selector(data[:4])
+        func = self.get_function_by_selector(HexBytes(data)[:4])
         arguments = decode_transaction_data(
             func.abi, data, normalizers=BASE_RETURN_NORMALIZERS
         )
@@ -832,7 +853,10 @@ class BaseContract:
     def find_functions_by_args(self, *args: Any) -> "BaseContractFunction":
         def callable_check(fn_abi: ABIFunction) -> bool:
             return check_if_arguments_can_be_encoded(
-                fn_abi, self.w3.codec, args=args, kwargs={}
+                fn_abi,
+                *args,
+                abi_codec=self.w3.codec,
+                **{},
             )
 
         return self.find_functions_by_identifier(
@@ -852,7 +876,7 @@ class BaseContract:
     @classmethod
     def _prepare_transaction(
         cls,
-        fn_name: str,
+        abi_element_identifier: ABIElementIdentifier,
         fn_args: Optional[Any] = None,
         fn_kwargs: Optional[Any] = None,
         transaction: Optional[TxParams] = None,
@@ -860,7 +884,7 @@ class BaseContract:
         return prepare_transaction(
             cls.address,
             cls.w3,
-            fn_identifier=fn_name,
+            abi_element_identifier=abi_element_identifier,
             contract_abi=cls.abi,
             transaction=transaction,
             fn_args=fn_args,
@@ -870,45 +894,44 @@ class BaseContract:
     @classmethod
     def _find_matching_fn_abi(
         cls,
-        fn_identifier: Optional[str] = None,
-        args: Optional[Any] = None,
-        kwargs: Optional[Any] = None,
-    ) -> ABIFunction:
-        return find_matching_fn_abi(
-            cls.abi, cls.w3.codec, fn_identifier=fn_identifier, args=args, kwargs=kwargs
+        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,
         )
 
     @classmethod
-    def _find_matching_event_abi(
+    def _get_event_abi(
         cls,
         event_name: Optional[str] = None,
         argument_names: Optional[Sequence[str]] = None,
     ) -> ABIEvent:
-        return find_matching_event_abi(
+        return get_event_abi(
             abi=cls.abi, event_name=event_name, argument_names=argument_names
         )
 
     @combomethod
     def _encode_constructor_data(
-        cls, args: Optional[Any] = None, kwargs: Optional[Any] = None
+        cls, *args: Sequence[Any], **kwargs: Dict[str, Any]
     ) -> HexStr:
-        constructor_abi = get_constructor_abi(cls.abi)
+        constructor_abi = find_constructor_abi_element_by_type(cls.abi)
 
         if constructor_abi:
-            if args is None:
-                args = tuple()
-            if kwargs is None:
-                kwargs = {}
-
-            arguments = merge_args_and_kwargs(constructor_abi, args, kwargs)
+            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 is not None or kwargs is not None:
+            if args or kwargs:
                 msg = "Constructor args were provided, but no constructor function was provided."  # noqa: E501
-                raise TypeError(msg)
+                raise Web3TypeError(msg)
 
             deploy_data = to_hex(cls.bytecode)
 
@@ -947,7 +970,7 @@ class BaseContract:
                 w3=w3,
                 contract_abi=abi,
                 address=address,
-                function_identifier=FallbackFn,
+                abi_element_identifier=FallbackFn,
             )()
 
         return cast(function_type, NonExistentFallbackFunction())  # type: ignore
@@ -965,7 +988,7 @@ class BaseContract:
                 w3=w3,
                 contract_abi=abi,
                 address=address,
-                function_identifier=ReceiveFn,
+                abi_element_identifier=ReceiveFn,
             )()
 
         return cast(function_type, NonExistentReceiveFunction())  # type: ignore
@@ -995,7 +1018,7 @@ class BaseContractCaller:
     """
 
     # mypy types
-    _functions: List[Union[ABIFunction, ABIEvent]]
+    _functions: Sequence[ABIFunction]
 
     def __init__(
         self,
@@ -1011,6 +1034,9 @@ class BaseContractCaller:
         self._functions = []
 
     def __getattr__(self, function_name: str) -> Any:
+        function_names = [
+            fn["name"] for fn in self._functions if fn.get("type") == "function"
+        ]
         if self.abi is None:
             raise NoABIFound(
                 "There is no ABI found for this contract.",
@@ -1020,8 +1046,8 @@ 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 {fn["name"] for fn in self._functions}:
-            functions_available = ", ".join([fn["name"] for fn in self._functions])
+        elif 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.",
                 " Here is a list of all of the function names found: ",
@@ -1075,7 +1101,7 @@ class BaseContractConstructor:
 
     @combomethod
     def _encode_data_in_transaction(self, *args: Any, **kwargs: Any) -> HexStr:
-        constructor_abi = get_constructor_abi(self.abi)
+        constructor_abi = find_constructor_abi_element_by_type(self.abi)
 
         if constructor_abi:
             if not args:
@@ -1083,7 +1109,8 @@ class BaseContractConstructor:
             if not kwargs:
                 kwargs = {}
 
-            arguments = merge_args_and_kwargs(constructor_abi, args, kwargs)
+            arguments = get_normalized_abi_inputs(constructor_abi, *args, **kwargs)
+
             data = add_0x_prefix(
                 encode_abi(self.w3, constructor_abi, arguments, data=self.bytecode)
             )
@@ -1103,9 +1130,8 @@ class BaseContractConstructor:
             )
 
         if self.w3.eth.default_account is not empty:
-            # type ignored b/c check prevents an empty default_account
             estimate_gas_transaction.setdefault(
-                "from", self.w3.eth.default_account  # type: ignore
+                "from", cast(ChecksumAddress, self.w3.eth.default_account)
             )
 
         estimate_gas_transaction["data"] = self.data_in_transaction
@@ -1122,9 +1148,8 @@ class BaseContractConstructor:
             )
 
         if self.w3.eth.default_account is not empty:
-            # type ignored b/c check prevents an empty default_account
             transact_transaction.setdefault(
-                "from", self.w3.eth.default_account  # type: ignore
+                "from", cast(ChecksumAddress, self.w3.eth.default_account)
             )
 
         transact_transaction["data"] = self.data_in_transaction
@@ -1143,7 +1168,7 @@ class BaseContractConstructor:
     ) -> None:
         keys_found = transaction.keys() & forbidden_keys
         if keys_found:
-            raise ValueError(
+            raise Web3ValueError(
                 f"Cannot set '{', '.join(keys_found)}' field(s) in transaction"
             )
 
@@ -1151,7 +1176,7 @@ class BaseContractConstructor:
 class NonExistentFallbackFunction:
     @staticmethod
     def _raise_exception() -> NoReturn:
-        raise FallbackNotFound("No fallback function was found in the contract ABI.")
+        raise ABIFallbackNotFound("No fallback function was found in the contract ABI.")
 
     def __getattr__(self, attr: Any) -> Callable[[], None]:
         return self._raise_exception
@@ -1160,7 +1185,7 @@ class NonExistentFallbackFunction:
 class NonExistentReceiveFunction:
     @staticmethod
     def _raise_exception() -> NoReturn:
-        raise FallbackNotFound("No receive function was found in the contract ABI.")
+        raise ABIReceiveNotFound("No receive function was found in the contract ABI.")
 
     def __getattr__(self, attr: Any) -> Callable[[], None]:
         return self._raise_exception