web3 7.0.0b8__py3-none-any.whl → 7.0.0b9__py3-none-any.whl

web3/_utils/contracts.py

@@ -4,10 +4,10 @@ from typing import (
     Any,
     Callable,
     Dict,
+    List,
     Optional,
     Sequence,
     Tuple,
-    Type,
     Union,
     cast,
 )
@@ -19,6 +19,14 @@ from eth_abi.registry import (
     registry as default_registry,
 )
 from eth_typing import (
+    ABI,
+    ABICallable,
+    ABIConstructor,
+    ABIElement,
+    ABIEvent,
+    ABIFallback,
+    ABIFunction,
+    ABIReceive,
     ChecksumAddress,
     HexStr,
     TypeStr,
@@ -26,11 +34,9 @@ from eth_typing import (
 from eth_utils import (
     add_0x_prefix,
     encode_hex,
-    function_abi_to_4byte_selector,
-    is_binary_address,
-    is_checksum_address,
-    is_list_like,
-    is_text,
+    filter_abi_by_name,
+    filter_abi_by_type,
+    get_abi_input_types,
 )
 from eth_utils.toolz import (
     pipe,
@@ -40,31 +46,20 @@ from hexbytes import (
 )
 
 from web3._utils.abi import (
-    abi_to_signature,
-    check_if_arguments_can_be_encoded,
-    filter_by_argument_count,
     filter_by_argument_name,
-    filter_by_encodability,
-    filter_by_name,
-    filter_by_type,
-    get_abi_input_types,
-    get_aligned_abi_inputs,
-    get_fallback_func_abi,
-    get_receive_func_abi,
     map_abi_data,
-    merge_args_and_kwargs,
     named_tree,
 )
+from web3._utils.abi_element_identifiers import (
+    FallbackFn,
+    ReceiveFn,
+)
 from web3._utils.blocks import (
     is_hex_encoded_block_hash,
 )
 from web3._utils.encoding import (
     to_hex,
 )
-from web3._utils.function_identifiers import (
-    FallbackFn,
-    ReceiveFn,
-)
 from web3._utils.method_formatters import (
     to_integer_if_hex,
 )
@@ -81,13 +76,16 @@ from web3.exceptions import (
     Web3ValueError,
 )
 from web3.types import (
-    ABI,
-    ABIEvent,
-    ABIFunction,
+    ABIElementIdentifier,
     BlockIdentifier,
     BlockNumber,
     TxParams,
 )
+from web3.utils.abi import (
+    check_if_arguments_can_be_encoded,
+    get_abi_element,
+    get_abi_element_info,
+)
 
 if TYPE_CHECKING:
     from web3 import (  # noqa: F401
@@ -96,44 +94,22 @@ if TYPE_CHECKING:
     )
 
 
-def extract_argument_types(*args: Sequence[Any]) -> str:
-    """
-    Takes a list of arguments and returns a string representation of the argument types,
-    appropriately collapsing `tuple` types into the respective nested types.
-    """
-    collapsed_args = []
-
-    for arg in args:
-        if is_list_like(arg):
-            collapsed_nested = []
-            for nested in arg:
-                if is_list_like(nested):
-                    collapsed_nested.append(f"({extract_argument_types(nested)})")
-                else:
-                    collapsed_nested.append(_get_argument_readable_type(nested))
-            collapsed_args.append(",".join(collapsed_nested))
-        else:
-            collapsed_args.append(_get_argument_readable_type(arg))
-
-    return ",".join(collapsed_args)
-
-
 def find_matching_event_abi(
     abi: ABI,
     event_name: Optional[str] = None,
     argument_names: Optional[Sequence[str]] = None,
 ) -> ABIEvent:
-    filters = [
-        functools.partial(filter_by_type, "event"),
+    filters: List[functools.partial[Sequence[ABIElement]]] = [
+        functools.partial(filter_abi_by_type, "event"),
     ]
 
     if event_name is not None:
-        filters.append(functools.partial(filter_by_name, event_name))
+        filters.append(functools.partial(filter_abi_by_name, event_name))
 
     if argument_names is not None:
         filters.append(functools.partial(filter_by_argument_name, argument_names))
 
-    event_abi_candidates = pipe(abi, *filters)
+    event_abi_candidates: Sequence[ABIEvent] = pipe(abi, *filters)
 
     if len(event_abi_candidates) == 1:
         return event_abi_candidates[0]
@@ -143,82 +119,24 @@ def find_matching_event_abi(
         raise Web3ValueError("Multiple events found")
 
 
-def find_matching_fn_abi(
-    abi: ABI,
-    abi_codec: ABICodec,
-    fn_identifier: Optional[Union[str, Type[FallbackFn], Type[ReceiveFn]]] = None,
-    args: Optional[Sequence[Any]] = None,
-    kwargs: Optional[Any] = None,
-) -> ABIFunction:
-    args = args or tuple()
-    kwargs = kwargs or dict()
-    num_arguments = len(args) + len(kwargs)
-
-    if fn_identifier is FallbackFn:
-        return get_fallback_func_abi(abi)
-
-    if fn_identifier is ReceiveFn:
-        return get_receive_func_abi(abi)
-
-    if not is_text(fn_identifier):
-        raise Web3TypeError("Unsupported function identifier")
-
-    name_filter = functools.partial(filter_by_name, fn_identifier)
-    arg_count_filter = functools.partial(filter_by_argument_count, num_arguments)
-    encoding_filter = functools.partial(filter_by_encodability, abi_codec, args, kwargs)
-
-    function_candidates = pipe(abi, name_filter, arg_count_filter, encoding_filter)
-
-    if len(function_candidates) == 1:
-        return function_candidates[0]
-    else:
-        matching_identifiers = name_filter(abi)
-        matching_function_signatures = [
-            abi_to_signature(func) for func in matching_identifiers
-        ]
-
-        arg_count_matches = len(arg_count_filter(matching_identifiers))
-        encoding_matches = len(encoding_filter(matching_identifiers))
-
-        if arg_count_matches == 0:
-            diagnosis = (
-                "\nFunction invocation failed due to improper number of arguments."
-            )
-        elif encoding_matches == 0:
-            diagnosis = (
-                "\nFunction invocation failed due to no matching argument types."
-            )
-        elif encoding_matches > 1:
-            diagnosis = (
-                "\nAmbiguous argument encoding. "
-                "Provided arguments can be encoded to multiple functions "
-                "matching this call."
-            )
-
-        collapsed_args = extract_argument_types(args)
-        collapsed_kwargs = dict(
-            {(k, extract_argument_types([v])) for k, v in kwargs.items()}
-        )
-        message = (
-            f"\nCould not identify the intended function with name `{fn_identifier}`, "
-            f"positional arguments with type(s) `{collapsed_args}` and "
-            f"keyword arguments with type(s) `{collapsed_kwargs}`."
-            f"\nFound {len(matching_identifiers)} function(s) with "
-            f"the name `{fn_identifier}`: {matching_function_signatures}{diagnosis}"
-        )
-
-        raise Web3ValidationError(message)
-
-
 def encode_abi(
     w3: Union["AsyncWeb3", "Web3"],
-    abi: ABIFunction,
+    abi: ABIElement,
     arguments: Sequence[Any],
     data: Optional[HexStr] = None,
 ) -> HexStr:
-    argument_types = get_abi_input_types(abi)
-
-    if not check_if_arguments_can_be_encoded(abi, w3.codec, arguments, {}):
+    argument_types = []
+    try:
+        argument_types = get_abi_input_types(abi)
+    except ValueError:
+        # Use the default argument_types if the abi doesn't have inputs
+        pass
+
+    if not check_if_arguments_can_be_encoded(
+        abi,
+        *arguments,
+        abi_codec=w3.codec,
+    ):
         raise Web3TypeError(
             "One or more arguments could not be encoded to the necessary "
             f"ABI type. Expected types are: {', '.join(argument_types)}"
@@ -250,25 +168,33 @@ def encode_abi(
 def prepare_transaction(
     address: ChecksumAddress,
     w3: Union["AsyncWeb3", "Web3"],
-    fn_identifier: Union[str, Type[FallbackFn], Type[ReceiveFn]],
+    abi_element_identifier: ABIElementIdentifier,
     contract_abi: Optional[ABI] = None,
-    fn_abi: Optional[ABIFunction] = None,
+    abi_callable: Optional[ABICallable] = None,
     transaction: Optional[TxParams] = None,
     fn_args: Optional[Sequence[Any]] = None,
     fn_kwargs: Optional[Any] = None,
 ) -> TxParams:
     """
-    :parameter `is_function_abi` is used to distinguish  function abi from contract abi
     Returns a dictionary of the transaction that could be used to call this
     TODO: make this a public API
     TODO: add new prepare_deploy_transaction API
     """
-    if fn_abi is None:
-        fn_abi = find_matching_fn_abi(
-            contract_abi, w3.codec, fn_identifier, fn_args, fn_kwargs
+    fn_args = fn_args or []
+    fn_kwargs = fn_kwargs or {}
+    if abi_callable is None:
+        abi_callable = cast(
+            ABICallable,
+            get_abi_element(
+                contract_abi,
+                abi_element_identifier,
+                *fn_args,
+                abi_codec=w3.codec,
+                **fn_kwargs,
+            ),
         )
 
-    validate_payable(transaction, fn_abi)
+    validate_payable(transaction, abi_callable)
 
     if transaction is None:
         prepared_transaction: TxParams = {}
@@ -283,9 +209,9 @@ def prepare_transaction(
 
     prepared_transaction["data"] = encode_transaction_data(
         w3,
-        fn_identifier,
+        abi_element_identifier,
         contract_abi,
-        fn_abi,
+        abi_callable,
         fn_args,
         fn_kwargs,
     )
@@ -294,34 +220,36 @@ def prepare_transaction(
 
 def encode_transaction_data(
     w3: Union["AsyncWeb3", "Web3"],
-    fn_identifier: Union[str, Type[FallbackFn], Type[ReceiveFn]],
+    abi_element_identifier: ABIElementIdentifier,
     contract_abi: Optional[ABI] = None,
-    fn_abi: Optional[ABIFunction] = None,
+    abi_callable: Optional[ABICallable] = None,
     args: Optional[Sequence[Any]] = None,
     kwargs: Optional[Any] = None,
 ) -> HexStr:
-    if fn_identifier is FallbackFn:
-        fn_abi, fn_selector, fn_arguments = get_fallback_function_info(
-            contract_abi, fn_abi
+    info_abi: ABIElement
+    if abi_element_identifier is FallbackFn:
+        info_abi, info_selector, info_arguments = get_fallback_function_info(
+            contract_abi, cast(ABIFallback, abi_callable)
         )
-    elif fn_identifier is ReceiveFn:
-        fn_abi, fn_selector, fn_arguments = get_receive_function_info(
-            contract_abi, fn_abi
+    elif abi_element_identifier is ReceiveFn:
+        info_abi, info_selector, info_arguments = get_receive_function_info(
+            contract_abi, cast(ABIReceive, abi_callable)
         )
-    elif is_text(fn_identifier):
-        fn_abi, fn_selector, fn_arguments = get_function_info(
-            # type ignored b/c fn_id here is always str b/c FallbackFn is handled above
-            fn_identifier,  # type: ignore
-            w3.codec,
+    elif isinstance(abi_element_identifier, str):
+        fn_info = get_abi_element_info(
             contract_abi,
-            fn_abi,
-            args,
-            kwargs,
+            abi_element_identifier,
+            *args,
+            abi_codec=w3.codec,
+            **kwargs,
         )
+        info_abi = fn_info["abi"]
+        info_selector = fn_info["selector"]
+        info_arguments = fn_info["arguments"]
     else:
         raise Web3TypeError("Unsupported function identifier")
 
-    return add_0x_prefix(encode_abi(w3, fn_abi, fn_arguments, fn_selector))
+    return add_0x_prefix(encode_abi(w3, info_abi, info_arguments, info_selector))
 
 
 def decode_transaction_data(
@@ -329,85 +257,67 @@ def decode_transaction_data(
     data: HexStr,
     normalizers: Sequence[Callable[[TypeStr, Any], Tuple[TypeStr, Any]]] = None,
 ) -> Dict[str, Any]:
-    data = HexBytes(data)
+    data_bytes = HexBytes(data)
     types = get_abi_input_types(fn_abi)
     abi_codec = ABICodec(default_registry)
-    decoded = abi_codec.decode(types, HexBytes(data[4:]))
+    decoded = abi_codec.decode(types, data_bytes[4:])
     if normalizers:
         decoded = map_abi_data(normalizers, types, decoded)
     return named_tree(fn_abi["inputs"], decoded)
 
 
-def get_fallback_function_info(
-    contract_abi: Optional[ABI] = None, fn_abi: Optional[ABIFunction] = None
-) -> Tuple[ABIFunction, HexStr, Tuple[Any, ...]]:
-    if fn_abi is None:
-        fn_abi = get_fallback_func_abi(contract_abi)
+def get_constructor_function_info(
+    contract_abi: Optional[ABI] = None, constructor_abi: Optional[ABIConstructor] = None
+) -> Tuple[ABIConstructor, HexStr, Tuple[Any, ...]]:
+    if constructor_abi is None:
+        constructor_abi = cast(
+            ABIConstructor, get_abi_element(contract_abi, "constructor")
+        )
     fn_selector = encode_hex(b"")
     fn_arguments: Tuple[Any, ...] = tuple()
-    return fn_abi, fn_selector, fn_arguments
+    return constructor_abi, fn_selector, fn_arguments
 
 
-def get_receive_function_info(
-    contract_abi: Optional[ABI] = None, fn_abi: Optional[ABIFunction] = None
-) -> Tuple[ABIFunction, HexStr, Tuple[Any, ...]]:
-    if fn_abi is None:
-        fn_abi = get_receive_func_abi(contract_abi)
+def get_fallback_function_info(
+    contract_abi: Optional[ABI] = None, fallback_abi: Optional[ABIFallback] = None
+) -> Tuple[ABIFallback, HexStr, Tuple[Any, ...]]:
+    if fallback_abi is None:
+        fallback_abi = cast(ABIFallback, get_abi_element(contract_abi, "fallback"))
     fn_selector = encode_hex(b"")
     fn_arguments: Tuple[Any, ...] = tuple()
-    return fn_abi, fn_selector, fn_arguments
+    return fallback_abi, fn_selector, fn_arguments
 
 
-def get_function_info(
-    fn_name: str,
-    abi_codec: ABICodec,
-    contract_abi: Optional[ABI] = None,
-    fn_abi: Optional[ABIFunction] = None,
-    args: Optional[Sequence[Any]] = None,
-    kwargs: Optional[Any] = None,
-) -> Tuple[ABIFunction, HexStr, Tuple[Any, ...]]:
-    if args is None:
-        args = tuple()
-    if kwargs is None:
-        kwargs = {}
-
-    if fn_abi is None:
-        fn_abi = find_matching_fn_abi(contract_abi, abi_codec, fn_name, args, kwargs)
-
-    fn_selector = encode_hex(function_abi_to_4byte_selector(fn_abi))
-
-    fn_arguments = merge_args_and_kwargs(fn_abi, args, kwargs)
-
-    _, aligned_fn_arguments = get_aligned_abi_inputs(fn_abi, fn_arguments)
-
-    return fn_abi, fn_selector, aligned_fn_arguments
+def get_receive_function_info(
+    contract_abi: Optional[ABI] = None, receive_abi: Optional[ABIReceive] = None
+) -> Tuple[ABIReceive, HexStr, Tuple[Any, ...]]:
+    if receive_abi is None:
+        receive_abi = cast(ABIReceive, get_abi_element(contract_abi, "receive"))
+    fn_selector = encode_hex(b"")
+    fn_arguments: Tuple[Any, ...] = tuple()
+    return receive_abi, fn_selector, fn_arguments
 
 
-def validate_payable(transaction: TxParams, abi: ABIFunction) -> None:
+def validate_payable(transaction: TxParams, abi_callable: ABICallable) -> None:
     """
     Raise Web3ValidationError if non-zero ether
     is sent to a non-payable function.
     """
-    if "value" in transaction:
-        if to_integer_if_hex(transaction["value"]) != 0:
-            if (
-                "payable" in abi
-                and not abi["payable"]
-                or "stateMutability" in abi
-                and abi["stateMutability"] == "nonpayable"
-            ):
-                raise Web3ValidationError(
-                    "Sending non-zero ether to a contract function "
-                    "with payable=False. Please ensure that "
-                    "transaction's value is 0."
-                )
-
-
-def _get_argument_readable_type(arg: Any) -> str:
-    if is_checksum_address(arg) or is_binary_address(arg):
-        return "address"
-
-    return arg.__class__.__name__
+    if (
+        "value" in transaction
+        and to_integer_if_hex(transaction["value"]) != 0
+        and (
+            "payable" in abi_callable
+            and not abi_callable["payable"]
+            or "stateMutability" in abi_callable
+            and abi_callable["stateMutability"] == "nonpayable"
+        )
+    ):
+        raise Web3ValidationError(
+            "Sending non-zero ether to a contract function "
+            "with payable=False. Please ensure that "
+            "transaction's value is 0."
+        )
 
 
 def parse_block_identifier(
@@ -468,3 +378,4 @@ async def async_parse_block_identifier_int(
         if block_num < 0:
             raise BlockNumberOutOfRange
     return BlockNumber(block_num)
+    return BlockNumber(block_num)

web3/_utils/encoding.py

@@ -255,12 +255,11 @@ def to_4byte_hex(hex_or_str_or_bytes: Union[HexStr, str, bytes, int]) -> HexStr:
     return pad_hex(hex_str, size_of_4bytes)
 
 
-# type ignored because subclassing BaseArrayEncoder which has type Any
-class DynamicArrayPackedEncoder(BaseArrayEncoder):  # type: ignore[misc]
+class DynamicArrayPackedEncoder(BaseArrayEncoder):
     is_dynamic = True
 
     def encode(self, value: Sequence[Any]) -> bytes:
-        encoded_elements = self.encode_elements(value)
+        encoded_elements = self.encode_elements(value)  # type: ignore[no-untyped-call]
         encoded_value = encoded_elements
 
         return encoded_value
@@ -279,10 +278,10 @@ def encode_single_packed(_type: TypeStr, value: Any) -> bytes:
     )
 
     abi_type = abi_type_parser.parse(_type)
-    if has_arrlist(_type):
+    if has_arrlist(_type):  # type: ignore[no-untyped-call]
         item_encoder = registry.get_encoder(abi_type.item_type.to_type_str())
         if abi_type.arrlist[-1] != 1:
-            return DynamicArrayPackedEncoder(item_encoder=item_encoder).encode(value)
+            return DynamicArrayPackedEncoder(item_encoder=item_encoder).encode(value)  # type: ignore[no-untyped-call]  # noqa: E501
         else:
             raise NotImplementedError(
                 "Fixed arrays are not implemented in this packed encoder prototype"

web3/_utils/events.py

@@ -27,6 +27,9 @@ from eth_abi.codec import (
     ABICodec,
 )
 from eth_typing import (
+    ABIComponent,
+    ABIComponentIndexed,
+    ABIEvent,
     ChecksumAddress,
     HexStr,
     Primitives,
@@ -34,7 +37,6 @@ from eth_typing import (
 )
 from eth_utils import (
     encode_hex,
-    event_abi_to_log_topic,
     is_list_like,
     keccak,
     to_bytes,
@@ -42,6 +44,11 @@ from eth_utils import (
     to_hex,
     to_tuple,
 )
+from eth_utils.abi import (
+    collapse_if_tuple,
+    event_abi_to_log_topic,
+    get_abi_input_names,
+)
 from eth_utils.curried import (
     apply_formatter_if,
 )
@@ -57,7 +64,6 @@ import web3
 from web3._utils.abi import (
     exclude_indexed_event_inputs,
     get_indexed_event_inputs,
-    get_normalized_abi_arg_type,
     map_abi_data,
     named_tree,
     normalize_event_input_types,
@@ -75,19 +81,16 @@ from web3.datastructures import (
 from web3.exceptions import (
     InvalidEventABI,
     LogTopicError,
-    MismatchedABI,
     Web3ValueError,
 )
 from web3.types import (
-    ABIEvent,
-    ABIEventParams,
     BlockIdentifier,
     EventData,
     FilterParams,
     LogReceipt,
 )
-from web3.utils import (
-    get_abi_input_names,
+from web3.utils.abi import (
+    get_event_log_topics,
 )
 
 if TYPE_CHECKING:
@@ -110,11 +113,11 @@ def _log_entry_data_to_bytes(
 def construct_event_topic_set(
     event_abi: ABIEvent,
     abi_codec: ABICodec,
-    arguments: Optional[Union[Sequence[Any], Dict[str, Any]]] = None,
+    arguments: Optional[Union[List[Any], Tuple[Any], Dict[str, Any]]] = None,
 ) -> List[HexStr]:
     if arguments is None:
         arguments = {}
-    if isinstance(arguments, (list, tuple)):
+    elif isinstance(arguments, (list, tuple)):
         if len(arguments) != len(event_abi["inputs"]):
             raise Web3ValueError(
                 "When passing an argument list, the number of arguments must "
@@ -124,11 +127,9 @@ def construct_event_topic_set(
             arg["name"]: [arg_value]
             for arg, arg_value in zip(event_abi["inputs"], arguments)
         }
-
     normalized_args = {
         key: value if is_list_like(value) else [value]
-        # type ignored b/c arguments is always a dict at this point
-        for key, value in arguments.items()  # type: ignore
+        for key, value in arguments.items()
     }
 
     event_topic = encode_hex(event_abi_to_log_topic(event_abi))
@@ -206,7 +207,7 @@ def is_dynamic_sized_type(type_str: TypeStr) -> bool:
 
 @to_tuple
 def get_event_abi_types_for_decoding(
-    event_inputs: Sequence[ABIEventParams],
+    event_inputs: Sequence[Union[ABIComponent, ABIComponentIndexed]],
 ) -> Iterable[TypeStr]:
     """
     Event logs use the `keccak(value)` for indexed inputs of type `bytes` or
@@ -214,10 +215,10 @@ def get_event_abi_types_for_decoding(
     decode the log entries using the correct types.
     """
     for input_abi in event_inputs:
-        if input_abi["indexed"] and is_dynamic_sized_type(input_abi["type"]):
+        if input_abi.get("indexed") and is_dynamic_sized_type(input_abi["type"]):
             yield "bytes32"
         else:
-            yield get_normalized_abi_arg_type(input_abi)
+            yield collapse_if_tuple(input_abi)
 
 
 @curry
@@ -230,22 +231,14 @@ def get_event_data(
     Given an event ABI and a log entry for that event, return the decoded
     event data
     """
-    if event_abi["anonymous"]:
-        log_topics = log_entry["topics"]
-    elif not log_entry["topics"]:
-        raise MismatchedABI("Expected non-anonymous event to have 1 or more topics")
-    elif event_abi_to_log_topic(dict(event_abi)) != _log_entry_data_to_bytes(
-        log_entry["topics"][0]
-    ):
-        raise MismatchedABI("The event signature did not match the provided ABI")
-    else:
-        log_topics = log_entry["topics"][1:]
-
+    log_topics = get_event_log_topics(event_abi, log_entry["topics"])
     log_topics_bytes = [_log_entry_data_to_bytes(topic) for topic in log_topics]
     log_topics_abi = get_indexed_event_inputs(event_abi)
     log_topic_normalized_inputs = normalize_event_input_types(log_topics_abi)
     log_topic_types = get_event_abi_types_for_decoding(log_topic_normalized_inputs)
-    log_topic_names = get_abi_input_names(ABIEvent({"inputs": log_topics_abi}))
+    log_topic_names = get_abi_input_names(
+        ABIEvent({"name": event_abi["name"], "type": "event", "inputs": log_topics_abi})
+    )
 
     if len(log_topics_bytes) != len(log_topic_types):
         raise LogTopicError(
@@ -256,7 +249,9 @@ def get_event_data(
     log_data_abi = exclude_indexed_event_inputs(event_abi)
     log_data_normalized_inputs = normalize_event_input_types(log_data_abi)
     log_data_types = get_event_abi_types_for_decoding(log_data_normalized_inputs)
-    log_data_names = get_abi_input_names(ABIEvent({"inputs": log_data_abi}))
+    log_data_names = get_abi_input_names(
+        ABIEvent({"name": event_abi["name"], "type": "event", "inputs": log_data_abi})
+    )
 
     # sanity check that there are not name intersections between the topic
     # names and the data argument names.
@@ -462,8 +457,8 @@ class AsyncEventFilterBuilder(BaseEventFilterBuilder):
         if not isinstance(async_w3, web3.AsyncWeb3):
             raise Web3ValueError(f"Invalid web3 argument: got: {async_w3!r}")
 
-        for arg in AttributeDict.values(self.args):
-            arg._immutable = True  # type: ignore[attr-defined]
+        for arg in self.args.values():
+            arg._immutable = True
         self._immutable = True
 
         log_filter = await async_w3.eth.filter(self.filter_params)
@@ -490,12 +485,12 @@ def _build_argument_filters_from_event_abi(
     for item in event_abi["inputs"]:
         key = item["name"]
         value: "BaseArgumentFilter"
-        if item["indexed"] is True:
+        if item.get("indexed") is True:
             value = TopicArgumentFilter(
-                abi_codec=abi_codec, arg_type=get_normalized_abi_arg_type(item)
+                abi_codec=abi_codec, arg_type=collapse_if_tuple(item)
             )
         else:
-            value = DataArgumentFilter(arg_type=get_normalized_abi_arg_type(item))
+            value = DataArgumentFilter(arg_type=collapse_if_tuple(item))
         yield key, value