feat: show decoded calldata on transaction signing (#2655)

Author: antazoey

docs/userguides/testing.md

@@ -449,7 +449,7 @@ assert x != 0  # dev: invalid value
 Take for example:
 
 ```python
-# @version 0.4.0
+# @version 0.4.3
 
 @external
 def check_value(_value: uint256) -> bool:

src/ape/api/transactions.py

@@ -7,7 +7,7 @@
 from typing import IO, TYPE_CHECKING, Any, NoReturn, Optional, Union
 
 from eth_pydantic_types import HexBytes, HexStr
-from eth_utils import is_hex, to_hex, to_int
+from eth_utils import humanize_hexstr, is_hex, to_hex, to_int
 from pydantic import ConfigDict, field_validator
 from pydantic.fields import Field
 from tqdm import tqdm  # type: ignore
@@ -26,6 +26,7 @@
 from ape.types.signatures import TransactionSignature
 from ape.utils.basemodel import BaseInterfaceModel, ExtraAttributesMixin, ExtraModelAttributes
 from ape.utils.misc import log_instead_of_fail, raises_not_implemented
+from ape.utils.trace import prettify_function
 
 if TYPE_CHECKING:
     from ethpm_types.abi import EventABI, MethodABI
@@ -169,6 +170,10 @@ def trace(self) -> "TraceAPI":
         """
         return self.provider.get_transaction_trace(to_hex(self.txn_hash))
 
+    @cached_property
+    def _calldata_repr(self) -> "CalldataRepr":
+        return self.local_project.config.display.calldata
+
     @abstractmethod
     def serialize_transaction(self) -> bytes:
         """
@@ -199,22 +204,63 @@ def to_string(self, calldata_repr: Optional["CalldataRepr"] = None) -> str:
         """
         data = self.model_dump(mode="json")  # JSON mode used for style purposes.
 
-        if calldata_repr is None:
-            # If was not specified, use the default value from the config.
-            calldata_repr = self.local_project.config.display.calldata
+        calldata_repr = calldata_repr or self._calldata_repr
+        data["data"] = self._get_calldata_repr_str(calldata_repr=calldata_repr)
+
+        params = "\n  ".join(f"{k}: {v}" for k, v in data.items())
+        cls_name = getattr(type(self), "__name__", TransactionAPI.__name__)
+        tx_str = f"{cls_name}:\n  {params}"
+
+        # Decode the actual call so the user can see the function.
+        if decoded := self._decoded_call():
+            tx_str = f"{tx_str}\n\n\t{decoded}"
+
+        return tx_str
+
+    def _get_calldata_repr_str(self, calldata_repr: "CalldataRepr") -> str:
+        calldata = HexBytes(self.data)
 
         # Elide the transaction calldata for abridged representations if the length exceeds 8
         # (4 bytes for function selector and trailing 4 bytes).
-        calldata = HexBytes(data["data"])
-        data["data"] = (
+        return (
             calldata[:4].to_0x_hex() + "..." + calldata[-4:].hex()
             if calldata_repr == "abridged" and len(calldata) > 8
             else calldata.to_0x_hex()
         )
 
-        params = "\n  ".join(f"{k}: {v}" for k, v in data.items())
-        cls_name = getattr(type(self), "__name__", TransactionAPI.__name__)
-        return f"{cls_name}:\n  {params}"
+    def _decoded_call(self) -> Optional[str]:
+        if not self.receiver:
+            return "constructor()"
+
+        if not (contract_type := self.chain_manager.contracts.get(self.receiver)):
+            # Unknown.
+            return None
+
+        try:
+            abi = contract_type.methods[HexBytes(self.data)[:4]]
+        except KeyError:
+            return None
+
+        ecosystem = (
+            self.provider.network.ecosystem
+            if self.network_manager.active_provider
+            else self.network_manager.ethereum
+        )
+        decoded_calldata = ecosystem.decode_calldata(abi, HexBytes(self.data)[4:])
+
+        # NOTE: There is no actual returndata yet, but we can show the type.
+        return_types = [t.canonical_type for t in abi.outputs]
+        if len(return_types) == 1:
+            return_types = return_types[0]
+
+        return prettify_function(
+            abi.name or "",
+            decoded_calldata,
+            returndata=return_types,
+            contract=contract_type.name or humanize_hexstr(self.receiver),
+            is_create=self.receiver is None,
+            depth=4,
+        )
 
 
 class ConfirmationsProgressBar:

src/ape/utils/__init__.py

@@ -108,7 +108,16 @@ def __getattr__(name: str):
 
         return getattr(testing_module, name)
 
-    elif name in ("USER_ASSERT_TAG", "TraceStyles", "parse_coverage_tables", "parse_gas_table"):
+    elif name in (
+        "USER_ASSERT_TAG",
+        "TraceStyles",
+        "parse_coverage_tables",
+        "parse_gas_table",
+        "prettify_dict",
+        "prettify_function",
+        "prettify_inputs",
+        "prettify_list",
+    ):
         import ape.utils.trace as trace_module
 
         return getattr(trace_module, name)
@@ -177,6 +186,10 @@ def __getattr__(name: str):
     "parse_coverage_tables",
     "parse_gas_table",
     "path_match",
+    "prettify_dict",
+    "prettify_function",
+    "prettify_inputs",
+    "prettify_list",
     "pragma_str_to_specifier_set",
     "raises_not_implemented",
     "request_with_retry",

src/ape/utils/os.py

@@ -200,7 +200,7 @@ def create_tempdir(name: Optional[str] = None) -> Iterator[Path]:
     Returns:
         Iterator[Path]: Context managing the temporary directory.
     """
-    with TemporaryDirectory() as temp_dir:
+    with TemporaryDirectory(ignore_cleanup_errors=True) as temp_dir:
         temp_path = Path(temp_dir).resolve()
 
         if name:

src/ape/utils/trace.py

@@ -1,8 +1,9 @@
 from collections.abc import Sequence
 from fnmatch import fnmatch
 from statistics import mean, median
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional, Union
 
+from eth_utils import is_0x_prefixed, to_hex
 from rich.box import SIMPLE
 from rich.table import Table
 
@@ -13,6 +14,209 @@
     from ape.types.trace import ContractFunctionPath, GasReport
 
 USER_ASSERT_TAG = "USER_ASSERT"
+DEFAULT_WRAP_THRESHOLD = 50
+
+
+def prettify_function(
+    method: str,
+    calldata: Any,
+    contract: Optional[str] = None,
+    returndata: Optional[Any] = None,
+    stylize: bool = False,
+    is_create: bool = False,
+    depth: int = 0,
+) -> str:
+    """
+    Prettify the given method call-string to a displayable, prettier string.
+    Useful for displaying traces and decoded calls.
+
+    Args:
+        method (str): the method call-string to prettify.
+        calldata (Any): Arguments to the method.
+        contract (str | None): The contract name called.
+        returndata (Any): Returned values from the method.
+        stylize (bool): ``True`` to use rich styling.
+        is_create (bool): Set to ``True`` if creating a contract for better styling.
+        depth (int): The depth in the trace (or output) this function gets displayed.
+
+    Returns:
+        str
+    """
+    if "(" in method:
+        # Only show short name, not ID name
+        # (it is the full signature when multiple methods have the same name).
+        method = method.split("(")[0].strip() or method
+
+    if stylize:
+        method = f"[{TraceStyles.METHODS}]{method}[/]"
+        if contract:
+            contract = f"[{TraceStyles.CONTRACTS}]{contract}[/]"
+
+    arguments_str = prettify_inputs(calldata, stylize=stylize)
+    if is_create and is_0x_prefixed(arguments_str):
+        # Un-enriched CREATE calldata is a massive hex.
+        arguments_str = "()"
+
+    signature = f"{method}{arguments_str}"
+    if not is_create and returndata not in ((), [], None, {}, ""):
+        if return_str := _get_outputs_str(returndata, stylize=stylize, depth=depth):
+            signature = f"{signature} -> {return_str}"
+
+    if contract:
+        signature = f"{contract}.{signature}"
+
+    return signature
+
+
+def prettify_inputs(inputs: Any, stylize: bool = False) -> str:
+    """
+    Prettify the inputs to a function or event (or alike).
+
+    Args:
+        inputs (Any): the inputs to prettify.
+        stylize (bool): ``True`` to use rich styling.
+
+    Returns:
+        str
+    """
+    color = TraceStyles.INPUTS if stylize else None
+    if inputs in ["0x", None, (), [], {}]:
+        return "()"
+
+    elif isinstance(inputs, dict):
+        return prettify_dict(inputs, color=color)
+
+    elif isinstance(inputs, bytes):
+        return to_hex(inputs)
+
+    return f"({inputs})"
+
+
+def _get_outputs_str(outputs: Any, stylize: bool = False, depth: int = 0) -> Optional[str]:
+    if outputs in ["0x", None, (), [], {}]:
+        return None
+
+    elif isinstance(outputs, dict):
+        color = TraceStyles.OUTPUTS if stylize else None
+        return prettify_dict(outputs, color=color)
+
+    elif isinstance(outputs, (list, tuple)):
+        return (
+            f"[{TraceStyles.OUTPUTS}]{prettify_list(outputs)}[/]"
+            if stylize
+            else prettify_list(outputs, depth=depth)
+        )
+
+    return f"[{TraceStyles.OUTPUTS}]{outputs}[/]" if stylize else str(outputs)
+
+
+def prettify_list(
+    ls: Union[list, tuple],
+    depth: int = 0,
+    indent: int = 2,
+    wrap_threshold: int = DEFAULT_WRAP_THRESHOLD,
+) -> str:
+    """
+    Prettify a list of values for displaying.
+
+    Args:
+        ls (list): the list to prettify.
+        depth (int): The depth the list appears in a tree structure (for traces).
+
+    Returns:
+        str
+    """
+    if not isinstance(ls, (list, tuple)) or len(str(ls)) < wrap_threshold:
+        return str(ls)
+
+    elif ls and isinstance(ls[0], (list, tuple)):
+        # List of lists
+        sub_lists = [prettify_list(i) for i in ls]
+
+        # Use multi-line if exceeds threshold OR any of the sub-lists use multi-line
+        extra_chars_len = (len(sub_lists) - 1) * 2
+        use_multiline = len(str(sub_lists)) + extra_chars_len > wrap_threshold or any(
+            ["\n" in ls for ls in sub_lists]
+        )
+
+        if not use_multiline:
+            # Happens for lists like '[[0], [1]]' that are short.
+            return f"[{', '.join(sub_lists)}]"
+
+        value = "[\n"
+        num_sub_lists = len(sub_lists)
+        index = 0
+        spacing = indent * " " * 2
+        for formatted_list in sub_lists:
+            if "\n" in formatted_list:
+                # Multi-line sub list. Append 1 more spacing to each line.
+                indented_item = f"\n{spacing}".join(formatted_list.splitlines())
+                value = f"{value}{spacing}{indented_item}"
+            else:
+                # Single line sub-list
+                value = f"{value}{spacing}{formatted_list}"
+
+            if index < num_sub_lists - 1:
+                value = f"{value},"
+
+            value = f"{value}\n"
+            index += 1
+
+        value = f"{value}]"
+        return value
+
+    return _list_to_multiline_str(ls, depth=depth)
+
+
+def prettify_dict(
+    dictionary: dict,
+    color: Optional[str] = None,
+    indent: int = 2,
+    wrap_threshold: int = DEFAULT_WRAP_THRESHOLD,
+) -> str:
+    """
+    Prettify a dictionary.
+
+    Args:
+        dictionary (dict): The dictionary to prettify.
+        color (Optional[str]): The color to use for pretty printing.
+
+    Returns:
+        str
+    """
+    length = sum(len(str(v)) for v in [*dictionary.keys(), *dictionary.values()])
+    do_wrap = length > wrap_threshold
+
+    index = 0
+    end_index = len(dictionary) - 1
+    kv_str = "(\n" if do_wrap else "("
+
+    for key, value in dictionary.items():
+        if do_wrap:
+            kv_str += indent * " "
+
+        if isinstance(value, (list, tuple)):
+            value = prettify_list(value, 1 if do_wrap else 0)
+
+        value_str = f"[{color}]{value}[/]" if color is not None else str(value)
+        kv_str += f"{key}={value_str}" if key and not key.isnumeric() else value_str
+        if index < end_index:
+            kv_str += ", "
+
+        if do_wrap:
+            kv_str += "\n"
+
+        index += 1
+
+    return f"{kv_str})"
+
+
+def _list_to_multiline_str(value: Union[list, tuple], depth: int = 0, indent: int = 2) -> str:
+    spacing = indent * " "
+    ls_spacing = spacing * (depth + 1)
+    joined = ",\n".join([f"{ls_spacing}{v}" for v in value])
+    new_val = f"[\n{joined}\n{spacing * depth}]"
+    return new_val
 
 
 class TraceStyles:

src/ape_accounts/accounts.py

@@ -221,8 +221,7 @@ def sign_message(self, msg: Any, **signer_options) -> Optional[MessageSignature]
     def sign_transaction(
         self, txn: "TransactionAPI", **signer_options
     ) -> Optional["TransactionAPI"]:
-        user_approves = self.__autosign or click.confirm(f"{txn}\n\nSign: ")
-        if not user_approves:
+        if not (self.__autosign or click.confirm(f"{txn}\n\nSign: ")):
             return None
 
         signature = EthAccount.sign_transaction(