Better messaging for wrong tuple arguments to contract functions

- collapse tuple types into their nested types for the recognized function signature(s)
- collapse user argument types to better compare against the recognized function signature(s)

Author: fselmo

tests/core/contracts/test_contract_call_interface.py

@@ -573,9 +573,8 @@ def test_returns_data_from_specified_block(w3, math_contract):
 
 
 message_regex = (
-    r"\nCould not identify the intended function with name `.*`, "
-    r"positional argument\(s\) of type `.*` and "
-    r"keyword argument\(s\) of type `.*`."
+    r"\nCould not identify the intended function with name `.*`, positional arguments "
+    r"with type\(s\) `.*` and keyword arguments with type\(s\) `.*`."
     r"\nFound .* function\(s\) with the name `.*`: .*"
 )
 diagnosis_arg_regex = (
@@ -625,6 +624,52 @@ def test_function_multiple_error_diagnoses(w3, arg1, arg2, diagnosis):
             Contract.functions.a(arg1).call()
 
 
+@pytest.mark.parametrize(
+    "address", (
+        "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",  # checksummed
+        b'\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee',  # noqa: E501
+    )
+)
+def test_function_wrong_args_for_tuple_collapses_args_in_message(
+    address, tuple_contract,
+):
+    with pytest.raises(ValidationError) as e:
+        tuple_contract.functions.method(
+            (1, [2, 3], [(4, [True, [False]], [address])])
+        ).call()
+
+    # assert the user arguments are formatted as expected:
+    # (int,(int,int),((int,(bool,(bool)),(address))))
+    e.match("\\(int,\\(int,int\\),\\(\\(int,\\(bool,\\(bool\\)\\),\\(address\\)\\)\\)\\)")  # noqa: E501
+
+    # assert the found method signature is formatted as expected:
+    # ['method((uint256,uint256[],(int256,bool[2],address[])[]))']
+    e.match("\\['method\\(\\(uint256,uint256\\[\\],\\(int256,bool\\[2\\],address\\[\\]\\)\\[\\]\\)\\)'\\]")  # noqa: E501
+
+
+@pytest.mark.parametrize(
+    "address", (
+        "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",  # checksummed
+        b'\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee\xee',  # noqa: E501
+    )
+)
+def test_function_wrong_args_for_tuple_collapses_kwargs_in_message(
+    address, tuple_contract
+):
+    with pytest.raises(ValidationError) as e:
+        tuple_contract.functions.method(
+            a=(1, [2, 3], [(4, [True, [False]], [address])])  # noqa: E501
+        ).call()
+
+    # assert the user keyword arguments are formatted as expected:
+    # {'a': '(int,(int,int),((int,(bool,(bool)),(address))))'}
+    e.match("{'a': '\\(int,\\(int,int\\),\\(\\(int,\\(bool,\\(bool\\)\\),\\(address\\)\\)\\)\\)'}")  # noqa: E501
+
+    # assert the found method signature is formatted as expected:
+    # ['method((uint256,uint256[],(int256,bool[2],address[])[]))']
+    e.match("\\['method\\(\\(uint256,uint256\\[\\],\\(int256,bool\\[2\\],address\\[\\]\\)\\[\\]\\)\\)'\\]")  # noqa: E501
+
+
 def test_function_no_abi(w3):
     contract = w3.eth.contract()
     with pytest.raises(NoABIFound):
@@ -1291,7 +1336,8 @@ async def test_async_no_functions_match_identifier(async_arrays_contract):
 
 @pytest.mark.asyncio
 async def test_async_function_1_match_identifier_wrong_number_of_args(
-        async_arrays_contract):
+        async_arrays_contract
+):
     regex = message_regex + diagnosis_arg_regex
     with pytest.raises(ValidationError, match=regex):
         await async_arrays_contract.functions.setBytes32Value().call()

web3/_utils/abi.py

@@ -719,7 +719,8 @@ 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(
-            [arg["type"] for arg in normalize_event_input_types(abi.get("inputs", []))]
+            collapse_if_tuple(dict(arg))
+            for arg in normalize_event_input_types(abi.get("inputs", []))
         ),
     )
     return function_signature

web3/_utils/contracts.py

@@ -21,11 +21,13 @@
     add_0x_prefix,
     encode_hex,
     function_abi_to_4byte_selector,
+    is_binary_address,
+    is_checksum_address,
+    is_list_like,
     is_text,
 )
 from eth_utils.toolz import (
     pipe,
-    valmap,
 )
 from hexbytes import (
     HexBytes,
@@ -73,6 +75,28 @@
     from web3 import Web3  # noqa: F401
 
 
+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,
@@ -149,10 +173,16 @@ def find_matching_fn_abi(
                 "\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}`, positional "
-            f"argument(s) of type `{tuple(map(type, args))}` and keyword argument(s) of type "
-            f"`{valmap(type, kwargs)}`.\nFound {len(matching_identifiers)} function(s) with "
+            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}"
         )
 
@@ -331,3 +361,10 @@ def validate_payable(transaction: TxParams, abi: ABIFunction) -> None:
                     "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__