ERC-8441 Hybrid Post-Quantum Stealth Addresses (Hybrid post-quantum stealth address scheme)

Draft · Accounts & wallets · created 2026-08-28

Adds schemeId 3 to ERC-5564 stealth addresses, using ML-KEM-768 together with secp256k1 ECDH in payment announcements so that even a future quantum computer cannot determine the recipient of a past payment.

Why it is needed

ERC-5564's schemeId 1 relies solely on secp256k1 ECDH for the privacy of announcement contents. Anyone capable of solving the discrete logarithm problem, that is, anyone who in the future possesses a cryptographically relevant quantum computer (CRQC), can take a registered viewing key, recompute the shared secret for every past announcement, and determine which payment went to which recipient. This loss of privacy applies retroactively: every announcement sitting in the public record today will be decrypted all at once the moment a future quantum computer appears. Since announce() and registerKeys accept bytes of unbounded length, the announcement layer alone can be moved to post-quantum key exchange right now, without any new contract or protocol change. Spending, by contrast, has a later deadline, since theft requires a CRQC to exist while the funds remain in the account, and requires account- or protocol-level changes, so it is a separate problem to address.

What to implement

In depth

Hybrid Combiner

The sender and recipient combine the 32-byte x-coordinate ss_ec obtained from ECDH and the ss_pq obtained from ML-KEM-768 encapsulation using SHA3-256 to produce a 32-byte ss. The input order is fixed as the domain separator DS("pq-stealth/hybrid-payment/v1"), ss_ec, ss_pq, epk (33B), ct (1088B), viewing_pk_ec (33B), ek (1184B), and since every field has a fixed length, simple concatenation introduces no ambiguity. This structure mirrors NIST SP 800-227's KeyCombineCCA_H, designed so that, treating the hash as a random oracle, the overall construction remains IND-CCA secure even if only one of the two component KEMs is IND-CCA.

Offset and View Tag

The way the offset H(ss) and the view tag are derived from ss differs from schemeId 1. It computes base = SHA256("pq-stealth/offset/v1" || ss) and uses it as a valid scalar only when 0 < base < n (the order of the secp256k1 group); if it falls outside that range, instead of reducing it mod n, it fails and has the sender retry with a new random value. This is to prevent the case where, if base equals n, reducing mod n would make the offset 0, turning the stealth address into the registered spending_pk itself. The view tag is derived separately from the offset, using the first byte of SHA256("pq-stealth/view-tag/v1" || ss), so unlike schemeId 1, it does not publicly leak bits of the offset digest.

Key Generation and Seeds

Key generation takes a single 128-byte seed and deterministically splits it into spending_seed (32B), viewing_ec_seed (32B), and kem_seed (64B, ML-KEM's d and z). spending_seed and viewing_ec_seed must each be valid secp256k1 scalars, the three must be generated independently, and key generation fails if spending_seed equals any of viewing_ec_seed, d, or z. The result is a meta-address (spending_pk || viewing_pk_ec || ek, 1250B), a master key (spending_sk, held only by the owner), and a tracking key (viewing_ec || d || z, 96B, which can be delegated to a scanning service).

Meta-Address and Registration

The meta-address is exactly 1250 bytes: spending_pk (33B) || viewing_pk_ec (33B) || ek (1184B), and is registered via ERC-6538's registerKeys(3, meta). A decoder must reject anything that is not 1250 bytes, and must check that both compressed points are valid points on secp256k1 and that ek passes the FIPS 203 encapsulation key checks. If the sender supports schemeId 3 and the recipient is registered under that scheme, schemeId 3 must be used even if the recipient is also registered under schemeId 1. A recipient who wants protection is advised to register only schemeId 3 and deregister any existing schemeId 1 entry by registering it as empty.

Sender Procedure

On every announcement, the sender must draw a fresh ephemeral scalar esk and fresh ML-KEM encapsulation randomness. Reusing esk causes epk to repeat, revealing that two announcements came from the same sender, and reusing it toward the same recipient also makes ss identical, merging the two payments into a single stealth key. It computes epk = esk*G, ss_ec = ECDH(esk, viewing_pk_ec), and (ct, ss_pq) = ML-KEM-768.Encaps(ek) to combine into ss, derives stealth_pk and the address, calls announce(3, address, epk||ct, view_tag(ss)), and then pays to that address. The sender can know stealth_pk but cannot know stealth_sk.

Scanner and Cost

The scanner uses the tracking key to perform ECDH and ML-KEM-768 decryption on every announcement to reconstruct ss, and checks whether the view tag and address match. Because ML-KEM uses implicit rejection, even an invalid ciphertext decrypts to a random value without an error, so decryption succeeding by itself is not evidence of a match; the address comparison must still be performed. Since the view tag is a function of the entire ss, it can only be checked after completing both ECDH and decryption, so there is no cheaper pre-filter as there is with schemeId 1. As a result, scanning a single schemeId 3 announcement costs roughly 2 to 3 times more than schemeId 1.

Wire Format

ERC-5564's announce(schemeId, stealthAddress, ephemeralPubKey, metadata) is used as-is, but ephemeralPubKey is exactly 1121 bytes, with the first 33 bytes being epk and the next 1088 bytes being ct. The first byte of metadata is the view tag, after which the 56 bytes of token metadata recommended by ERC-5564 may be appended, but these bytes are not bound to ss and are merely an unverified claim by the sender. If ephemeralPubKey is not 1121 bytes or metadata is empty, the scanner skips that announcement.

Proposal status

This ERC was created on 2026-08-28 and is currently in Draft status. It remains a proposal stage that may change or stall, and is not a finalized standard.

Things to watch out for

Original ERC · ← ERCs