Support contract error structs with anonymous fields

Author: fjarri

docs/changelog.rst

@@ -2,6 +2,18 @@ Changelog
 ---------
 
 
+0.10.1 (in development)
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Added
+^^^^^
+
+- Support for contract errors with anonymous fields. (PR_90_)
+
+
+.. _PR_90: https://github.com/fjarri-eth/pons/pull/90
+
+
 0.10.0 (2025-10-19)
 ~~~~~~~~~~~~~~~~~~~
 

pons/_client.py

@@ -156,10 +156,10 @@ class ContractError(Exception):
     error: Error
     """The recognized ABI Error object."""
 
-    data: dict[str, Any]
+    data: dict[str, Any] | tuple[Any, ...]
     """The unpacked error data, corresponding to the ABI."""
 
-    def __init__(self, error: Error, decoded_data: dict[str, Any]):
+    def __init__(self, error: Error, decoded_data: dict[str, Any] | tuple[Any, ...]):
         super().__init__(error, decoded_data)
         self.error = error
         self.data = decoded_data
@@ -189,10 +189,15 @@ def decode_contract_error(
         except UnknownError:
             return ProviderError(exc)
 
+        # These errors have named fields, so `decoded_data` is expected to be a dictionary.
+        # The assertions are there for `mypy`'s sake.
         if error == PANIC_ERROR:
+            assert isinstance(decoded_data, dict)  # noqa: S101
             return ContractPanic.from_code(decoded_data["code"])
         if error == LEGACY_ERROR:
+            assert isinstance(decoded_data, dict)  # noqa: S101
             return ContractLegacyError(decoded_data["message"])
+
         return ContractError(error, decoded_data)
     return ProviderError(exc)
 

pons/_contract_abi.py

@@ -583,27 +583,28 @@ def from_json(cls, error_entry: ABI_JSON) -> "Error":
 
         name = error_entry_typed["name"]
         fields = dispatch_types(error_entry_typed["inputs"])
-        if isinstance(fields, list):
-            raise TypeError("Error fields must be named")
 
         return cls(name=name, fields=fields)
 
     def __init__(
         self,
         name: str,
-        fields: Mapping[str, Type],
+        fields: Mapping[str, Type] | Sequence[Type],
     ):
         self.name = name
+        self._named_fields = isinstance(fields, Mapping)
         self.fields = Signature(fields)
 
     @cached_property
     def selector(self) -> bytes:
         """Error's selector."""
         return keccak(self.name.encode() + self.fields.canonical_form.encode())[:SELECTOR_LENGTH]
 
-    def decode_fields(self, data_bytes: bytes) -> dict[str, Any]:
+    def decode_fields(self, data_bytes: bytes) -> dict[str, Any] | tuple[Any, ...]:
         """Decodes the error fields from the given packed data."""
-        return self.fields.decode_into_dict(data_bytes)
+        if self._named_fields:
+            return self.fields.decode_into_dict(data_bytes)
+        return self.fields.decode_into_tuple(data_bytes)
 
     def __str__(self) -> str:
         return f"error {self.name}{self.fields}"
@@ -843,7 +844,7 @@ def __init__(
             error.selector: error for error in chain([PANIC_ERROR, LEGACY_ERROR], self.error)
         }
 
-    def resolve_error(self, error_data: bytes) -> tuple[Error, dict[str, Any]]:
+    def resolve_error(self, error_data: bytes) -> tuple[Error, dict[str, Any] | tuple[Any, ...]]:
         """
         Given the packed error data, attempts to find the error in the ABI
         and decode the data into its fields.

tests/TestClient.sol

@@ -104,6 +104,8 @@ contract PayableConstructor {
 contract TestErrors {
     error CustomError(uint256 x);
 
+    error AnonymousFieldError(uint256);
+
     uint256 state;
 
     constructor(uint256 x) {
@@ -152,4 +154,8 @@ contract TestErrors {
     function transactPanic(uint256 x) public {
         state = raisePanic(x);
     }
+
+    function raiseAnonymousFieldError(uint256 x) public view returns (uint256) {
+        revert AnonymousFieldError(x);
+    }
 }

tests/TestContractFunctionality.sol

@@ -98,6 +98,4 @@ contract Test {
         ByteInner[2] memory inner_arr = [inner1, inner2];
         emit Complicated("aaaa", bytestring33len2, foo, inner_arr);
     }
-
-    error MyError(address sender);
 }

tests/test_client.py

@@ -208,6 +208,20 @@ async def test_call_decoding_error(
         await session.call(wrong_contract.method.getState(456))
 
 
+async def test_error_with_anonymous_fields(
+    session: ClientSession,
+    compiled_contracts: dict[str, CompiledContract],
+    root_signer: AccountSigner,
+) -> None:
+    compiled_contract = compiled_contracts["TestErrors"]
+    deployed_contract = await session.deploy(root_signer, compiled_contract.constructor(123))
+
+    with pytest.raises(ContractError) as exc:
+        await session.call(deployed_contract.method.raiseAnonymousFieldError(4))
+    assert exc.value.error == deployed_contract.error.AnonymousFieldError
+    assert exc.value.data == (4,)
+
+
 async def test_estimate_deploy(
     session: ClientSession,
     compiled_contracts: dict[str, CompiledContract],

tests/test_contract_abi.py

@@ -762,18 +762,6 @@ def test_error_from_json() -> None:
     ):
         Error.from_json(dict(type="constructor"))
 
-    with pytest.raises(TypeError, match="Error fields must be named"):
-        Error.from_json(
-            dict(
-                inputs=[
-                    dict(internalType="address", name="", type="address"),
-                    dict(internalType="bytes", name="", type="bytes"),
-                ],
-                name="Foo",
-                type="error",
-            )
-        )
-
 
 def test_error_init() -> None:
     error = Error(
@@ -785,6 +773,8 @@ def test_error_init() -> None:
 
 
 def test_error_decode() -> None:
+    # Named fields
+
     error = Error(
         "Foo",
         dict(foo=abi.bytes(), bar=abi.uint(8)),
@@ -794,6 +784,17 @@ def test_error_decode() -> None:
     decoded = error.decode_fields(encoded_bytes)
     assert decoded == dict(foo=b"12345", bar=9)
 
+    # Anonymous fields
+
+    error = Error(
+        "Foo",
+        [abi.bytes(), abi.uint(8)],
+    )
+
+    encoded_bytes = encode_args((abi.bytes(), b"12345"), (abi.uint(8), 9))
+    decoded = error.decode_fields(encoded_bytes)
+    assert decoded == (b"12345", 9)
+
 
 def test_resolve_error() -> None:
     error1 = Error("Error1", dict(foo=abi.bytes(), bar=abi.uint(8)))