Debug EIP-712 type strings and hashes in Wake

Introduction: Type String Testing Tricks

A single typo in the type hash is a medium severity bug, but manually checking the hash is tedious and error-prone. The most time-consuming part of debugging an EIP-712 is finding out what actually went into the digest. wakes Struct expose base class encode_eip712_type and encode_eip712_data So you can see exactly what’s being hashed, compare it directly to Solidity, and verify that the signatures match before deployment. If you need to double-check raw and structured signatures, start with Signing Data in Wake: Raw, Structured, and Hash Flows.

Context and prerequisite testing

• By running tests within the Wake testing framework, Struct, AccountChain fasteners are available.
• Use subclassed data classes Struct. Field order and field names must reflect the Solidity structure validated on-chain.
• build Eip712Domain It matches exactly with the contract. that name, version, chainIdand verifyingContract The value should be the same as the Solidity side.
• When debugging errors, tests print type strings and call traces to quickly find schema or domain mismatches.

Technical Background: What Assistants Do

encode_eip712_type Instead of returning a hash, it builds a standard type string including the referenced structure. This visibility allows you to inspect order and field names while debugging. encode_eip712_data Returns the compressed bytes fed into the final digest. Together these helpers reflect aspects of Solidity. hashTypedData Even if you use nested structs or proxy-based validation contracts, you can simply assert that your tests and contracts use the same preimage.

Building typed structures that can be inspected

base Struct class is alive wake.testing. Subclass it with a data class and mirror the Solidity name exactly. If your Python keywords are different from Solidity, use: field(metadata="original_name": ...) Preserves the on-chain schema.

from dataclasses import dataclass, field
from wake.testing import *

@dataclass
class Person(Struct):
    name: str
    wallet: Address

@dataclass
class Mail(Struct):
    from_: Person = field(metadata="original_name": "from")
    to: Person
    contents: str

mail = Mail(
    from_=Person("Alice", Address(1)),
    to=Person("Bob", Address(2)),
    contents="Hello",
)

print(mail.encode_eip712_type())
# Mail(Person from,Person to,string contents)Person(string name,address wallet)

Keeping type strings human-readable helps you catch inconsistencies early, such as incorrect data types, stray whitespace, missing nested structures, and renamed variables. If the string matches the Solidity side, it can be safely hashed.

Data in hash format in the same way as in Solidity

Once the type string is verified, write the type hash and data bytes identical to the contract. The snippet below reflects the EIP-712 pipeline used internally. hashTypedData.

type_hash = keccak256(mail.encode_eip712_type().encode())
data = mail.encode_eip712_data()

typed_data_hash = keccak256(abi.encode_packed(type_hash, data))
domain = Eip712Domain(
    name="Mail",
    version="1",
    chainId=chain.chain_id,
    verifyingContract=Address(0x1234),
)

signature = Account.new().sign_structured(mail, domain)

because encode_eip712_data By returning the exact bytes fed into the digest, you can record and compare them with Solidity helpers or real-time contract calls without guessing.

Cross-check the contract

End-to-end claims provide the strongest evidence. The fuzz test below signs the same struct in two ways, using a manual hash and a high-level hash. sign_structured Use the helper and make sure both match your contract. hashTypedData Implementation of the base contract.

from wake.testing import *
from wake.testing.fuzzing import *
from dataclasses import dataclass, field

from pytypes.src.utils.ERC1967Factory import ERC1967Factory
from pytypes.ext.wake_tests.helpers.EIP712Mock import EIP712Mock

@dataclass
class Person(Struct):
    name: str
    wallet: Address

@dataclass
class Mail(Struct):
    from_: Person = field(metadata="original_name": "from")
    to: Person
    contents: str

class Eip712FuzzTest(FuzzTest):
    def __init__(self):
        self._factory = ERC1967Factory.deploy()

    def pre_sequence(self) -> None:
        self._impl = EIP712Mock.deploy()
        self._signer = Account.new()
        self._proxy = EIP712Mock(self._factory.deploy_(self._impl, self._signer).return_value)

    @flow()
    def sign_flow(self, mail: Mail) -> None:
        type_hash = keccak256(mail.encode_eip712_type().encode())
        mail_hash = keccak256(abi.encode_packed(type_hash, mail.encode_eip712_data()))

        for target in (self._impl, self._proxy):
            manual = self._signer.sign_hash(target.hashTypedData(mail_hash))
            structured = self._signer.sign_structured(
                mail,
                Eip712Domain(
                    name=target.NAME(),
                    version=target.VERSION(),
                    chainId=chain.chain_id,
                    verifyingContract=target.address,
                ),
            )
            assert manual == structured

@chain.connect()
def test_eip712_fuzz():
    Eip712FuzzTest().run(100, 100000)

Key points:

• The type string is displayed so you can see if it contains nested structures.
• The data bytes do not come from an opaque helper, but exactly match Solidity’s pre-image.

Preventative technology for reliable signatures

• Domain Sort: name, version, chainIdand verifyingContract It must be consistent with the contract. EIP712Domain accurately.
• Keep names standard: Enabled metadata="original_name": ... Prevent Python keywords from automatically changing Solidity field names.
• Write type string: print encode_eip712_type() Quickly pinpoint order or case issues from failed tests.
• Avoid Blind Hashing: Preferred sign_structured Unless the external API requires a precomputed digest.
• Pre-Image Assertion: Recalculate keccak256(abi.encodePacked(typeHash, data)) It is claimed to be identical to Wake’s output before Solidity verifies the signature.
• Fuzzy Nested Structure: Creates a combination of optional or nested fields to catch missing structure definitions in the type string.

conclusion

wakes Struct.encode_eip712_type and encode_eip712_data Take the guesswork out of testing entered data. By exposing type strings and pre-image bytes, you can accurately align with Solidity, verify contract domains, and prove that signatures match without trial and error. It provides reliable permission and meta-transaction flows by keeping domains consistent, logging type strings, and asserting digests on both sides.

Additional Resources