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

Revert changes for `get_*_function_abi` for edge case tests

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,
 )
@@ -85,9 +85,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 +99,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 +109,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 +169,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 +183,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 +208,7 @@ def prepare_transaction(
         w3,
         fn_identifier,
         contract_abi,
-        fn_abi,
+        abi_callable,
         fn_args,
         fn_kwargs,
     )
@@ -272,7 +267,7 @@ 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_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
@@ -282,7 +277,7 @@ 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_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
@@ -292,13 +287,13 @@ 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_abi = cast(ABIReceive, get_abi_element(contract_abi, "receive"))
     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 +302,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(
@@ -378,3 +373,4 @@ async def async_parse_block_identifier_int(
         if block_num < 0:
             raise BlockNumberOutOfRange
     return BlockNumber(block_num)
+    return BlockNumber(block_num)

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

web3/contract/base_contract.py

@@ -122,7 +122,6 @@
     check_if_arguments_can_be_encoded,
     get_abi_element,
     get_abi_element_info,
-    get_constructor_function_abi,
     get_event_abi,
 )
 
@@ -913,7 +912,7 @@ def _encode_constructor_data(
         cls, *args: Sequence[Any], **kwargs: Dict[str, Any]
     ) -> HexStr:
         try:
-            constructor_abi = get_constructor_function_abi(cls.abi)
+            constructor_abi = get_abi_element(cls.abi, "constructor")
         except ABIConstructorNotFound:
             constructor_abi = None
 
@@ -1097,8 +1096,8 @@ def __init__(
     @combomethod
     def _encode_data_in_transaction(self, *args: Any, **kwargs: Any) -> HexStr:
         try:
-            constructor_abi = get_constructor_function_abi(self.abi)
-        except ABIConstructorNotFound:
+            constructor_abi = get_abi_element(self.abi, "constructor", *args, **kwargs)
+        except MismatchedABI:
             constructor_abi = None
 
         if constructor_abi: