EIP-8222 Lean Staking

No call decision · Security & privacy · EIP status Draft · created 2026-04-09

A proposal that splits staking deposits into two stages, 'pending deposit' and 'claim', breaking the public link between the deposit address and the validator key. In the claim stage, only ownership is proven, via a zero-knowledge proof.

Why it is needed

Today, Ethereum staking deposit transactions carry the validator key and withdrawal information in the clear, so anyone can track who operates which validator. At the time this EIP was written, more than 38 million ETH ($81 billion) is locked in the staking contract, and this public linkage threatens the funds, and sometimes the physical safety, of both solo stakers and institutions. Because EIP-6110 moved deposit inclusion and verification to the execution layer, changes on the deposit side are now possible through staking contract modifications alone, without touching the consensus layer. Also, since every validator would use the same two-stage deposit, even users with no intention of running a validator can hide within the same anonymity set to make private transfers. The core of this design is its dual purpose: validators get privacy by default, and ordinary users get a transfer mechanism with plausible deniability.

What changes

Today

After EIP-8222

Who is affected

In depth

Pending Deposit Tree and Two-Stage Deposit

The staking contract's `deposit` method is replaced with `add_pending_deposit`. The depositor sends at least 1 ETH and a 32-byte commitment, the commitment is inserted into the pending deposit tree, an append-only incremental binary Merkle tree, and a `PendingDeposit` event is emitted. The tree uses a SNARK-friendly hash such as Poseidon. The contract stores only the frontier needed to update the root (one hash per level) and keeps a circular buffer of recent roots (for example, 1024). A claim is valid against any root in the buffer, and a proof referencing an evicted root must be regenerated against the current root. Since older roots also have smaller anonymity sets, expiring them has the side effect of encouraging claims against larger anonymity sets.

Commitment and Nullifier Structure

The commitment is defined as `commitment = hash(nullifier_preimage | validator_key | withdrawal_cred | amount)`, and the nullifier as `nullifier = hash(nullifier_preimage)`. The `nullifier_preimage` is a single random value chosen by the depositor at deposit time, serving both as the commitment's hiding randomness and as the nullifier's source. Without knowing this value, an observer cannot link a published nullifier to a specific commitment. The zkSNARK proves in zero knowledge that an unclaimed commitment exists among the stored roots, and publishes the nullifier. Because the validator credentials and amount are included in the commitment preimage, the proof is inherently bound to those values.

The claim function and front-running prevention

`claim(pubkey, withdrawal_credentials, signature, deposit_data_root, deposit_proof, nullifier, amount)` consumes a pending deposit commitment, adds the deposit to the deposit tree, and the consensus layer processes it afterward. The contract records the nullifier to reject double claims. Even if a mempool observer tries to intercept the claim by swapping in their own `pubkey` and `withdrawal_credentials`, the circuit recomputes the commitment from the public inputs (the credentials and amount) and checks it against the tree's leaves, so different credentials produce a different commitment that is not in the tree and proof verification fails. The concrete encoding of `Proof` will be specified once the proof system is finalized.

Two-phase withdrawals and type 0x03 withdrawal credentials

The same pattern is extended to withdrawals. A new withdrawal credential type `0x03` is introduced, which puts `withdrawal_commitment = hash(withdrawal_nullifier_preimage | recipient_address)[0:31]` in the remaining 31 bytes instead of an address. When a `0x03` validator exits, instead of sending ETH to an address, the consensus layer inserts this commitment into the pending withdrawal tree, and later anyone who submits a proof to the execution layer showing they know the `withdrawal_nullifier_preimage` receives the ETH at the `recipient_address` embedded in the commitment. The pending withdrawal tree has the same structure as the pending deposit tree (an append-only Merkle tree, a circular root buffer, and a separate nullifier set). This fits naturally alongside the existing type scheme (`0x00` BLS, `0x01` execution address, `0x02` compounding), but this part alone requires a change to the consensus layer's withdrawal mechanism.

A direct path that bypasses the validator and bidirectional deniability

For users who only want privacy and do not want to go through the full validator lifecycle, a path is allowed that sends a pending deposit directly to the pending withdrawal tree. This is a three-step flow: prove ownership of the deposit, insert a `withdrawal_commitment` into the pending withdrawal tree instead of the entry queue, and claim it on the execution layer. In this case the deposit-side commitment is already bound to a `0x03` credential carrying the `withdrawal_commitment`, and both nullifier preimages are fixed at deposit time. Because the user never joins the validator set, they avoid the entry queue, validation duties, and the exit queue entirely. The sending side is indistinguishable from an ordinary validator deposit and the receiving side from an ordinary validator withdrawal, giving both parties plausible deniability. The authors state this is the first construction in Ethereum to provide bidirectional deniability. Even without this direct path, privacy can still be obtained by entering and then exiting the validator set, but a short-lived validator stands out and weakens the recipient's deniability.

Fixed denominations and nullifier set management

Because the amount is bound to the commitment, deposits of an arbitrary amount can only form an anonymity set with deposits of the exact same amount. A rare amount like 37.5 ETH has almost nowhere to hide, making it easy to link. The proposal therefore limits deposits to a fixed set of denominations (e.g. 32, 64, 128, 256, 512, 1024, 2048 ETH) with a separate tree per denomination. Since EIP-7251 raised the effective balance cap to 2048 ETH after Pectra, supporting only 32 ETH would be impractical. More denominations give more flexibility but split the anonymity set, while fewer denominations force a trade-off, such as splitting 96 ETH into 64 and 32 across multiple deposits. Meanwhile, the nullifier set grows monotonically and becomes a long-term storage burden; the proposal explains that adopting 'evolving nullifiers' as proposed by Bowe and Miers and adopted in Zcash's Tachyon upgrade (splitting into epochs and permanently retiring old sets via recursive proofs) can keep storage volume and verification cost bounded.

The LeanVM reference implementation and security considerations

The reference implementation uses LeanVM, based on a quantum-resistant proof system combining WHIR and SuperSpartan. It uses Poseidon1 over the Koala-Bear field (and its degree-5 extension), and exposes a `poseidon16` precompile (16 being the permutation width). Since the commitment preimage consists of 31 field elements (8 for the preimage, 13 for the validator key, 9 for the withdrawal credential, 1 for the amount), hashing chains three calls to `poseidon16`. On a MacBook M1 Pro benchmark (N = 500) with a depth-32 tree, proof generation takes 0.032 to 0.041 seconds, verification takes 0.005 to 0.012 seconds, and proof size is about 83 to 189 KB (Rho 1 to 4). Security depends on the soundness of the proof system; if the system is broken, deposits could be intercepted without a valid commitment. Also, `0x03` in its current form is incompatible with EIP-7002, so a separation is proposed where the withdrawal address stays hidden in the commitment while the exit authority address is exposed. The proposal also notes that, beyond deposit privacy, network anonymity (preventing IP exposure) is needed as well, and that the claim timing must be kept variable and unpredictable to avoid timing analysis.

Draft status

This EIP is in Draft status and its content may change. The hash function and field depend on the proof system that is ultimately chosen, so the current draft does not mandate a specific hash or field, and the `Proof` encoding is also still undetermined. The two-phase withdrawal portion is described as an extension separable from the core deposit protocol. There are no fork-inclusion decisions recorded in the call notes.

Original EIP · ← EIPs