EVMTools

EIP-712 Typed Data Hasher

Hash EIP-712 typed structured data online. Compute domain separator, struct hash, and final signing hash for permits and gasless transactions.

Intermediate Values

What is EIP-712?

  • EIP-712 defines a standard for signing typed structured data in Ethereum, making signatures human-readable in wallets.
  • Permit (ERC-2612): Approve token spending via signatures instead of on-chain transactions, saving gas.
  • Gasless transactions: Users sign typed data off-chain; relayers submit transactions and pay gas.
  • Governance: Protocols like Compound use EIP-712 for off-chain vote signing.
  • Hash formula: keccak256("\x19\x01" || domainSeparator || hashStruct(message))

How to Use This EIP-712 Typed Data Hasher

This free online tool computes all the intermediate and final hashes for EIP-712 typed structured data. Use it to debug signature verification, build permit flows, and understand the EIP-712 hashing process.

  1. Enter the domain data including the contract name, version, chain ID, and verifying contract address.
  2. Define your typed data with the primary type and its fields. The tool supports nested struct types.
  3. Provide the message values matching the defined types.
  4. View the computed hashes — domain separator, struct hash, and the final EIP-712 signing hash are all displayed for inspection and debugging.
  5. Copy any hash to compare against your contract's on-chain values or use in testing.

All computation runs locally in your browser. No private keys or sensitive data are transmitted to any server.

Common Use Cases

  • Permit debugging — Compute ERC-2612 Permit hashes to debug why signature verification is failing in your token contract.
  • Order signing — Verify EIP-712 hashes for DEX limit orders, NFT marketplace listings, and other off-chain order structures.
  • Meta-transaction development — Compute signing hashes for gasless transaction forwarders and relayer infrastructure.
  • Domain separator verification — Confirm that your contract's domain separator matches the expected value for the correct chain and address.
  • Security auditing — Verify EIP-712 implementations by independently computing hashes and comparing against the contract's behavior.

Related Tools

Keccak256 Hash Generator

Generate Keccak256 hashes, the underlying hash function used in all EIP-712 computations.

ABI Encoder / Decoder

Encode and decode ABI data used in the abi.encode step of EIP-712 struct hashing.

Checksum Address Converter

Convert addresses to EIP-55 checksum format for use in EIP-712 domain separators and messages.

Frequently Asked Questions

What is EIP-712 typed structured data?

EIP-712 is an Ethereum standard for hashing and signing typed structured data. Instead of signing raw bytes (which users cannot verify), EIP-712 defines a schema for structured data that wallets can display in a human-readable format. This enables users to understand what they are signing, improving security for permits, orders, and gasless transactions.

What is a domain separator in EIP-712?

The domain separator is a hash that uniquely identifies the signing context, typically including the contract name, version, chain ID, and verifying contract address. It prevents signatures from being replayed across different contracts or chains. The domain separator is computed as keccak256(abi.encode(typeHash, nameHash, versionHash, chainId, verifyingContract)).

How is the EIP-712 signing hash computed?

The final signing hash follows the formula: keccak256('\x19\x01' + domainSeparator + structHash). The '\x19\x01' prefix prevents collision with other signed data formats. The domainSeparator identifies the contract context, and the structHash is the keccak256 of the encoded typed data. This hash is what gets signed by the user's private key.

What is ERC-2612 Permit and how does it use EIP-712?

ERC-2612 Permit allows ERC-20 token approvals via signatures instead of on-chain transactions. Users sign an EIP-712 message containing the spender, value, nonce, and deadline. The contract verifies the signature and sets the approval. This enables gasless approvals and is widely used in DeFi protocols like Uniswap, Aave, and OpenSea.

What are common EIP-712 use cases in DeFi?

EIP-712 is used extensively in DeFi: ERC-20 Permit for gasless approvals, limit orders on DEXs (Uniswap, 1inch), NFT marketplace listings (OpenSea Seaport), meta-transactions for gasless interactions, governance voting (Compound Governor), and EIP-4337 account abstraction user operations.

How do I debug EIP-712 signature verification failures?

Common issues include: wrong chain ID in the domain separator, incorrect type hashes (ensure canonical type ordering), wrong encoding of nested structs, mismatched verifying contract address, or nonce issues. Use this tool to compute each component separately (domain separator, struct hash, final hash) and compare against your contract's values.

Related Tools & Guides

ABI Encoder / Decoder

Encode and decode Ethereum ABI data. Input function signatures and parameters to generate calldata.

Keccak256 Hash Generator

Generate Keccak256 hashes from text input. The hash function used by Ethereum and Solidity.

Signature Signer & Verifier

Sign messages with a private key and verify Ethereum EIP-191 signatures. Recover signer addresses from signed messages.

Try Also

UTF-8 / Hex / Bytes Converter

Convert between UTF-8 text, hexadecimal strings, and byte arrays. Essential for encoding and debugging Ethereum data.

Calldata Decoder

Decode raw Ethereum calldata hex into human-readable function calls and parameters.

Solidity Event Hash Calculator

Calculate keccak256 hashes for Solidity event signatures. Get topic 0 values for filtering Ethereum logs.