--- eip: 8502 title: Dynamic individual consolidation incentive description: Encourage consolidation with a per-validator balance deduction that rises while the validator count is above a scheduled target. author: Anders Elowsson (@anderselowsson) discussions-to: https://ethereum-magicians.org/t/eip-0000-dynamic-individual-consolidation-incentive/30436 status: Draft type: Standards Track category: Core created: 2026-11-18 requires: 7251 --- ## Abstract This EIP encourages stakers to consolidate their stake into fewer validators to reduce the network load from carrying and aggregating votes. Each epoch, an individual consolidation incentive is subtracted from validator balances. It makes each additional validator carry a private cost, giving stakers a reason to reduce the public cost they impose on the network. The incentive is largest for 32-ETH validators, up to their attestation reward at full participation, and falls linearly with effective balance to zero at 2048 ETH. Every validator removed through consolidation therefore saves the staker about the same amount. The protocol lowers the target validator count at a constant rate over a predetermined period, then holds it fixed at a terminal target value. Starting from zero, the incentive rises gradually while the validator count is above target and falls ten times faster while it is below. ## Motivation Ethereum takes about 13 minutes to finalize a block, and proposals for faster finality aim to bring this down to a few slots. Typically, every validator votes in each finality round, and finality requires votes from validators holding two-thirds of the stake. Since any validator may be part of that two-thirds, the network must carry and aggregate votes from the whole validator set in every round. The cost grows with the number of validators, not with the amount of stake. At the time of writing, Ethereum has around 815,000 validators, making the validator count a central obstacle to faster finality. Post-quantum signatures, which are larger and costlier to aggregate, will raise the cost further and also put pressure on the current protocol. [EIP-7251](./eip-7251.md) lets stakers consolidate up to 2048 ETH into one validator, and large operators have begun to do so, but the average validator still holds only about 54 ETH. Consolidation is voluntary, and the protocol pays a 32-ETH validator the same yield per ETH as a 2048-ETH validator. With FOCIL ([EIP-7805](./eip-7805.md)), small validators may even earn more. Includers are selected per validator rather than per ETH, so a 32-ETH validator serves as includer 64 times as often per ETH as a 2048-ETH validator, and an includer may charge fees out of band for listing transactions in its inclusion list. Not consolidating therefore has a public cost, since the network must carry the votes of every validator, but little or no private cost. Nothing ensures that the validator count falls to a level that allows a clean fast-finality design, or that it stays there as new stake arrives. This EIP adds a dynamic individual consolidation incentive. The protocol publishes a schedule for the validator count that falls linearly toward a terminal target. As long as consolidation keeps pace with the schedule, nothing changes. If it lags, an individual incentive is subtracted from validators' balances each epoch, largest for the smallest validators and zero at 2048 ETH. Not consolidating then carries a private cost. How large an incentive each operator needs before it consolidates is knowledge dispersed among stakers and unavailable to protocol designers. The incentive therefore acts as a price rather than a fixed penalty. It rises only while consolidation lags the schedule, so the operators who can consolidate most cheaply move first, and it falls while the validator count is below the schedule. Each additional validator costs its operator about the same amount, so the price falls on the resource that a fast-finality design must economize: validators. ## Specification ### Parameters | Name | Value | Description | | --- | --- | --- | | `FORK_EPOCH` | TBD | Activation epoch | | `VALIDATOR_TARGET_START` | TBD, e.g. `2**19` | Target at ramp start | | `VALIDATOR_TARGET_END` | TBD, e.g. `2**17` | Terminal target | | `VALIDATOR_TARGET_RAMP_DURATION_MS` | `47_304_000_000` | Ramp, 1.5 years | | `CONSOLIDATION_FORCE_RISE_TIME_MS` | `25_920_000_000` | Rise time $\tau_{\uparrow}$, 300 days | | `CONSOLIDATION_FORCE_FALL_TIME_MS` | `2_592_000_000` | Fall time $\tau_{\downarrow}$, 30 days | | `CONSOLIDATION_FORCE_DENOMINATOR` | `10**9` | Force at 100% | ### Beacon state ```python class BeaconState(ProgressiveContainer): ACTIVE_FIELDS = active_fields(width=47, gaps=(8, 9, 10, 28)) # [Modified in this EIP] # ... existing fields ... consolidation_force: Uint64 # [New in this EIP] in units of 1 / CONSOLIDATION_FORCE_DENOMINATOR ``` The new field is appended at index 46, after the last field of the Heze beacon state. The fork upgrade function MUST set `consolidation_force = 0`. ### Helper functions ```python def get_validator_target(state: BeaconState, time_ms: Uint64) -> Uint64: genesis_time_ms = seconds_to_milliseconds(state.genesis_time) start_ms = compute_time_at_slot_ms(genesis_time_ms, compute_start_slot_at_epoch(FORK_EPOCH)) elapsed = min(time_ms - start_ms, VALIDATOR_TARGET_RAMP_DURATION_MS) reduction = (VALIDATOR_TARGET_START - VALIDATOR_TARGET_END) * elapsed // VALIDATOR_TARGET_RAMP_DURATION_MS return Uint64(VALIDATOR_TARGET_START - reduction) ``` ```python def get_validator_count(state: BeaconState) -> Uint64: # Active validators, excluding sources of pending consolidations epoch = get_current_epoch(state) active = len(get_active_validator_indices(state, epoch)) consolidating = len([ c for c in state.pending_consolidations if is_active_validator(state.validators[c.source_index], epoch) ]) return Uint64(active - consolidating) ``` ```python def get_individual_consolidation_incentive(state: BeaconState, index: ValidatorIndex) -> Gwei: e_min = MIN_ACTIVATION_BALANCE // EFFECTIVE_BALANCE_INCREMENT e_max = MAX_EFFECTIVE_BALANCE_ELECTRA // EFFECTIVE_BALANCE_INCREMENT e = state.validators[index].effective_balance // EFFECTIVE_BALANCE_INCREMENT e = min(max(e, e_min), e_max) full_reward = get_base_reward(state, index) * sum(PARTICIPATION_FLAG_WEIGHTS) // WEIGHT_DENOMINATOR exposed = full_reward * e_min * (e_max - e) // (e * (e_max - e_min)) # full_reward * f(e) return Gwei(exposed * state.consolidation_force // CONSOLIDATION_FORCE_DENOMINATOR) ``` ### Epoch processing ```python def process_consolidation_incentive(state: BeaconState) -> None: epoch = get_current_epoch(state) genesis_time_ms = seconds_to_milliseconds(state.genesis_time) start_ms = compute_time_at_slot_ms(genesis_time_ms, compute_start_slot_at_epoch(epoch)) end_ms = compute_time_at_slot_ms(genesis_time_ms, compute_start_slot_at_epoch(Epoch(epoch + 1))) count = get_validator_count(state) target = get_validator_target(state, end_ms) # Update the force: rise when above target, fall faster when below if count > target: gap = CONSOLIDATION_FORCE_DENOMINATOR * (count - target) // target step = gap * (end_ms - start_ms) // CONSOLIDATION_FORCE_RISE_TIME_MS state.consolidation_force = min(state.consolidation_force + step, CONSOLIDATION_FORCE_DENOMINATOR) else: gap = CONSOLIDATION_FORCE_DENOMINATOR * (target - count) // target step = gap * (end_ms - start_ms) // CONSOLIDATION_FORCE_FALL_TIME_MS state.consolidation_force -= min(step, state.consolidation_force) # Subtract the individual consolidation incentive from every active validator for index in get_active_validator_indices(state, epoch): decrease_balance(state, index, get_individual_consolidation_incentive(state, index)) ``` The function `process_epoch` MUST call `process_consolidation_incentive(state)` immediately after `process_rewards_and_penalties(state)`. Rewards, penalties and `get_base_reward` are unchanged. ### Interaction with other proposals With [EIP-8198](./eip-8198.md), `get_base_reward` takes the epoch being priced, and `get_individual_consolidation_incentive` passes the current epoch. With [Decoupled Consensus](https://github.com/ethereum/consensus-specs/blob/0f4fa3ffdd26ec083ff4dba65645d81433178413/specs/_features/eip8453/beacon-chain.md), which settles rewards in each round and removes `process_rewards_and_penalties` from epoch processing, `process_consolidation_incentive` runs at the start of `process_epoch`, and `full_reward` matches the finality reward at full participation over the rounds of an epoch. ## Rationale ### Overview The protocol compares the validator count $V$ with a target $T$. The validator count includes all active validators except those already committed to consolidating into another validator. The target moves linearly from `VALIDATOR_TARGET_START` to `VALIDATOR_TARGET_END` over `VALIDATOR_TARGET_RAMP_DURATION_MS`, starting at `FORK_EPOCH`, and then stays at `VALIDATOR_TARGET_END`. A consolidation force $F$ accumulates the relative gap $g = (V - T)/T$ over time. It rises with the rise time $\tau_{\uparrow}$ when the validator count is above target and falls with the shorter fall time $\tau_{\downarrow}$ when it is below. The force is updated once per epoch, with $\Delta t$ set to the epoch's duration. All durations are in milliseconds rather than epochs, so the ramp and the speed of the force stay the same in calendar time if the slot duration changes, as proposed in EIP-8198. Writing the maximum force, `CONSOLIDATION_FORCE_DENOMINATOR`, as 1: - If $g > 0$: $F \leftarrow \min(F + g\,\Delta t / \tau_{\uparrow},\ 1)$ - Otherwise: $F \leftarrow \max(F + g\,\Delta t / \tau_{\downarrow},\ 0)$ Each epoch, an individual consolidation incentive is subtracted from the balance of every active validator. It equals the fraction $F\,f(e)$ of $\hat r$, the validator's attestation reward at full participation. Here $e$ is the validator's effective balance in ETH, clamped to $[e_{\min}, e_{\max}] = [32, 2048]$: - Distribution: $f(e) = e_{\min}(e_{\max} - e) / \bigl(e\,(e_{\max} - e_{\min})\bigr)$ - Subtracted per epoch: $F\,f(e)\,\hat r$ Since $f(32) = 1$ and $f(2048) = 0$, the force is the share of its full attestation reward subtracted from a minimum-balance validator, and nothing is subtracted from fully consolidated validators. ### Expected outcome During the ramp, the incentive stays at zero as long as voluntary consolidation keeps pace with the schedule. If consolidation lags, the incentive rises until enough operators have consolidated to catch up. Operators respond in order of their cost of consolidating, so those with the cheapest path consolidate first, and the incentive climbs only as far as the gap requires, plus some overshoot while stakers respond. At the end of the ramp, provided the terminal target can be reached at a force of at most 100%, the validator count settles around the terminal target, sometimes drifting slightly above or below. Because the consolidation force falls ten times faster than it rises, the validator count may spend a little more time just above the target than below it. Consolidation is costly to reverse, so the incentive needed to keep the validator count at the target is lower than the incentive that was needed to reach it. In the long run, the incentive is the price of keeping a validator small. It reflects the ongoing value that operators place on small validators, such as more frequent includer seats under FOCIL, and it absorbs new small validators as stake arrives. The protocol need not estimate this value, since the force finds the level that offsets it. If operators kept small validators mainly out of inertia, this price is low. ### Pricing and capping A cap on participation, letting only the largest validators up to some number take part in finality, could complement the incentive. It would be set slightly above the terminal target, so that the validator count rarely exceeds it. On its own, however, a cap has four problems: - **It creates a cliff.** Validators just above the cutoff balance take part in finality and earn its rewards, while those just below are left out. The cutoff itself moves with the choices of everyone else, so stakers with less capital risk losing access to the most rewarding duties even when they hold more than 32 ETH, which may further discourage solo staking. The set of validators with finality duties also becomes less stable, since validators move in and out of it as the ranking changes. - **It favors access to capital over capital efficiency.** Seats go to the validators with the highest balances, and those left out are the smallest, such as those of solo stakers, even where large operators could have consolidated more cheaply. The incentive instead favors stakers who make the most efficient use of the capital available to them. A small staker can still take part at a lower yield, and it can compensate by keeping its costs, including its risks, low. - **It can make the cost of not consolidating entirely public.** Under the incentive, not consolidating always carries a private cost, since stakers pay for each validator seat. Under a cap, not maximally consolidating has no private cost, unless validators end up below the cutoff. Stake may therefore congregate in validators just above the cutoff, especially under current designs for FOCIL, which assign includer seats per validator. The same number of seats then leaves less room for small stakers, who may be able to make more efficient use of their capital. - **It complicates issuance policy.** Stake outside the cap still takes part in other duties, such as block proposals and data availability, but it does not vote on finality. The protocol must therefore decide whether to pay it finality rewards, and the reward curve's yield falls as stake grows. Neither choice works well: - *Paying it* makes being left out attractive. Since such stake would earn rewards without finality duties or exposure to slashing for finality votes, operators could gain by splitting their stake to fall below the cutoff. If the pay follows a reward curve evaluated on participating stake, splitting also raises issuance, because less participating stake means a higher yield paid on all stake. - *Not paying it* withholds finality rewards from small stakers and rewards those inside the cap for pushing others out. The stake inside the cap earns more as excluded stake leaves staking, and immediately if the curve is evaluated on participating stake. Operators inside the cap can push others out at no private cost, for example by keeping their stake split in many validators just above the cutoff. The incentive avoids these problems by pricing validators rather than rationing them, leaving it to stakers to decide who consolidates, so that consolidation happens where its cost is lowest. Since a price alone cannot guarantee a limit on the validator count, for example during a sudden inflow of small validators or if the force reaches 100% without enough consolidation, a cap, such as the finality participation cap proposed separately, can serve as a backstop. Validators left out by the cap would then still count toward the validator count, but the incentive would not be subtracted from them, since they already forgo their finality rewards. ### Subtracted from the balance each epoch The incentive is subtracted from each active validator's balance every epoch, rather than withheld from the rewards it earns. The amount does not depend on what the validator does, so the marginal reward for attesting stays intact at any force level. If the incentive were instead withheld from rewards, a 32-ETH validator at a force of 100% would earn nothing for attesting, and its only reason to attest would be to avoid the penalty. Subtracting from the balance also leaves penalties and proposer rewards untouched, and it lowers issuance relative to the reward curve but never raises it. ### Scaled by issuance The incentive is a fraction of the validator's attestation reward at full participation. Tying it to issuance keeps it in proportion to consensus rewards as deposit size, the reward curve and slot duration change, and it needs no estimate of MEV. It also gives the force's maximum of 100% a clear meaning: no validator loses more than its attestation reward at full participation. The drawback, noted in earlier analysis of consolidation incentives for Orbit SSF, is that issuance is not the only income of stakers. Dynamic control compensates for this only as long as the force needed stays below 100%. At 44M ETH staked, a force of 100% gives a yield gap of about 2.1 percentage points between 32-ETH and 2048-ETH validators, likely well above what is needed. A deep cut to issuance would lower this maximum gap in proportion. The unit could then be widened, for example with a fixed ETH component as in the Orbit analysis. Because the state stores the force itself, such a change would not make the force jump. An issuance-neutral variant would add the subtracted amount back to the rewards of larger validators. It would keep issuance on the reward curve and soften the loss for small validators while they are many. Neutrality does not by itself address the drawback above, which comes from the unit. Scaled by issuance, the variant's gap between small and large validators would still be roughly tied to issuance. The amount returned would widen the gap while small validators hold much of the stake, but this effect fades as they consolidate. The variant would also turn the incentive into a transfer from small to large validators. Holders of large validators would then profit whenever the force rises, which gives them a reason to push the validator count above target. Finally, it would need a sum over the validator set every epoch. ### Integral control on the relative gap As in [EIP-4844](./eip-4844.md), the force accumulates the gap over time rather than reacting to the current gap alone. Consider instead a force set directly from the current gap, as with a fixed incentive curve. It produces a given incentive only while the gap persists, so it settles where the gap is just large enough to sustain the needed force, and the target is missed in steady state. The integral keeps moving until the validator count meets the target. It thereby finds the needed force without the protocol having to know it in advance, provided the target can be reached at a force of at most 100%. The gap is measured as a share of the target rather than as a number of validators. With the example values in the Parameters table, the target falls from 524,288 to 131,072 validators over the ramp. Missing it by 10% then means about 52,000 excess validators at the start but only about 13,000 at the end. If the force responded to the number of excess validators, as the blob base fee in EIP-4844 responds to excess blob gas, the same 10% miss would move the force four times faster at the start than at the end. Measured as a share of the target, a 10% miss moves the force equally fast throughout the ramp, whatever the size of the validator set. The rise time sets how fast the force builds. A shorter rise time reaches the needed force sooner but overshoots more while stakers respond. With the example rise time of 300 days, a sustained 10% excess raises the force by one percentage point every 30 days. With 300k validators against a 100k target (a 200% excess), the force rises by about 20 percentage points per month and reaches 100% after 150 days if nobody consolidates. ### Faster fall than rise Consolidation is effectively one-way. Stakers consolidate in response to the incentive, but they do not deconsolidate when it falls, since that requires withdrawing stake and activating additional validators. An integral controller therefore ends up holding the force that was needed to *reach* the target, which is typically higher than the force needed to *stay* there. The excess force is only bled off while the validator count is below target, at a speed proportional to the shortfall. If the validator count ends up just below target, the fall is slow, and small validators keep losing an incentive that no longer buys anything. The force therefore falls ten times faster than it rises, with an example fall time of 30 days. If the validator count settles 5% below target, a force of 30% fades in about six months, instead of about five years with symmetric speeds. The trade-off is that the validator count may spend a little more time above target than below it, as described under "Expected outcome". Given that consolidation is one-way, this bias toward a lower incentive is intended. ### Linear rather than exponential In EIP-4844, the blob base fee is an exponential function of the excess, so each unit of excess changes the fee by a constant percentage. This suits a price that may need to range over many orders of magnitude, and whose errors matter in proportion to its level. Neither holds here, and a linear relation between accumulated gap and force is preferable for four reasons. 1. **Errors cost in absolute terms.** The cost of the incentive is the yield taken from small validators. Consolidation responds with a lag, during which any controller overshoots. With a linear relation, the overshoot is roughly the relative gap times the lag, divided by the rise time, at every level of the force. For example, a 10% excess and a 60-day lag give about 2 percentage points. With an exponential relation, the overshoot is a constant *factor*. It is then largest in absolute terms when the force is already high, and the force accelerates toward its maximum. 2. **Zero floor.** The linear force starts at zero and can return to zero after enough time below target. An exponential instead requires a positive minimum, such as the minimum blob base fee in EIP-4844. 3. **Bounded range.** The force is bounded between zero and its maximum, so the scale invariance of the exponential buys little. Its finer relative resolution at very small forces is of little value, since such forces also cost little. 4. **Predictability.** Above target, the force rises by the relative gap over each rise time, so operators can read off directly what lagging the schedule will cost. With a linear relation, the accumulated gap and the force are the same variable up to a constant, so the state stores the force itself. A later fork that changes the rise time, the fall time or the target schedule therefore leaves the current force unchanged. In EIP-4844, by contrast, changing the update fraction rescales the blob base fee at the fork boundary. ### Bound at 100% At the bound, a minimum-balance validator loses its entire attestation reward, so at full participation it earns nothing net from attesting. It keeps its proposer and sync committee rewards (about 16% of issuance) and its execution-layer rewards. At a 2.5% issuance yield (about 44M ETH staked), this is a loss of about 2.1 percentage points. A 64-ETH validator loses about half its attestation reward. A bound below 100%, such as 10%, would reintroduce the guess that the controller is meant to remove. If the bound is below the force actually needed, small validators bear the full bound permanently and the target is still missed. A bound above 100% would let the incentive exceed what a validator earns by attesting, cutting into its proposer and sync committee rewards and, at high enough levels, its principal. This would increase pressure on small stakers to exit or delegate whenever the target is infeasible, for example because there are more stakers than `VALIDATOR_TARGET_END`, each needing at least one validator. Earlier analysis of consolidation incentives for Orbit SSF argues against such forcing. The denominator `CONSOLIDATION_FORCE_DENOMINATOR` has no policy role beyond defining 100%. Consensus code has no floating point, so the force is stored as an integer in parts per billion. This precision must be fine enough that per-epoch steps do not round to zero. At a 1% excess, one 6.4-minute epoch moves the force by 148 parts per billion, which would round to zero at basis-point precision. ### Persistent deconsolidation If the validator count stays above target, the force rises to 100% and stays there. If the validator count stays at 524,288, the force reaches 10% after about 6 months, 50% after about 12 months and 100% after about 16 months. These figures use the example values in the Parameters table: a target falling from 524,288 to 131,072 validators over 1.5 years, and a rise time of 300 days. The protocol stores the force itself, and the stored value never exceeds 100%. The force therefore starts to fall as soon as the validator count drops below target. If the protocol instead kept accumulating the gap beyond that point, the force would remain at 100% long after the validator count had come down. ### Validators awaiting consolidation A consolidation request immediately schedules the source validator's exit, but the source stays active until the consolidation churn processes it. With [EIP-8061](./eip-8061.md), the consolidation churn per epoch is the total active balance divided by 65,536. At 44M ETH staked, that is about 670 ETH per epoch, or about 4,700 minimum-balance validators per day, so a backlog of 200k takes about 42 days to clear. If these validators were included in the validator count, the force would keep rising during that time even though the stakers had already acted. With 300k validators against a 100k target, a backlog of 200k draining over 42 days would add about 14 percentage points to the force. The validator count therefore excludes active validators that are sources of a pending consolidation, so the controller sees the commitment at once. The remaining delay comes from the request rate of the EIP-7251 request contract, which targets one request per block, so 200k requests take about four weeks. The incentive is still subtracted from excluded validators until they leave the active set. Validators in the regular exit queue remain in the validator count. The stake of a consolidation source merges into a validator that already exists, so the validator count is sure to fall. A voluntary exit may instead be followed by a new deposit. If all exiting validators were left out of the validator count, a staker could keep a rolling set of validators in the exit queue that the mechanism never sees. A staker could still keep validators out of the validator count by repeatedly consolidating, partially withdrawing and re-depositing, but it gains little from doing so. The incentive is still subtracted from validators awaiting consolidation, and re-deposited ETH earns nothing while it waits in the activation queue. The only benefit is a lower force, which all small validators share equally. Consolidating once and staying consolidated is cheaper, and it also reduces what is subtracted from the staker's own validators. The cost of excluding consolidation sources is that, while the consolidation queue drains, the number of active validators exceeds the validator count by the number of consolidation sources that are still active. ### Target schedule The target can start at roughly the validator count around the fork, so that the force is zero at activation. Stakers who consolidate at least as fast as the ramp then never bear any incentive, and the calendar schedule is known in advance. Validators awaiting consolidation are not included in the validator count, so the consolidation churn does not delay the controller. The ramp should still be comfortably longer than the time the churn needs, so that the number of active validators follows the schedule. At 44M ETH staked, the consolidation churn under EIP-8061 processes about 1.7M minimum-balance validators per year. The example ramp in the Parameters table, from 524,288 to 131,072 validators over 1.5 years, needs the validator count to fall by about 262k per year, about 15% of that capacity. ### Distribution across validator sizes The mechanism targets a validator count. In the current protocol, every validator attests once per epoch, whatever its balance, and proposer and sync committee selection are proportional to effective balance. So, unlike in Orbit SSF, there is no size-dependent activity rate or risk to compensate for. If anything, FOCIL gives small validators more includer seats per ETH, an advantage the incentive must also outweigh. The only thing that distinguishes two ways of staking the same ETH is how many validators they use, and $f(e)$ prices exactly that. For effective balances between 32 and 2048 ETH, and ignoring rounding, the reward $\hat r$ is proportional to $e$. The incentive subtracted from a validator is therefore proportional to $F\,e_{\min}(e_{\max} - e)/(e_{\max} - e_{\min})$, which is linear in $e$. Summed over a staker's $n$ validators holding total stake $S$, it is proportional to $F\,(n\,e_{\max} - S)$. It depends only on the number of validators and the total stake, not on how the stake is split. As a result: - Each additional validator costs the same: about $F$ times the full attestation reward of a 32-ETH validator. - Every consolidation that removes one validator saves the same, whether it merges two 32-ETH validators or two 1024-ETH validators. This is the inversely proportional distribution from earlier analysis of consolidation incentives for Orbit SSF, rescaled to reach zero at 2048 ETH so that nothing is subtracted from validators that cannot consolidate further. A log-scaled distribution would instead pay 32 times more per validator removed for merging 1024-ETH validators than for merging 32-ETH validators holding the same stake. | $e$ (ETH) | 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | | --- | --- | --- | --- | --- | --- | --- | --- | | $f(e)$ | 1 | 0.49 | 0.24 | 0.11 | 0.048 | 0.016 | 0 | | Incentive at $F = 100\%$, as a share of $\hat r$ | 100% | 49% | 24% | 11% | 4.8% | 1.6% | 0 | ## Backwards Compatibility This EIP changes the beacon chain state transition and requires a network upgrade. It adds one field to the beacon state and one step to epoch processing. Rewards, penalties, validator duties and the execution layer are unchanged, so validator clients need no changes. Software that predicts or accounts for validator balances, such as staking pools, liquid staking protocols, explorers and reward calculators, must account for the new subtraction each epoch. ## Security Considerations ### Gaming the validator count Sources of pending consolidations are not included in the validator count, but the incentive is still subtracted from them. Repeatedly consolidating and re-depositing to keep validators out of the validator count costs a staker more than it gains, as discussed under "Validators awaiting consolidation". ### Solo stakers and decentralization Every staker needs at least one validator, and stakers with more than 2048 ETH need one per 2048 ETH. The validator count therefore cannot fall below a certain level, even if everyone consolidates fully. If the terminal target is set below that level, the force stays at 100%, and small validators, mainly solo stakers, lose their attestation income permanently. That could push them to exit or delegate, weakening decentralization. The terminal target must therefore be set with the distribution of stakers in mind, and revisited if the force stays high. ## Copyright Copyright and related rights waived via [CC0](../LICENSE.md).