EIP-7942 Available Attestation

No call decision · Consensus & staking · EIP status Draft · created 2025-04-30

A proposal that recognizes a block as stable only if it includes attestations from at least one-third of the validators of the previous slot, and changes the fork choice rule to the longest stable chain rule to prevent chain reorg attacks.

Why it is needed

Every known effective attack on Ethereum proof-of-stake (PoS) is a reorg attack, that is, an attack that pushes an already-created block off the chain. The original text categorizes these into two branches: attacks that alter block weight and attacks that cause the block tree to be filtered. The response so far has been piecemeal, fixing one problem at a time as it surfaced. For example, proposer boosting, introduced to prevent ex-ante reorg attacks and balancing attacks, gave rise to a new attack called the sandwich reorg attack, in which two malicious proposers collude, and the response to that in the Capella upgrade led to the staircase attack. Many of the existing mitigations either lack formal proof or rely on the additional assumption that the attacker's stake is 20% or less. This proposal aims for a fundamental solution that is provably safe while remaining lightweight to implement.

What changes

Today

After EIP-7942

Who is affected

In depth

Weak quorum and the definition of a stable block

This borrows the concept of a weak quorum from BFT protocols. Among N validators, if at most f can be malicious, and f+1 have voted for block b, then at least one honest validator must have validated b, so these f+1 attestations serve as proof of availability for b. A block in slot t that receives attestations from more than one-third is denoted AA_t. A block b proposed in slot t is a stable block if its parent is AA_{t-1}, and otherwise an unstable block; a chain whose leaf block is a stable block is a stable chain.

Committee splitting and threshold ϑ calculation

In practice, validators are randomly split into 32 committees, so the number of malicious validators per committee is approximated by a binomial distribution. The threshold ϑ for the number of malicious validators within a committee is computed as ϑ = ⌊μ + σ·Φ⁻¹(1-p)⌋ for an allowed failure probability p, where μ = f' and σ² = f'(1 - f/n). Ethereum currently has about 2²⁰ validators, and at p = 10⁻⁶ the ratio is 0.3457, meaning the protocol fails once every 10⁶ slots (138 days). At p = 10⁻⁹, a malicious reorg occurs once every 380 years. As n grows large the ratio converges to f/n, so the conclusion is that ϑ can simply be set to one-third of the committee size.

Change 1: Parent selection rule

A block b at slot t must include ϑ+1 attestations proving that the parent is a valid output of slot t-1, in which case the parent is AA_{t-1}. If there is no AA_{t-1}, the output of the fork choice rule is used as the parent, and that block becomes an unstable block. In the validator specification, at proposal time the AA block is computed at the start of the slot, setting parent_root to the root aa_root of the later AA block; if there is no AA block, get_head(store), after running on_tick and applying pending attestations from slot-1, is used as parent_root.

Change 2: Replacing HLMD-GHOST with the longest stable chain rule

The fork choice is changed to the Longest Stable Chain rule, which outputs the head of the chain with the most stable blocks. Ties are broken by choosing the chain whose leaf block has the highest slot number. The implementation adds a Chain class with fields leaf (Root), length (uint64), and justified_checkpoint (Checkpoint), adds chains: Set[Chain] to Store, and get_head returns the leaf of the chain with the maximum length among the filtered chains. The reason for the replacement is that HLMD-GHOST is based on block weight determined by attestation counts, which cannot prevent an attacker from withholding attestations.

Change 3: Preserving transaction continuity via unstable_root

Adds an unstable_root field to the block. The proposer sets unstable_root to the hash of the latest unstable block, or leaves it as None if no such block exists. Transactions in unstable blocks must not conflict with transactions in the stable chain (the longest chain), and once a block containing unstable_root is finalized, the transactions within it can be finalized together. This is a mechanism to prevent transactions carried in unstable blocks from being discarded.

Change 4: Simplifying the filtering rule and justification

get_filtered_block_tree is simplified so that only chains justifying a checkpoint equal to the store's justified_checkpoint remain. The unrealized_justified_checkpoint and unrealized_finalized_checkpoint fields are removed, eliminating compute_pulled_up_tip, i.e. the handling of justification and finalization that occurs mid-epoch. A chain's justified_checkpoint is now updated only when crossing an epoch boundary.

Basis for reorg resistance and safety/liveness

The attacker has two possible strategies: immediately proposing a block that conflicts with the canonical chain, or building a block that extends the canonical chain and delaying its release. The former is blocked because a block extending a non-leaf block cannot receive attestations from honest validators and so becomes an unstable block. The latter is blocked because if two or more stable blocks are withheld, at least one of them has already been observed by all honest validators (Lemma 2 in the paper). Since the finality mechanism, Casper, is not modified, safety is preserved, and liveness is achieved because reorg resistance holds during synchronous periods, so that after GST some block eventually gets finalized. The proposal states that it introduces no new message types and therefore no new attack surface.

Deployment requirements and current status

This proposal modifies the fork choice logic and attestation format, so it may be incompatible with existing clients, and deployment requires a hard fork or protocol version flag. The source status is Draft, so the details of the specification may still change. No decision on fork inclusion has come out of core developer calls yet.

Original EIP · ← EIPs