ERC-8092 Cross-account association proof standard (Associated Accounts)
Draft · Accounts & wallets · created 2025-11-25
A standard that lets two accounts publicly declare their relationship to each other and prove or revoke it with signatures from both sides. It can be used for sub-account identity inheritance, permission delegation, reputation aggregation, and similar purposes.
Why it is needed
It is common today for one person to use multiple addresses across a blockchain, but there is no standard way to publicly and reliably prove that these addresses belong to a connected identity. Because each app handles address linking in its own way, a link recognized in one app does not carry over to another, and every feature involving permission delegation or reputation aggregation requires a new app-specific ad hoc solution. This becomes even more complex when trying to link two addresses with different chains or account structures, since there is not even a standard address representation. Without this standard, inheriting a parent identity's permissions or reputation into a sub-account, or having a third party verify the relationship between two accounts, ends up implemented differently in every app, reducing interoperability.
What to implement
event AssociationRevoked(bytes32 indexed hash, bytes32 indexed revokedBy, uint256 revokedAt);: An event that records which record was revoked, by whom, and when, when an on-chain association is revoked.
In depth
AAR: The Core Data of an Association
AssociatedAccountRecord (AAR) is a shared payload describing the relationship between two accounts. initiator and approver are addresses in ERC-7930 binary format, allowing accounts on non-EVM chains to be recorded as raw bytes as well. validAt is the timestamp at which the association becomes valid, and validUntil is its expiration timestamp (optional). interfaceId is a 4-byte selector for interpreting the data field, and data is arbitrary bytes holding application-specific context such as delegation or hierarchical relationships. The AAR itself is immutable content that both parties must agree on, while signatures are kept in a separate structure and collected asynchronously.
SAR: A Wrapper Holding Signature and Revocation State
SignedAssociationRecord (SAR) wraps an AAR and holds both parties' signatures and metadata. initiatorSignature and approverSignature are the values with which the initiator and approver respectively signed the EIP-712 hash of the AAR, and initiatorKeyType/approverKeyType are 2-byte Key IDs specifying which signature scheme was used. revokedAt is 0 if not revoked, and changes to the revocation timestamp once revoked. In onchain contexts that require trust, it is recommended that the SAR carry signatures from both parties.
Signature Schemes Distinguished by Key ID
Each signature carries a 2-byte Key ID indicating which key and protocol it was signed with. 0x0000 is Delegated (delegated authentication), 0x0001 is secp256k1 (K1), 0x0002 is secp256r1 (R1), 0x0003 is BLS12-381, and 0x0004 is Ed25519 (EdDSA). The top bit is used as a flag so that protocol-integrated keys take the form 0x8000 | PROTOCOL_ID, where 0x8001 is WebAuthn/passkey, 0x8002 is ERC-1271 contract verification, and 0x8003 is ERC-6492 predeploy contract verification. Implementations using the Delegated key type must disclose how they interpret the delegation schema.
EIP-712 Signing Payload and Domain
The signature preimage takes the form keccak256(0x1901 || DOMAIN_SEPARATOR || structHash), where structHash is the encoding of the type hash "AssociatedAccountRecord(bytes initiator,bytes approver,uint40 validAt,uint40 validUntil,bytes4 interfaceId,bytes data)" together with each field's value (addresses are hashed with keccak256). DOMAIN_SEPARATOR is defined as a fixed value computed from EIP712Domain(string name,string version) with name="AssociatedAccounts" and version="1".
Onchain and Offchain Storage Requirements
To store a SAR onchain, it must first pass the checks in the Validation section; once it passes, an AssociationCreated event indexed by hash, initiator, and approver must be emitted. A record stored onchain must be revocable onchain. Offchain storage must provide a public endpoint accessible to all expected consumers, must perform validation before storing, and it is recommended that the storage location be discoverable through a standard method such as an ENS text record.
Five Steps of Validation
A consumer of a SAR must check all of the following. First, confirm that the current time is greater than or equal to validAt. If validUntil is nonzero, also check that the current time is less than it; if revokedAt is nonzero, also check that the current time is less than it. If initiatorSignature is present, verify that the signature over the AAR's EIP-712 preimage is valid using the scheme indicated by initiatorKeyType, and do the same for approverSignature. In onchain validation, 'current time' is replaced with block.timestamp.
Revocation Rules
Onchain storage must implement a method by which either party can revoke a valid association. Once a revocation is accepted, revokedAt is updated to the greater of block.timestamp and the revocation time specified by the account, and an AssociationRevoked event containing hash, revokedBy, and revokedAt is emitted. Offchain storage must also allow revocation by either party and update revokedAt. If an already-revoked association is revoked again with an earlier timestamp, that earlier timestamp takes precedence.
Standard status
This ERC-8092 is still in Draft stage, a proposal under discussion on the Ethereum Magicians forum. Its structure or detailed rules may change, or adoption may stall.
Things to watch out for
- Onchain Verification May Be Expensive or Infeasible for Some Key Types: In onchain applications, verifying signatures for certain key types may incur excessive gas costs or may not be supported at all. Integrators are responsible for appropriately handling unsupported key types.
- Offchain Storage Creates a Trust Vector: Using offchain storage introduces centralization risk for consumers. Integrators and consumers should account for this risk by informing users or by providing ways to reduce trust assumptions, such as keeping some state onchain.
- Onchain Takes Precedence When Stored Both Onchain and Offchain: It is preferable for each association to have a single canonical storage location per application. When the same association data is stored both onchain and offchain, the onchain data should take precedence.