web3 7.0.0b1__py3-none-any.whl → 7.7.0__py3-none-any.whl

web3/_utils/abi.py

@@ -25,7 +25,6 @@ from typing import (
 )
 
 from eth_abi import (
-    codec,
     decoding,
     encoding,
 )
@@ -47,12 +46,24 @@ from eth_abi.registry import (
     registry as default_registry,
 )
 from eth_typing import (
+    ABI,
+    ABIComponent,
+    ABIComponentIndexed,
+    ABIConstructor,
+    ABIElement,
+    ABIEvent,
+    ABIFallback,
+    ABIFunction,
+    ABIReceive,
     HexStr,
     TypeStr,
 )
 from eth_utils import (
-    combomethod,
+    collapse_if_tuple,
     decode_hex,
+    filter_abi_by_type,
+    get_abi_input_names,
+    get_abi_input_types,
     is_bytes,
     is_list_like,
     is_string,
@@ -60,15 +71,16 @@ from eth_utils import (
     to_text,
     to_tuple,
 )
-from eth_utils.abi import (
-    collapse_if_tuple,
-)
 from eth_utils.toolz import (
     curry,
     partial,
     pipe,
 )
 
+from web3._utils.abi_element_identifiers import (
+    FallbackFn,
+    ReceiveFn,
+)
 from web3._utils.decorators import (
     reject_recursive_repeats,
 )
@@ -79,20 +91,15 @@ from web3._utils.formatters import (
     recursive_map,
 )
 from web3.exceptions import (
-    FallbackNotFound,
     MismatchedABI,
+    Web3AttributeError,
+    Web3TypeError,
+    Web3ValueError,
 )
 from web3.types import (
-    ABI,
-    ABIEvent,
-    ABIEventParams,
-    ABIFunction,
-    ABIFunctionParams,
+    ABIElementIdentifier,
     TReturn,
 )
-from web3.utils import (  # public utils module
-    get_abi_input_names,
-)
 
 if TYPE_CHECKING:
     from web3 import (  # noqa: F401
@@ -100,92 +107,94 @@ if TYPE_CHECKING:
     )
 
 
-def filter_by_type(_type: str, contract_abi: ABI) -> List[Union[ABIFunction, ABIEvent]]:
-    return [abi for abi in contract_abi if abi["type"] == _type]
-
-
-def filter_by_name(name: str, contract_abi: ABI) -> List[Union[ABIFunction, ABIEvent]]:
-    return [
-        abi
-        for abi in contract_abi
-        if (
-            abi["type"] not in ("fallback", "constructor", "receive")
-            and abi["name"] == name
-        )
-    ]
-
-
-def get_abi_input_types(abi: ABIFunction) -> List[str]:
-    if "inputs" not in abi and (abi["type"] == "fallback" or abi["type"] == "receive"):
-        return []
-    else:
-        return [collapse_if_tuple(cast(Dict[str, Any], arg)) for arg in abi["inputs"]]
-
-
-def get_abi_output_types(abi: ABIFunction) -> List[str]:
-    if abi["type"] == "fallback":
-        return []
-    else:
-        return [collapse_if_tuple(cast(Dict[str, Any], arg)) for arg in abi["outputs"]]
+def fallback_func_abi_exists(contract_abi: ABI) -> Sequence[ABIFallback]:
+    return filter_abi_by_type("fallback", contract_abi)
 
 
-def get_receive_func_abi(contract_abi: ABI) -> ABIFunction:
-    receive_abis = filter_by_type("receive", contract_abi)
-    if receive_abis:
-        return cast(ABIFunction, receive_abis[0])
-    else:
-        raise FallbackNotFound("No receive function was found in the contract ABI.")
+def receive_func_abi_exists(contract_abi: ABI) -> Sequence[ABIReceive]:
+    return filter_abi_by_type("receive", contract_abi)
 
 
-def get_fallback_func_abi(contract_abi: ABI) -> ABIFunction:
-    fallback_abis = filter_by_type("fallback", contract_abi)
-    if fallback_abis:
-        return cast(ABIFunction, fallback_abis[0])
-    else:
-        raise FallbackNotFound("No fallback function was found in the contract ABI.")
+def get_indexed_event_inputs(event_abi: ABIEvent) -> Sequence[ABIComponentIndexed]:
+    return [arg for arg in event_abi["inputs"] if arg["indexed"] is True]
 
 
-def fallback_func_abi_exists(contract_abi: ABI) -> List[Union[ABIFunction, ABIEvent]]:
-    return filter_by_type("fallback", contract_abi)
+def exclude_indexed_event_inputs(event_abi: ABIEvent) -> Sequence[ABIComponentIndexed]:
+    return [arg for arg in event_abi["inputs"] if arg["indexed"] is False]
 
 
-def receive_func_abi_exists(contract_abi: ABI) -> List[Union[ABIFunction, ABIEvent]]:
-    return filter_by_type("receive", contract_abi)
+def filter_by_types(types: Collection[str], contract_abi: ABI) -> Sequence[ABIElement]:
+    return [abi_element for abi_element in contract_abi if abi_element["type"] in types]
 
 
-def get_indexed_event_inputs(event_abi: ABIEvent) -> List[ABIEventParams]:
-    return [arg for arg in event_abi["inputs"] if arg["indexed"] is True]
+def filter_by_argument_name(
+    argument_names: Collection[str], contract_abi: ABI
+) -> Sequence[ABIElement]:
+    """
+    Return a list of each ``ABIElement`` which contain arguments matching provided
+    names.
+    """
+    abis_with_matching_args = []
+    for abi_element in contract_abi:
+        try:
+            abi_arg_names = get_abi_input_names(abi_element)
 
+            if set(argument_names).intersection(abi_arg_names) == set(argument_names):
+                abis_with_matching_args.append(abi_element)
+        except TypeError:
+            # fallback or receive functions do not have arguments
+            # proceed to next ABIElement
+            continue
 
-def exclude_indexed_event_inputs(event_abi: ABIEvent) -> List[ABIEventParams]:
-    return [arg for arg in event_abi["inputs"] if arg["indexed"] is False]
+    return abis_with_matching_args
 
 
-def get_normalized_abi_arg_type(abi_arg: ABIEventParams) -> str:
+def filter_by_argument_type(
+    argument_types: Collection[str], contract_abi: ABI
+) -> List[ABIElement]:
     """
-    Return the normalized type for the abi argument provided.
-    In order to account for tuple argument types, this abstraction
-    makes use of `collapse_if_tuple()` to collapse the appropriate component
-    types within a tuple type, if present.
+    Return a list of each ``ABIElement`` which contain arguments matching provided
+    types.
     """
-    return collapse_if_tuple(dict(abi_arg))
+    abis_with_matching_args = []
+    for abi_element in contract_abi:
+        try:
+            abi_arg_types = get_abi_input_types(abi_element)
+
+            if set(argument_types).intersection(abi_arg_types) == set(argument_types):
+                abis_with_matching_args.append(abi_element)
+        except ValueError:
+            # fallback or receive functions do not have arguments
+            # proceed to next ABIElement
+            continue
+
+    return abis_with_matching_args
+
+
+def get_name_from_abi_element_identifier(
+    abi_element_identifier: ABIElementIdentifier,
+) -> str:
+    if abi_element_identifier in ["fallback", FallbackFn]:
+        return "fallback"
+    elif abi_element_identifier in ["receive", ReceiveFn]:
+        return "receive"
+    elif is_text(abi_element_identifier):
+        return str(abi_element_identifier).split("(")[0]
+    else:
+        raise Web3TypeError("Unsupported function identifier")
 
 
-def filter_by_argument_count(
-    num_arguments: int, contract_abi: ABI
-) -> List[Union[ABIFunction, ABIEvent]]:
-    return [abi for abi in contract_abi if len(abi["inputs"]) == num_arguments]
+def get_abi_element_signature(
+    abi_element_identifier: ABIElementIdentifier,
+    abi_element_argument_types: Optional[Sequence[str]] = None,
+) -> str:
+    element_name = get_name_from_abi_element_identifier(abi_element_identifier)
+    argument_types = ",".join(abi_element_argument_types or [])
 
+    if element_name in ["fallback", "receive"]:
+        return element_name
 
-def filter_by_argument_name(
-    argument_names: Collection[str], contract_abi: ABI
-) -> List[Union[ABIFunction, ABIEvent]]:
-    return [
-        abi
-        for abi in contract_abi
-        if set(argument_names).intersection(get_abi_input_names(abi))
-        == set(argument_names)
-    ]
+    return f"{element_name}({argument_types})"
 
 
 class AddressEncoder(encoding.AddressEncoder):
@@ -194,7 +203,7 @@ class AddressEncoder(encoding.AddressEncoder):
         if is_ens_name(value):
             return
 
-        super().validate_value(value)
+        super().validate_value(value)  # type: ignore[no-untyped-call]
 
 
 class AcceptsHexStrEncoder(encoding.BaseEncoder):
@@ -209,12 +218,9 @@ class AcceptsHexStrEncoder(encoding.BaseEncoder):
         subencoder: encoding.BaseEncoder,
         **kwargs: Dict[str, Any],
     ) -> None:
-        super().__init__(**kwargs)
+        super().__init__(**kwargs)  # type: ignore[no-untyped-call]
         self.subencoder = subencoder
-
-    @property
-    def is_dynamic(self) -> bool:
-        return self.subencoder.is_dynamic
+        self.is_dynamic = subencoder.is_dynamic
 
     @classmethod
     def from_type_str(
@@ -224,20 +230,19 @@ class AcceptsHexStrEncoder(encoding.BaseEncoder):
         # cast b/c expects BaseCoder but `from_type_string`
         # restricted to BaseEncoder subclasses
         subencoder = cast(
-            encoding.BaseEncoder, subencoder_cls.from_type_str(abi_type, registry)
+            encoding.BaseEncoder, subencoder_cls.from_type_str(abi_type, registry)  # type: ignore[no-untyped-call]  # noqa: E501
         )
         return cls(subencoder)
 
     @classmethod
     def get_subencoder_class(cls) -> Type[encoding.BaseEncoder]:
         if cls.subencoder_cls is None:
-            raise AttributeError(f"No subencoder class is set. {cls.__name__}")
+            raise Web3AttributeError(f"No subencoder class is set. {cls.__name__}")
         return cls.subencoder_cls
 
-    @combomethod
     def validate_value(self, value: Any) -> None:
         normalized_value = self.validate_and_normalize(value)
-        return self.subencoder.validate_value(normalized_value)
+        self.subencoder.validate_value(normalized_value)
 
     def encode(self, value: Any) -> bytes:
         normalized_value = self.validate_and_normalize(value)
@@ -290,36 +295,39 @@ class ExactLengthBytesEncoder(BytesEncoder):
     is_strict = True
 
     def validate(self) -> None:
-        super().validate()
+        super().validate()  # type: ignore[no-untyped-call]
         if self.value_bit_size is None:
-            raise ValueError("`value_bit_size` may not be none")
+            raise Web3ValueError("`value_bit_size` may not be none")
         if self.data_byte_size is None:
-            raise ValueError("`data_byte_size` may not be none")
+            raise Web3ValueError("`data_byte_size` may not be none")
         if self.is_big_endian is None:
-            raise ValueError("`is_big_endian` may not be none")
+            raise Web3ValueError("`is_big_endian` may not be none")
 
         if self.value_bit_size % 8 != 0:
-            raise ValueError(
+            raise Web3ValueError(
                 f"Invalid value bit size: {self.value_bit_size}. "
                 "Must be a multiple of 8"
             )
 
         if self.value_bit_size > self.data_byte_size * 8:
-            raise ValueError("Value byte size exceeds data size")
+            raise Web3ValueError("Value byte size exceeds data size")
 
-    @parse_type_str("bytes")
-    def from_type_str(cls, abi_type: BasicType, registry: ABIRegistry) -> bytes:
+    @parse_type_str("bytes")  # type: ignore[no-untyped-call]
+    def from_type_str(
+        cls, abi_type: BasicType, registry: ABIRegistry
+    ) -> "ExactLengthBytesEncoder":
         subencoder_cls = cls.get_subencoder_class()
-        # cast b/c expects BaseCoder but `from_type_string`
-        # restricted to BaseEncoder subclasses
-        subencoder = cast(
-            encoding.BaseEncoder,
-            subencoder_cls.from_type_str(abi_type.to_type_str(), registry),
-        )
-        return cls(
-            subencoder,
-            value_bit_size=abi_type.sub * 8,
-            data_byte_size=abi_type.sub,
+        subencoder = subencoder_cls.from_type_str(abi_type.to_type_str(), registry)  # type: ignore[no-untyped-call]  # noqa: E501
+        return cast(
+            ExactLengthBytesEncoder,
+            # type ignored b/c mypy thinks the __call__ is from BaseEncoder, but it's
+            # from ExactLengthBytesEncoder, which does have value_bit_size and
+            # data_byte_size attributes
+            cls(  # type: ignore[call-arg]
+                subencoder,
+                value_bit_size=abi_type.sub * 8,
+                data_byte_size=abi_type.sub,
+            ),
         )
 
 
@@ -345,110 +353,7 @@ class TextStringEncoder(encoding.TextStringEncoder):
                     msg="not decodable as unicode string",
                 )
 
-        super().validate_value(value)
-
-
-def filter_by_encodability(
-    abi_codec: codec.ABIEncoder,
-    args: Sequence[Any],
-    kwargs: Dict[str, Any],
-    contract_abi: ABI,
-) -> List[ABIFunction]:
-    return [
-        cast(ABIFunction, function_abi)
-        for function_abi in contract_abi
-        if check_if_arguments_can_be_encoded(
-            cast(ABIFunction, function_abi), abi_codec, args, kwargs
-        )
-    ]
-
-
-def check_if_arguments_can_be_encoded(
-    function_abi: ABIFunction,
-    abi_codec: codec.ABIEncoder,
-    args: Sequence[Any],
-    kwargs: Dict[str, Any],
-) -> bool:
-    try:
-        arguments = merge_args_and_kwargs(function_abi, args, kwargs)
-    except TypeError:
-        return False
-
-    if len(function_abi.get("inputs", [])) != len(arguments):
-        return False
-
-    try:
-        types, aligned_args = get_aligned_abi_inputs(function_abi, arguments)
-    except TypeError:
-        return False
-
-    return all(
-        abi_codec.is_encodable(_type, arg) for _type, arg in zip(types, aligned_args)
-    )
-
-
-def merge_args_and_kwargs(
-    function_abi: ABIFunction, args: Sequence[Any], kwargs: Dict[str, Any]
-) -> Tuple[Any, ...]:
-    """
-    Takes a list of positional args (``args``) and a dict of keyword args
-    (``kwargs``) defining values to be passed to a call to the contract function
-    described by ``function_abi``.  Checks to ensure that the correct number of
-    args were given, no duplicate args were given, and no unknown args were
-    given.  Returns a list of argument values aligned to the order of inputs
-    defined in ``function_abi``.
-    """
-    # Ensure the function is being applied to the correct number of args
-    if len(args) + len(kwargs) != len(function_abi.get("inputs", [])):
-        raise TypeError(
-            f"Incorrect argument count. Expected '{len(function_abi['inputs'])}'"
-            f". Got '{len(args) + len(kwargs)}'"
-        )
-
-    # If no keyword args were given, we don't need to align them
-    if not kwargs:
-        return cast(Tuple[Any, ...], args)
-
-    kwarg_names = set(kwargs.keys())
-    sorted_arg_names = tuple(arg_abi["name"] for arg_abi in function_abi["inputs"])
-    args_as_kwargs = dict(zip(sorted_arg_names, args))
-
-    # Check for duplicate args
-    duplicate_args = kwarg_names.intersection(args_as_kwargs.keys())
-    if duplicate_args:
-        raise TypeError(
-            f"{function_abi.get('name')}() got multiple values for argument(s) "
-            f"'{', '.join(duplicate_args)}'"
-        )
-
-    # Check for unknown args
-    unknown_args = kwarg_names.difference(sorted_arg_names)
-    if unknown_args:
-        if function_abi.get("name"):
-            raise TypeError(
-                f"{function_abi.get('name')}() got unexpected keyword argument(s)"
-                f" '{', '.join(unknown_args)}'"
-            )
-        raise TypeError(
-            f"Type: '{function_abi.get('type')}' got unexpected keyword argument(s)"
-            f" '{', '.join(unknown_args)}'"
-        )
-
-    # Sort args according to their position in the ABI and unzip them from their
-    # names
-    sorted_args = tuple(
-        zip(
-            *sorted(
-                itertools.chain(kwargs.items(), args_as_kwargs.items()),
-                key=lambda kv: sorted_arg_names.index(kv[0]),
-            )
-        )
-    )
-
-    if sorted_args:
-        return sorted_args[1]
-    else:
-        return tuple()
+        super().validate_value(value)  # type: ignore[no-untyped-call]
 
 
 TUPLE_TYPE_STR_RE = re.compile(r"^(tuple)((\[([1-9]\d*\b)?])*)??$")
@@ -470,7 +375,9 @@ def get_tuple_type_str_parts(s: str) -> Optional[Tuple[str, Optional[str]]]:
     return None
 
 
-def _align_abi_input(arg_abi: ABIFunctionParams, arg: Any) -> Tuple[Any, ...]:
+def _align_abi_input(
+    arg_abi: Union[ABIComponent, ABIComponentIndexed], arg: Any
+) -> Tuple[Any, ...]:
     """
     Aligns the values of any mapping at any level of nesting in ``arg``
     according to the layout of the corresponding abi spec.
@@ -494,7 +401,7 @@ def _align_abi_input(arg_abi: ABIFunctionParams, arg: Any) -> Tuple[Any, ...]:
         new_abi = copy.copy(arg_abi)
         new_abi["type"] = tuple_prefix + "[]" * (num_dims - 1)
 
-        sub_abis = itertools.repeat(new_abi)  # type: ignore
+        sub_abis = [cast(ABIComponent, abi) for abi in itertools.repeat(new_abi)]
 
     if isinstance(arg, abc.Mapping):
         # Arg is mapping.  Align values according to abi order.
@@ -503,7 +410,7 @@ def _align_abi_input(arg_abi: ABIFunctionParams, arg: Any) -> Tuple[Any, ...]:
         aligned_arg = arg
 
     if not is_list_like(aligned_arg):
-        raise TypeError(
+        raise Web3TypeError(
             f'Expected non-string sequence for "{arg_abi.get("type")}" '
             f"component type: got {aligned_arg}"
         )
@@ -517,38 +424,21 @@ def _align_abi_input(arg_abi: ABIFunctionParams, arg: Any) -> Tuple[Any, ...]:
     )
 
 
-def get_aligned_abi_inputs(
-    abi: ABIFunction, args: Union[Tuple[Any, ...], Mapping[Any, Any]]
-) -> Tuple[Tuple[Any, ...], Tuple[Any, ...]]:
-    """
-    Takes a function ABI (``abi``) and a sequence or mapping of args (``args``).
-    Returns a list of type strings for the function's inputs and a list of
-    arguments which have been aligned to the layout of those types.  The args
-    contained in ``args`` may contain nested mappings or sequences corresponding
-    to tuple-encoded values in ``abi``.
+def find_constructor_abi_element_by_type(contract_abi: ABI) -> ABIConstructor:
     """
-    input_abis = abi.get("inputs", [])
-
-    if isinstance(args, abc.Mapping):
-        # `args` is mapping.  Align values according to abi order.
-        args = tuple(args[abi["name"]] for abi in input_abis)
-
-    return (
-        # typed dict cannot be used w/ a normal Dict
-        # https://github.com/python/mypy/issues/4976
-        tuple(collapse_if_tuple(abi) for abi in input_abis),  # type: ignore
-        type(args)(_align_abi_input(abi, arg) for abi, arg in zip(input_abis, args)),
-    )
+    Find the constructor ABI element in the contract ABI.
 
-
-def get_constructor_abi(contract_abi: ABI) -> ABIFunction:
+    This function is often used in place of `web3.utils.abi.get_abi_element` to find
+    a constructor without considering it's argument types. This is used prior to
+    encoding the abi, since the argument types are not known at that time.
+    """
     candidates = [abi for abi in contract_abi if abi["type"] == "constructor"]
     if len(candidates) == 1:
         return candidates[0]
     elif len(candidates) == 0:
         return None
     elif len(candidates) > 1:
-        raise ValueError("Found multiple constructors.")
+        raise Web3ValueError("Found multiple constructors.")
     return None
 
 
@@ -570,7 +460,7 @@ STATIC_TYPES = list(
 )
 
 BASE_TYPE_REGEX = "|".join(
-    (_type + "(?![a-z0-9])" for _type in itertools.chain(STATIC_TYPES, DYNAMIC_TYPES))
+    _type + "(?![a-z0-9])" for _type in itertools.chain(STATIC_TYPES, DYNAMIC_TYPES)
 )
 
 SUB_TYPE_REGEX = r"\[" "[0-9]*" r"\]"
@@ -636,14 +526,14 @@ END_BRACKETS_OF_ARRAY_TYPE_REGEX = r"\[[^]]*\]$"
 
 def sub_type_of_array_type(abi_type: TypeStr) -> str:
     if not is_array_type(abi_type):
-        raise ValueError(f"Cannot parse subtype of nonarray abi-type: {abi_type}")
+        raise Web3ValueError(f"Cannot parse subtype of nonarray abi-type: {abi_type}")
 
-    return re.sub(END_BRACKETS_OF_ARRAY_TYPE_REGEX, "", abi_type, 1)
+    return re.sub(END_BRACKETS_OF_ARRAY_TYPE_REGEX, "", abi_type, count=1)
 
 
 def length_of_array_type(abi_type: TypeStr) -> int:
     if not is_array_type(abi_type):
-        raise ValueError(f"Cannot parse length of nonarray abi-type: {abi_type}")
+        raise Web3ValueError(f"Cannot parse length of nonarray abi-type: {abi_type}")
 
     inner_brackets = (
         re.search(END_BRACKETS_OF_ARRAY_TYPE_REGEX, abi_type).group(0).strip("[]")
@@ -675,8 +565,8 @@ def is_probably_enum(abi_type: TypeStr) -> bool:
 
 @to_tuple
 def normalize_event_input_types(
-    abi_args: Collection[Union[ABIFunction, ABIEvent]]
-) -> Iterable[Union[ABIFunction, ABIEvent, Dict[TypeStr, Any]]]:
+    abi_args: Collection[ABIEvent],
+) -> Iterable[Union[ABIEvent, Dict[TypeStr, Any]]]:
     for arg in abi_args:
         if is_recognized_type(arg["type"]):
             yield arg
@@ -686,17 +576,6 @@ def normalize_event_input_types(
             yield arg
 
 
-def abi_to_signature(abi: Union[ABIFunction, ABIEvent]) -> str:
-    function_signature = "{fn_name}({fn_input_types})".format(
-        fn_name=abi["name"],
-        fn_input_types=",".join(
-            collapse_if_tuple(dict(arg))
-            for arg in normalize_event_input_types(abi.get("inputs", []))
-        ),
-    )
-    return function_signature
-
-
 ########################################################
 #
 #  Conditionally modifying data, tagged with ABI Types
@@ -711,8 +590,8 @@ def map_abi_data(
     data: Sequence[Any],
 ) -> Any:
     """
-    This function will apply normalizers to your data, in the
-    context of the relevant types. Each normalizer is in the format:
+    Applies normalizers to your data, in the context of the relevant types.
+    Each normalizer is in the format:
 
     def normalizer(datatype, data):
         # Conditionally modify data
@@ -778,7 +657,7 @@ def data_tree_map(
 
 class ABITypedData(namedtuple("ABITypedData", "abi_type, data")):
     """
-    This class marks data as having a certain ABI-type.
+    Marks data as having a certain ABI-type.
 
     >>> a1 = ABITypedData(['address', addr1])
     >>> a2 = ABITypedData(['address', addr2])
@@ -847,7 +726,7 @@ def strip_abi_type(elements: Any) -> Any:
 def build_non_strict_registry() -> ABIRegistry:
     # We make a copy here just to make sure that eth-abi's default registry is not
     # affected by our custom encoder subclasses
-    registry = default_registry.copy()
+    registry = default_registry.copy()  # type: ignore[no-untyped-call]
 
     registry.unregister("address")
     registry.unregister("bytes<M>")
@@ -855,25 +734,25 @@ def build_non_strict_registry() -> ABIRegistry:
     registry.unregister("string")
 
     registry.register(
-        BaseEquals("address"),
+        BaseEquals("address"),  # type: ignore[no-untyped-call]
         AddressEncoder,
         decoding.AddressDecoder,
         label="address",
     )
     registry.register(
-        BaseEquals("bytes", with_sub=True),
+        BaseEquals("bytes", with_sub=True),  # type: ignore[no-untyped-call]
         BytesEncoder,
         decoding.BytesDecoder,
         label="bytes<M>",
     )
     registry.register(
-        BaseEquals("bytes", with_sub=False),
+        BaseEquals("bytes", with_sub=False),  # type: ignore[no-untyped-call]
         ByteStringEncoder,
         decoding.ByteStringDecoder,
         label="bytes",
     )
     registry.register(
-        BaseEquals("string"),
+        BaseEquals("string"),  # type: ignore[no-untyped-call]
         TextStringEncoder,
         decoding.StringDecoder,
         label="string",
@@ -882,7 +761,7 @@ def build_non_strict_registry() -> ABIRegistry:
 
 
 def build_strict_registry() -> ABIRegistry:
-    registry = default_registry.copy()
+    registry = default_registry.copy()  # type: ignore[no-untyped-call]
 
     registry.unregister("address")
     registry.unregister("bytes<M>")
@@ -890,25 +769,25 @@ def build_strict_registry() -> ABIRegistry:
     registry.unregister("string")
 
     registry.register(
-        BaseEquals("address"),
+        BaseEquals("address"),  # type: ignore[no-untyped-call]
         AddressEncoder,
         decoding.AddressDecoder,
         label="address",
     )
     registry.register(
-        BaseEquals("bytes", with_sub=True),
+        BaseEquals("bytes", with_sub=True),  # type: ignore[no-untyped-call]
         ExactLengthBytesEncoder,
         decoding.BytesDecoder,
         label="bytes<M>",
     )
     registry.register(
-        BaseEquals("bytes", with_sub=False),
+        BaseEquals("bytes", with_sub=False),  # type: ignore[no-untyped-call]
         StrictByteStringEncoder,
         decoding.ByteStringDecoder,
         label="bytes",
     )
     registry.register(
-        BaseEquals("string"),
+        BaseEquals("string"),  # type: ignore[no-untyped-call]
         encoding.TextStringEncoder,
         decoding.StringDecoder,
         label="string",
@@ -917,7 +796,11 @@ def build_strict_registry() -> ABIRegistry:
 
 
 def named_tree(
-    abi: Iterable[Union[ABIFunctionParams, ABIFunction, ABIEvent, Dict[TypeStr, Any]]],
+    abi: Iterable[
+        Union[
+            ABIComponent, ABIComponentIndexed, ABIFunction, ABIEvent, Dict[TypeStr, Any]
+        ]
+    ],
     data: Iterable[Tuple[Any, ...]],
 ) -> Dict[str, Any]:
     """
@@ -930,10 +813,12 @@ def named_tree(
 
 
 def _named_subtree(
-    abi: Union[ABIFunctionParams, ABIFunction, ABIEvent, Dict[TypeStr, Any]],
+    abi: Union[
+        ABIComponent, ABIComponentIndexed, ABIFunction, ABIEvent, Dict[TypeStr, Any]
+    ],
     data: Tuple[Any, ...],
 ) -> Union[Dict[str, Any], Tuple[Any, ...], List[Any]]:
-    abi_type = parse(collapse_if_tuple(dict(abi)))
+    abi_type = parse(collapse_if_tuple(cast(Dict[str, Any], abi)))
 
     if abi_type.is_array:
         item_type = abi_type.item_type.to_type_str()
@@ -942,7 +827,11 @@ def _named_subtree(
         return items
 
     elif isinstance(abi_type, TupleType):
-        abi = cast(ABIFunctionParams, abi)
+        if abi.get("indexed"):
+            abi = cast(ABIComponentIndexed, abi)
+        else:
+            abi = cast(ABIComponent, abi)
+
         names = [item["name"] for item in abi["components"]]
         items = [_named_subtree(*item) for item in zip(abi["components"], data)]
 
@@ -1035,7 +924,6 @@ async def async_map_if_collection(
     Apply an awaitable method to each element of a collection or value of a dictionary.
     If the value is not a collection, return it unmodified.
     """
-
     datatype = type(value)
     if isinstance(value, Mapping):
         return datatype({key: await func(val) for key, val in value.values()})