Fix argument type and function logic for prepare_transaction

Fix typing for `find_matching_event_abi`

Remove redundant `get_*_function_abi` methods, typing can be done client side

Fix mypy errors

Fix type for `get_abi_element` `args` as `Optional[Sequence[Any]]`

Fix docstrings types and ordering

Ensure `get_element_abi` uses the right `constructor`, `fallback`, or `receive` function

Fix issue with constructor function in `get_abi_element`

Use ``abi_element_name`` as argument name

Author: Stuart Reed

docs/migration.rst

@@ -292,7 +292,8 @@ Miscellaneous Changes
 - ``get_default_ipc_path()`` and ``get_dev_ipc_path()`` now return the path value
   without checking if the ``geth.ipc`` file exists.
 - ``Web3.is_address()`` returns ``True`` for non-checksummed addresses.
-- ``Contract.encodeABI()`` has been renamed to ``Contract.encode_abi()``.
+- ``Contract.encodeABI()`` has been renamed to ``Contract.encode_abi()``. The ``fn_name``
+  argument has been changed to ``abi_element_name``.
 - JSON-RPC responses are now more strictly validated against the JSON-RPC 2.0
   specification while providing more informative error messages for invalid responses.
 

newsfragments/3408.breaking.rst

@@ -0,0 +1,6 @@
+Upgrades to use latest ``ABI`` utilities and typings from ``eth-utils`` and ``eth-typing``.
+* Typings for ``ABI`` components are now available in the ``eth-typing`` package. ``ABI`` types previously in ``web3.types`` have been removed.
+* New versions of existing ABI functions were added to ``eth-utils`` and are now exposed in `web3.py` via ``web3.utils.abi``.
+* ABI exceptions have been renamed in ``web3.exceptions``. The ``ABIEventFunctionNotFound`` and ``FallbackNotFound`` exceptions have been removed. Use ``ABIEventNotFound`` and ``ABIFallbackNotFound`` instead.
+* ``MismatchedABI`` exceptions are raised instead of a ``Web3ValidationError`` for ABI related errors.
+* ``encode_abi`` arguments have been updated to use ``abi_element_name`` instead of ``fn_name``.

newsfragments/3408.feature.rst

@@ -0,0 +1,7 @@
+Utilities to extract function and event ``ABI`` attributes from a contract. Utilities in the ``web3.utils.abi`` module parse ABI elements and check encodability of provided arguments. ABI functions in ``eth-utils`` are exposed by the ``web3.utils.abi`` module.
+* ``get_abi_element_info`` returns an ``ABIElementInfo`` TypedDict with the ``abi``, ``selector``, and ``arguments``.
+* ``get_abi_element`` returns the ``ABI`` of a function, event, or error given the name and arguments.
+* ``check_if_arguments_can_be_encoded`` returns true if the arguments can be encoded with the given ABI.
+* ``get_event_abi`` returns the ``ABI`` of an event given the name.
+* ``get_event_log_topics`` returns the log topics of an event given the name.
+* ``log_topics_to_bytes`` returns the log topics as bytes.

tests/core/utilities/test_abi.py

@@ -49,9 +49,6 @@
     addresses_checksummed,
 )
 from web3.exceptions import (
-    ABIConstructorNotFound,
-    ABIFallbackNotFound,
-    ABIReceiveNotFound,
     MismatchedABI,
     Web3ValidationError,
     Web3ValueError,
@@ -62,11 +59,8 @@
 from web3.utils.abi import (
     get_abi_element,
     get_abi_element_info,
-    get_constructor_function_abi,
     get_event_abi,
     get_event_log_topics,
-    get_fallback_function_abi,
-    get_receive_function_abi,
 )
 
 FUNCTION_ABI_NO_INPUTS = ABIFunction({"type": "function", "name": "myFunction"})
@@ -547,90 +541,6 @@ def test_get_abi_element_codec_override(contract_abi: ABI) -> None:
     assert function_abi == expected_abi
 
 
-@pytest.mark.parametrize(
-    "abi,expected_abi",
-    [
-        ([LOG_TWO_EVENTS_ABI, SET_VALUE_ABI, ABI_CONSTRUCTOR], ABI_CONSTRUCTOR),
-        ([ABI_CONSTRUCTOR], ABI_CONSTRUCTOR),
-    ],
-)
-def test_get_constructor_function_abi(abi: ABI, expected_abi: ABIElement) -> None:
-    constructor_abi = get_constructor_function_abi(abi)
-    assert constructor_abi == expected_abi
-
-
-@pytest.mark.parametrize(
-    "abi,expected_abi",
-    [
-        ([LOG_TWO_EVENTS_ABI, SET_VALUE_ABI, ABI_RECEIVE], ABI_RECEIVE),
-        ([ABI_RECEIVE], ABI_RECEIVE),
-    ],
-)
-def test_get_receive_function_abi(abi: ABI, expected_abi: ABIElement) -> None:
-    receive_abi = get_receive_function_abi(abi)
-    assert receive_abi == expected_abi
-
-
-@pytest.mark.parametrize(
-    "contract_abi,expected_abi",
-    [
-        ([LOG_TWO_EVENTS_ABI, SET_VALUE_ABI, ABI_FALLBACK], ABI_FALLBACK),
-        ([ABI_FALLBACK], ABI_FALLBACK),
-    ],
-)
-def test_get_fallback_function_abi(contract_abi: ABI, expected_abi: ABIElement) -> None:
-    fallback_abi = get_fallback_function_abi(contract_abi)
-    assert fallback_abi == expected_abi
-
-
-@pytest.mark.parametrize(
-    "contract_abi,error_message",
-    [
-        (
-            [LOG_TWO_EVENTS_ABI, SET_VALUE_ABI],
-            "No {} function was found in the contract ABI.",
-        ),
-        (
-            [],
-            "No {} function was found in the contract ABI.",
-        ),
-    ],
-)
-def test_get_function_abi_raises_if_none_found(
-    contract_abi: ABI, error_message: str
-) -> None:
-    with pytest.raises(ABIFallbackNotFound, match=error_message.format("fallback")):
-        get_fallback_function_abi(contract_abi)
-
-    with pytest.raises(ABIReceiveNotFound, match=error_message.format("receive")):
-        get_receive_function_abi(contract_abi)
-
-    with pytest.raises(
-        ABIConstructorNotFound, match=error_message.format("constructor")
-    ):
-        get_constructor_function_abi(contract_abi)
-
-
-def test_get_function_abi_raises_if_multiple_found() -> None:
-    with pytest.raises(
-        MismatchedABI,
-        match="Multiple fallback functions found in the contract ABI.",
-    ):
-        get_fallback_function_abi([ABI_FALLBACK, ABI_FALLBACK])
-
-    with pytest.raises(
-        MismatchedABI,
-        match="Multiple receive functions found in the contract ABI.",
-    ):
-        get_receive_function_abi([ABI_RECEIVE, ABI_RECEIVE])
-
-    with pytest.raises(
-        MismatchedABI,
-        match="Multiple constructor functions found in the contract ABI.",
-    ):
-        get_constructor_function_abi([ABI_CONSTRUCTOR, ABI_CONSTRUCTOR])
-
-
 @pytest.mark.parametrize(
     "topics,anonymous,expected_topics",
     [

web3/_utils/abi.py

@@ -52,6 +52,7 @@
     ABIElement,
     ABIEvent,
     ABIFallback,
+    ABIFunction,
     ABIReceive,
     HexStr,
     TypeStr,
@@ -723,7 +724,11 @@ def build_strict_registry() -> ABIRegistry:
 
 
 def named_tree(
-    abi: Iterable[Union[ABIComponent, ABIComponentIndexed, Dict[TypeStr, Any]]],
+    abi: Iterable[
+        Union[
+            ABIComponent, ABIComponentIndexed, ABIFunction, ABIEvent, Dict[TypeStr, Any]
+        ]
+    ],
     data: Iterable[Tuple[Any, ...]],
 ) -> Dict[str, Any]:
     """
@@ -736,10 +741,12 @@ def named_tree(
 
 
 def _named_subtree(
-    abi: Union[ABIComponent, ABIComponentIndexed, 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(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()

web3/_utils/contracts.py

@@ -4,10 +4,10 @@
     Any,
     Callable,
     Dict,
+    List,
     Optional,
     Sequence,
     Tuple,
-    Type,
     Union,
     cast,
 )
@@ -21,12 +21,9 @@
 from eth_typing import (
     ABI,
     ABICallable,
-    ABIConstructor,
     ABIElement,
     ABIEvent,
-    ABIFallback,
     ABIFunction,
-    ABIReceive,
     ChecksumAddress,
     HexStr,
     TypeStr,
@@ -56,10 +53,6 @@
 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,
 )
@@ -85,9 +78,6 @@
     check_if_arguments_can_be_encoded,
     get_abi_element,
     get_abi_element_info,
-    get_constructor_function_abi,
-    get_fallback_function_abi,
-    get_receive_function_abi,
 )
 
 if TYPE_CHECKING:
@@ -102,7 +92,7 @@ def find_matching_event_abi(
     event_name: Optional[str] = None,
     argument_names: Optional[Sequence[str]] = None,
 ) -> ABIEvent:
-    filters = [
+    filters: List[functools.partial[Sequence[ABIElement]]] = [
         functools.partial(filter_abi_by_type, "event"),
     ]
 
@@ -112,7 +102,7 @@ def find_matching_event_abi(
     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]
@@ -172,9 +162,9 @@ def encode_abi(
 def prepare_transaction(
     address: ChecksumAddress,
     w3: Union["AsyncWeb3", "Web3"],
-    fn_identifier: Union[str, Type[FallbackFn], Type[ReceiveFn]],
+    fn_identifier: FunctionIdentifier,
     contract_abi: Optional[ABI] = None,
-    fn_abi: Optional[ABIElement] = None,
+    abi_callable: Optional[ABICallable] = None,
     transaction: Optional[TxParams] = None,
     fn_args: Optional[Sequence[Any]] = None,
     fn_kwargs: Optional[Any] = None,
@@ -186,17 +176,15 @@ def prepare_transaction(
     """
     fn_args = fn_args or []
     fn_kwargs = fn_kwargs or {}
-    if fn_abi is None:
-        fn_abi = get_abi_element(
-            contract_abi, fn_identifier, *fn_args, abi_codec=w3.codec, **fn_kwargs
-        )
-
-    if fn_abi["type"] == "error" or fn_abi["type"] == "event":
-        raise Web3ValidationError(
-            f"Cannot make a transaction with an `{fn_abi['type']}` ABI."
+    if abi_callable is None:
+        abi_callable = cast(
+            ABICallable,
+            get_abi_element(
+                contract_abi, fn_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 = {}
@@ -213,7 +201,6 @@ def prepare_transaction(
         w3,
         fn_identifier,
         contract_abi,
-        fn_abi,
         fn_args,
         fn_kwargs,
     )
@@ -224,32 +211,19 @@ def encode_transaction_data(
     w3: Union["AsyncWeb3", "Web3"],
     fn_identifier: FunctionIdentifier,
     contract_abi: Optional[ABI] = None,
-    fn_abi: Optional[ABICallable] = None,
     args: Optional[Sequence[Any]] = None,
     kwargs: Optional[Any] = None,
 ) -> HexStr:
-    info_abi: ABIElement
-    if fn_identifier is FallbackFn:
-        info_abi, info_selector, info_arguments = get_fallback_function_info(
-            contract_abi, cast(ABIFallback, fn_abi)
-        )
-    elif fn_identifier is ReceiveFn:
-        info_abi, info_selector, info_arguments = get_receive_function_info(
-            contract_abi, cast(ABIReceive, fn_abi)
-        )
-    elif isinstance(fn_identifier, str):
-        fn_info = get_abi_element_info(
-            contract_abi,
-            fn_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")
+    fn_info = get_abi_element_info(
+        contract_abi,
+        fn_identifier,
+        *args,
+        abi_codec=w3.codec,
+        **kwargs,
+    )
+    info_abi = fn_info["abi"]
+    info_selector = fn_info["selector"]
+    info_arguments = fn_info["arguments"]
 
     return add_0x_prefix(encode_abi(w3, info_abi, info_arguments, info_selector))
 
@@ -268,37 +242,7 @@ def decode_transaction_data(
     return named_tree(fn_abi["inputs"], decoded)
 
 
-def get_constructor_function_info(
-    contract_abi: Optional[ABI] = None, fn_abi: Optional[ABIConstructor] = None
-) -> Tuple[ABIConstructor, HexStr, Tuple[Any, ...]]:
-    if fn_abi is None:
-        fn_abi = get_constructor_function_abi(contract_abi)
-    fn_selector = encode_hex(b"")
-    fn_arguments: Tuple[Any, ...] = tuple()
-    return fn_abi, fn_selector, fn_arguments
-
-
-def get_fallback_function_info(
-    contract_abi: Optional[ABI] = None, fn_abi: Optional[ABIFallback] = None
-) -> Tuple[ABIFallback, HexStr, Tuple[Any, ...]]:
-    if fn_abi is None:
-        fn_abi = get_fallback_function_abi(contract_abi)
-    fn_selector = encode_hex(b"")
-    fn_arguments: Tuple[Any, ...] = tuple()
-    return fn_abi, fn_selector, fn_arguments
-
-
-def get_receive_function_info(
-    contract_abi: Optional[ABI] = None, fn_abi: Optional[ABIReceive] = None
-) -> Tuple[ABIReceive, HexStr, Tuple[Any, ...]]:
-    if fn_abi is None:
-        fn_abi = get_receive_function_abi(contract_abi)
-    fn_selector = encode_hex(b"")
-    fn_arguments: Tuple[Any, ...] = tuple()
-    return fn_abi, fn_selector, fn_arguments
-
-
-def validate_payable(transaction: TxParams, abi_element: ABICallable) -> None:
+def validate_payable(transaction: TxParams, abi_callable: ABICallable) -> None:
     """
     Raise Web3ValidationError if non-zero ether
     is sent to a non-payable function.
@@ -307,10 +251,10 @@ def validate_payable(transaction: TxParams, abi_element: ABICallable) -> None:
         "value" in transaction
         and to_integer_if_hex(transaction["value"]) != 0
         and (
-            "payable" in abi_element
-            and not abi_element["payable"]
-            or "stateMutability" in abi_element
-            and abi_element["stateMutability"] == "nonpayable"
+            "payable" in abi_callable
+            and not abi_callable["payable"]
+            or "stateMutability" in abi_callable
+            and abi_callable["stateMutability"] == "nonpayable"
         )
     ):
         raise Web3ValidationError(

web3/_utils/events.py

@@ -239,7 +239,7 @@ def get_event_data(
     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({"type": "event", "inputs": log_topics_abi})
+        ABIEvent({"name": event_abi["name"], "type": "event", "inputs": log_topics_abi})
     )
 
     if len(log_topics_bytes) != len(log_topic_types):
@@ -252,7 +252,7 @@ def get_event_data(
     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({"type": "event", "inputs": log_data_abi})
+        ABIEvent({"name": event_abi["name"], "type": "event", "inputs": log_data_abi})
     )
 
     # sanity check that there are not name intersections between the topic