EIP-712 Definition

EIP-712 is an Ethereum standard for hashing and signing typed, structured data so wallets can show people exactly what they are agreeing to. It replaces hard-to-read hex blobs with clear fields that are both human-readable and machine-verifiable.

Background and purpose

Before EIP-712, many “sign this message” prompts were opaque strings. That made it easy to confuse users and hard to verify what was being approved. EIP-712 improves the usability of off-chain signatures that later get checked on-chain by defining a shared way to encode the data and its structure. This reduces friction and helps people understand what they are signing. 

How the standard works

At the core is a digest that wallets ask you to sign. The digest is the keccak256 hash of three parts placed together in order: the constant prefix 0x1901, a domain separator, and the hash of the typed message itself. That fixed layout keeps signatures deterministic and compatible across tools.

Typed data model

Typed data is described in a JSON object with four pieces:

• types: the struct definitions used in the message
• primaryType: the top-level struct being signed
• domain: parameters for the signing domain
• message: the actual values to sign

This mirrors Solidity-style types and supports atomic values, strings and bytes, arrays, and nested structs. The type information is folded into the hash so both parties agree on the exact meaning of each field.

Domain separator

The domain separator prevents signatures from being replayed across apps or chains by binding a signature to a specific “signing space.” A domain can include one or more of these fields: name of the app or protocol, version, chainId, verifyingContract, and optional salt. Wallets may use these fields to inform or warn users, or even refuse to sign if something looks wrong.

What users see

Because the data is structured, wallets can present clear labels and values instead of raw hex. That way, users can check the key details before approving. The idea is to keep messages readable for humans while staying precise for machines.

JSON-RPC and wallet support

EIP-712 specifies a JSON-RPC method, eth_signTypedData, so apps can request a signature over typed data. This gives wallets and libraries a standard entry point for rendering and signing these messages.

Relationship to other EIPs

EIP-712 builds on the general message-signing rules in EIP-191 and uses EIP-155 chain IDs in the domain. In other words, it extends earlier work so that data is not only signed safely but also shown in a structured way.

Benefits at a glance

• Readable prompts: people can see fields and values rather than hashes
• Machine-verifiable structure: contracts and tools can reliably parse the same message
• Better UX for off-chain approvals that will be checked on-chain later

These usability gains are the main reason wallets adopt EIP-712 for “clear signing.”

Limits and security notes

The standard covers how to encode and sign. It does not itself provide replay protection or define what an app must do if the same signed message is submitted twice. Those behaviors are application-level concerns. Protocols should handle replays and idempotency in their own logic. 

Typical uses

Apps use EIP-712 for actions like off-chain approvals, meta-transactions, or any workflow where a user signs structured data that a smart contract will verify later. The shared structure lets wallets display the request clearly while contracts check the signature on-chain.

‍