ERC-8176 ERC-7730 descriptor review attestation (Descriptor Attestations for ERC-7730)

Draft · Signatures & auth · created 2026-02-26

Defines a method for using EAS to prove that a specific reviewer has signed off on an ERC-7730 descriptor file. This lets wallets know whether a trusted reviewer has verified the descriptor.

Why it is needed

ERC-7730 descriptors are used by wallets to show human-readable transaction content before signing. However, a malicious contributor could upload a descriptor to a registry or repository that hides or mislabels important fields, a network attacker could swap out a descriptor in transit, and a registry mirror, CDN, or pinning gateway could serve a forged descriptor instead. ERC-7730's context binding confirms that a descriptor points to the correct contract and chain, but it does not indicate whether the display format itself was reviewed by a trusted party. Also, a git commit signature proves authorship within the repository, but that guarantee disappears the moment the descriptor is served via an API or extracted as a standalone file. In other words, there was no way to guarantee the full process by which a descriptor circulates once it leaves the repository.

What to implement

In depth

Canonical EAS schema

The schema used by this ERC is a single bytes32 descriptorHash, with schema UID 0xe023eef113c1670774801c34b377fdf612dd8a4d2fa92fe382e15bd91fafb5c2, registered on the EAS contract (0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587) on Ethereum mainnet (chainId=1). The resolver is 0x0, making it a permissionless schema that anyone can attest to, with revocable set to true. Every attestation conforming to this ERC must reference this schema UID; attestations referencing a different UID are out of scope even if their content is identical.

descriptorHash computation procedure

First parse the descriptor JSON, then recursively resolve includes references per ERC-7730's merge rules until none remain, producing a fully resolved result. Serialize this as a byte string using RFC 8785 (JCS, the JSON Canonicalization Scheme), then compute a 32-byte Keccak-256 hash (the Ethereum Yellow Paper variant, not NIST SHA3-256) to obtain the descriptorHash. If a file referenced via includes cannot be obtained at hash computation time, the hash cannot be computed, and verification of any attestation depending on it cannot reach a conclusion.

Onchain/offchain attestation format

Both formats carry the same information. An onchain attestation is created by calling attest() on the EAS contract and is stored in contract state under a deterministic UID. An offchain attestation is EIP-712-signed JSON following the EAS Offchain Attestation v2 format; it is not submitted onchain and is distributed together with the descriptor. The data field must always be the 32-byte descriptorHash. The EIP-712 domain for the offchain signature is fixed with name "EAS Attestation", version "0.26", chainId 1, and verifyingContract set to the canonical EAS contract; primaryType is Attest, with fields in the order version, schema, recipient, time, expirationTime, revocable, refUID, data, salt. For attestations under this ERC, version must be 2, schema must be the canonical UID, and data must be abi.encode(descriptorHash).

Attestation verification procedure

The verifier first checks that the schema field matches the canonical UID, decodes data as the descriptorHash, and compares it against the descriptorHash computed directly from the descriptor being verified. If expirationTime is nonzero and has passed, the attestation is treated as expired. Attester recovery is done offchain by ECDSA-recovering from the EIP-712 digest (for an EOA) or by calling ERC-1271 isValidSignature at the current block (for a contract); implementations that cache ERC-1271 results must limit the cache lifetime. For onchain attestations, the attester recorded on the EAS contract is trusted as is. Revocation status must be queried directly from the canonical EAS contract (getRevokeOffchain for offchain, the revocationTime in getAttestation for onchain), and revocation reports from whatever source delivered the attestation must not be trusted. Finally, check whether the attester is on the wallet's trust list.

Revocation

An attester can revoke an attestation it issued. Revocation is always an onchain transaction sent to the canonical EAS contract, regardless of whether the original attestation was onchain or offchain. For an offchain attestation, calling revokeOffchain(uid) records a timestamp against the (msg.sender, uid) pair; for an onchain attestation, calling revoke() sets the record's revocationTime. Under this ERC, only revocation by the original attester invalidates the attestation.

Lifetime (TTL) recommendation

Attesters are recommended to set expirationTime to a finite point in the future, to limit exposure if they lose operational capability due to key loss, organizational change, or service discontinuation. Setting expirationTime to 0 means the attestation never expires on its own and relies solely on active revocation, so wallets receiving such an attestation must factor this property into their trust policy.

Multi-attester semantics

Multiple attesters can each independently issue attestations for the same descriptor. Each attestation is verified independently, and the failure of one attestation does not invalidate the others or the descriptor itself. The policy for deciding how many attestations are required, and from which attesters, is the wallet's responsibility.

Proposal status

This proposal is still in Draft status. The detailed specification may change or discussion may stall going forward.

Things to watch out for

Original ERC · ← ERCs