Some facts about EIP 712

Before diving into the technicalities, it's essential to understand the problem EIP-712 solves. In traditional Ethereum transactions and interactions, users are often required to sign messages to prove ownership of an account. Before EIP-712, this signing was done on arbitrary data, which could be confusing and potentially risky, as it's hard to verify what exactly is being signed. This can often lead to malicious actors exploiting this and stealing tokens from victim's wallets.

EIP-712 solves this by introducing a standard for signing data that is both structured and typed. This means that the data being signed is organized in a specific way and that each piece of data is associated with a type (e.g., string, uint, etc.). This structured approach allows for the data to be displayed in a more user-friendly manner, making it clearer what the signer is agreeing to.

How It Works

EIP-712 introduces a method for creating a domain separator, a unique identifier for a smart contract that prevents signed messages from being valid across different contracts unintentionally. It also defines a way to hash structured data in a manner that is consistent across platforms.

Here’s a brief overview of the process:

Define the Data Types: The first step in implementing EIP-712 is to define the data types that will be used. This is done by creating a JSON schema that describes the types and structures of the data.

Create a Domain Separator: The domain separator is a hash that uniquely identifies a smart contract's domain, including the contract name, version, and the network it's on. This prevents signatures from being valid across different domains.

Hash the Structured Data: Once the data types are defined, the structured data can be hashed using a specific method defined in EIP-712. This hashed data can then be signed by a user's address.

Solidity Example

Implementing EIP-712 in a Solidity smart contract involves several steps. Below is a simplified example to illustrate the process:

In this example, a struct named MyData is defined, containing an id, a message, and the sender's address. The contract inherits from OpenZeppelin's EIP712 implementation, setting up a domain separator in the constructor. The hashAndSign function then demonstrates how to hash the data according to EIP-712 standards, preparing it for signing.

Link to the article