EIP-7922 Dynamic adjustment of the exit queue limit (Dynamic exit queue rate limit)

No call decision · Consensus & staking · EIP status Stagnant · created 2025-03-24

The per-epoch exit churn limit applied when validators leave the network is adjusted dynamically based on actual historical exit records instead of a fixed value. This reduces wait times when exits are concentrated while maintaining the same security level.

Why it is needed

Ethereum validators who want to stop staking and leave must pass through an exit queue. If too much stake exits at once, a malicious validator could withhold a conflicting block, publish it after the stake has exited, execute a double-spend attack, and avoid accountability through slashing. That is why the amount that can exit per epoch is currently fixed, at 16 validators per epoch for a validator set of 1,053,742. This figure comes from a limit of roughly 10% of total stake exiting per month. However, this limit takes no account of past conditions. For example, even if no one has exited in the past 13 days, a large staking operator running 30,000 validators (3% of the total) would still have to wait 1,875 epochs, about 8.33 days, to exit, even though doing so would not violate the overall constraint of allowing up to 5.04% to exit over two weeks. This kind of unnecessary waiting arises during periods of unusually high exit demand, such as institutional liquidations or market events.

What changes

Today

After EIP-7922

Who is affected

In depth

The current exit queue and security model

Currently, the exit volume allowed per epoch is determined by a ratio set via CHURN_LIMIT_QUOTIENT=2^16. For 1,053,742 validators, this is 16 per epoch, and since there are 225 epochs per day, that is 3,600 per day and 108,000 over 30 days, about 10% of the total. In other words, this is a constraint ensuring the economic security of finalized transactions does not degrade by more than 10% per month. This constraint is necessary because, if a malicious validator could exit immediately without delay, a double-spend attack would become possible: publishing a block while withholding a conflicting one, then revealing it after the stake has exited the protocol. In that case, slashing cannot enforce accountability, and if an attacker holding one-third of total stake manages to split the two-thirds honest majority in half, two mutually conflicting finalized transactions could exist.

Core idea: looking at history removes the need for a per-epoch cap

The fixed limit of 16 per epoch is actually a bundle of constraints of the form 'at most 16·n over the next n epochs.' This EIP proposes explicitly selecting one of those constraints and enforcing it flexibly instead. The weak subjectivity constraint cited as an example in the source is 'no more than 50,400 over two weeks,' which corresponds to 5.04% for a validator set of 1 million. As long as this constraint is maintained over every rolling two-week window, there is no need for a rigid per-epoch cap. If there have been no exits at all in the past 13 days, even an immediate exit of 30,000 validators would not violate the two-week constraint, yet under the current rules this would require waiting 1,875 epochs (8.33 days). Looking back at historical exit records allows the limit to be safely raised whenever the network has been operating consistently below the limit.

Recording by generation: new constants and state variables

Time is divided into generations of 256 epochs (about 27 hours) each. The constants are EPOCHS_PER_CHURN_GENERATION=256, GENERATIONS_PER_EXIT_CHURN_VECTOR=16 (about 18 days), GENERATIONS_PER_EXIT_CHURN_LOOKAHEAD=2, and EXIT_CHURN_SLACK_MULTIPLIER=8. The beacon state gains exit_churn_vector: Vector[uint64, GENERATIONS_PER_EXIT_CHURN_VECTOR], which records the total balance exited per generation over the most recent 16 generations. The difference between the maximum possible exit volume per generation and the actual exit volume is the unused churn.

get_exit_churn_limit: computing the new limit

per_epoch_exit_churn is, as now, the total stake divided by 2^16 via get_activation_exit_churn_limit, capped at 256 ETH, which is currently 256 ETH per epoch. Multiplying this by the generation length of 256 gives per_generation_exit_churn, currently 65536 ETH. The function iterates over the past 14 generations, excluding the 2-generation lookahead, summing per_generation_exit_churn - churn_usage to obtain total_unused_exit_churn, and adds this to the per-epoch limit. The final return value is capped at per_epoch_exit_churn * EXIT_CHURN_SLACK_MULTIPLIER, i.e. 8 times the normal rate (currently 2048 ETH per epoch). However, if the generation containing earliest_exit_epoch is later than the lookahead generation, the slack is not used and only the existing per_epoch_exit_churn is returned.

Modifying compute_exit_epoch_and_update_churn

The existing function for determining the exit epoch is replaced with a simplified version inspired by MINSLACK. It uses the return value of get_exit_churn_limit as the per-epoch limit, and if the exit balance exceeds the amount consumable at the currently assigned epoch (exit_balance_to_consume), it pushes earliest_exit_epoch back by however many additional epochs are needed. The newly added part is usage recording. The exit_balance is added to the corresponding generation's entry in exit_churn_vector only if the generation of the assigned exit epoch falls within the lookahead window (current generation + 2 generations) and that generation's recorded value is not UINT64_MAX (indicating fully used).

Initialization and epoch processing

At EIP activation, since the actual usage of past generations is unknown, the entire exit_churn_vector is filled with UINT64_MAX, treating it as fully used. Then, from the current generation through the lookahead generation, only generations later than the one containing state.earliest_exit_epoch are initialized to 0. Afterward, during epoch processing, process_historical_exit_churn_vector runs to update the lookahead generation's record whenever the next epoch rolls over into a new generation. If earliest_exit_epoch is earlier than the lookahead generation, that generation's usage is reset to 0; otherwise it is marked UINT64_MAX, treating it as fully used.

Security: the 8x cap and the hard fork

The source explains that the validator exit constraint is essential to Ethereum's accountable safety, and that this proposal strictly limits the increase in churn to preserve core security guarantees. Because the maximum limit is capped at 8 times the original fixed limit, the safety assumptions hold even in worst-case scenarios. Since the consensus layer's state structure and epoch processing logic change, implementation requires a hard fork. The source's Rationale section also notes that this approach reduces wait times during periods of congestion and is simpler to implement than more complex dynamic mechanisms.

Design choices and current status

The source's Rationale explains that a generation length of 256 epochs (about 27 hours) and a history of 14 generations (about 16 days) were chosen to balance responsiveness and stability. The intent is to let the network adapt smoothly to ongoing changes in exit behavior. This EIP was created on March 24, 2025, and its current status is Stagnant, meaning it is not actively progressing. The specification may change if discussion resumes. There is no record of a core developer call deciding to include it in a specific fork.

Original EIP · ← EIPs