EIP Draft: Tapered Issuance Burn
eip: <to be assigned>
title: Tapered Issuance Burn
description: Burn a fraction of validator rewards that rises with the staking ratio, removing the issuance incentive to stake more than 50% of all ETH
author: pintail (@pintail-xyz), Jérôme de Tychey (@jdetychey), dapplion (@dapplion), pa7x1 (@pa7x1), Ladislaus von Daniels (@ladidan), Justin Drake (@justindrake)
discussions-to: <to be assigned>
status: Draft
type: Standards Track
category: Core
created: 2026-07-14Abstract
This EIP introduces a tapered issuance burn: at each epoch boundary each validator is charged a deduction for every duty it was assigned (attestation, block proposal, sync committee participation), sized as a fraction of the idealised reward for that duty, and the deducted ETH is burned. The burn fraction tapers linearly with the staking ratio, reaching 100% at a fixed saturation balance, so net staking yield declines as more ETH is staked. This removes the yield floor implicit in the current curve, letting the staking market settle where the yield meets the risk premium stakers demand. For a positive premium, this occurs at a staking ratio below 50%, beyond which issuance no longer incentivises further stake growth.
Applied in full at the fork, the burn would reduce yields sharply at today’s staking ratio, so the reduction is phased in over an 18-month transition by temporarily raising BASE_REWARD_FACTOR, which scales rewards, penalties, and the burn together. Net yield therefore begins close to today’s level and moves gradually to the permanent curve, with the balance between micro-incentives preserved throughout. The taper’s shape, however, is in full effect from activation: from day one, issuance no longer rewards growth beyond a 50% staking ratio.
Motivation
The choice between staking and simply holding ETH is made on the gap between the yields the two options offer and the risks each carries.1 For staking these include liquidity, slashing, operational, and regulatory risks; liquid staking exchanges some of these for risks attaching to the token issuer, whether smart-contract and governance risks for on-chain protocols or counterparty risk for a centralised provider. Stake is therefore expected to keep flowing in for as long as the net incentive to stake, given by the nominal yield, exceeds the premium the marginal staker demands for bearing those risks. The staking market reaches equilibrium only if the nominal yield falls to the level of the staking risk premium. This risk premium is trending down owing to the maturity of staking setups at the infrastructure, smartcontract and software level. Furthermore, the credibility of slashing is negatively impacted by large amounts of ETH at stake, further weighing on the staking risk premium.
Under the current issuance curve there is no point at which the incentive to stake switches off: the yield falls only as \(1/\sqrt{f}\) in the staking ratio \(f\), and retains a floor of roughly 1.5% however much ETH is staked. Where stake growth comes to rest therefore depends entirely on the marginal staker’s risk premium staying above that floor. There is reason to think the premium may continue to fall: as the staking ecosystem matures, trusted low-friction custodians such as ETF providers emerge, and tooling and liquid staking reduce the costs and risks that justify it. Meanwhile, since issuance increases with staking ratio, dilution costs to unstaked ETH holders increase, adding greater incentive to stake to avoid this dilution.
A drift toward a very high staking ratio is undesirable for two distinct reasons, which correspond to the two goals of this proposal: preserving Ethereum’s security, neutrality and resistance to capture, and protecting ETH’s role as money.
Security, neutrality, and resistance to capture
Beyond a certain level, additional stake makes Ethereum less secure, not more: the marginal contribution of new stake to economic security falls as the ratio rises, while several risks compound. As an ever-larger share of the ETH supply is held by custodians and staking providers rather than its owners, the social layer is deprived of its ability to hold large operators to account, while solo stakers are forced out.
- Stake concentration leads to moral hazard. A large operator that misbehaves can degrade consensus for its own gain, and its delegators bear the loss if slashing follows. This is a risk that should be priced by delegators, increasing the effective cost of delegated staking. But whenever one event puts a large share of the supply at risk (for example, a slashing event, or an exploit of the operator’s own systems) the holders with most to lose are also the best resourced and best organised to coordinate a fork reversing it. The DAO rescue is the precedent for the social layer overriding protocol rules at that scale. A dominant operator could therefore come to be treated as “too big to fail”. The resulting moral hazard is self-reinforcing: anticipating rescue rather than ruin, delegators stop demanding compensation for tail risk, the discount makes the largest operators cheaper to stake with, and stake concentrates further still.
- The social layer loses its backstop. Meanwhile, a fork that should happen becomes much harder to coordinate: “social slashing” of a colluding coalition can only succeed if the wider economy coordinates on the forked chain. Since most ETH holders cannot run validators themselves, the incentive toward ever-higher staking participation pushes an ever-larger share of the supply into custody with a handful of exchanges, ETFs, and staking service providers. With the owners of ETH no longer in full control of it (“not your keys, not your coins”), the credibility of a fork which implements social slashing, and therefore its deterrent effect, is diminished.
- Solo stakers are forced out. Dilution erodes everyone’s real return as the ratio climbs, but solo stakers, who in most jurisdictions pay income tax on their nominal yield, cross into negative dilution-adjusted returns well before large operators and holders of tax-shielded positions do (this includes accumulating exchange traded products (ETPs) and non-rebasing or wrapped liquid staking tokens (LSTs)).
The consequence is the capture of both the validator set and the ETH supply by a small group who are at much greater risk of coercion, undermining core Ethereum properties of neutrality and censorship resistance.
Nothing in the current curve arrests these trends. Because total issuance keeps rising as the staking ratio climbs, a large operator’s income grows with every validator it adds. This applies equally at every operator size, and at every staking ratio. Under this proposal increasing size is not rewarded, and this applies soonest for the largest operators, as set out in the Rationale.
ETH as money
Within the Ethereum economy ETH is not only the asset that secures the chain and pays for blockspace. It is also that economy’s money: its default collateral, unit of account, and medium of exchange. Performing those functions earns ETH a monetary premium, giving it value beyond what its use as a fee asset alone would command.
Monetary premium benefits ETH holders, but its significance is not confined to them. Economic security depends directly on the value of ETH: the cost of attacking Ethereum is the market value of the stake an attacker must acquire and forfeit, so a higher ETH price places a greater real value at slashing risk behind the same quantity of stake. This is security that scales with the value of ETH rather than with the quantity of it staked, and it carries none of the risks set out above. The existing issuance curve, however, undermines the monetary role on which that premium rests:
- Excess issuance taxes holders. Issuance to the staked base operates as a continuous dilution tax on holders of unstaked ETH, eroding the scarcity and monetary premium that underpin its value as money. This forces on every holder an artificial choice: accept the dilution, or take on the costs and risks of staking merely to avoid it. Neither leaves ETH functioning as neutral money: the first taxes holding it, the second makes holding it conditional on running infrastructure or trusting somebody who does.
- Staking derivatives displace ETH itself. At high staking ratios, yield-bearing LSTs and other staking derivatives come to dominate raw ETH as collateral and medium of exchange within the Ethereum economy, displacing the most neutral, permissionless, trustless asset available with intermediated claims on staking providers. For a staking provider this displacement is a rational profit-maximising strategy, pursued by embedding the derivative across every layer and application until it, rather than ETH, is the ecosystem’s working money. In consequence, liquidity fragments across competing derivatives and slippage rises on decentralised exchanges, while every application that settles in a staking derivative inherits its issuer’s smart-contract, counterparty, and governance risk.
- The social layer gains a dependency. Once one or more ETH derivatives become the ecosystem’s working money, the social layer becomes dependent on outside organisations, the derivatives they issues, and their governance processes. The applications that power the money thereby acquire outsized influence over the applications that use the money, making Ethereum a less desirable blockchain to build and develop on.
By removing the issuance incentive for further stake growth, this proposal keeps issuance itself bounded: it peaks at a staking ratio of roughly 20% and falls beyond that point, settling at the ratio where yield equals the compensation stakers require for the costs and risks they bear. Each staking derivative then faces stronger competition from non-staked ETH, keeping a trustless asset at the foundation of the ecosystem. On the supply side of the ledger, the tapered burn complements the fee burn of EIP-1559. Together they protect the monetary role of unstaked ETH, and with it the real value of the stake that secures the chain.
Restoring an equilibrium
This EIP proposes the minimal change needed to ensure that the issuance mechanism no longer drives stake growth beyond a 50% staking ratio: after computing rewards exactly as today, deduct from each validator a fraction of the idealised reward for each assigned duty with that fraction tapering linearly in the staking ratio up to a fixed saturation point. The deducted ETH is not credited anywhere and is therefore in effect burned. At the 50% saturation ratio the burn exactly cancels issuance. It therefore meets any positive risk premium at a staking ratio strictly below 50%, and the level of that premium is what fixes the equilibrium.
The two goals are served by different aspects of this change. The security and capture-resistance goal is met by the shape of the tapered curve: with the burn fully cancelling issuance at 50%, issuance no longer incentivises staking beyond that ratio. The ETH-as-money goal is served additionally by the level of issuance. This proposal bounds it below today’s curve, so that holders of ETH do not overpay for security through dilution.
The reduction is phased in over an 18-month transition, during which the effective base reward factor decays from twice its current value back to today’s, limiting the impact on existing stakers at activation. The tapered shape is nonetheless in full effect from the moment the transition begins: immediately after the fork, the issuance mechanism no longer rewards growth in the staking ratio beyond 50%, so the market has an equilibrium below that point.
Specification
Let \(D\) denote get_total_active_balance(state) in Gwei, and let SATURATION_BALANCE (Gwei, \(D_\text{sat}\)) be a fixed constant set at the hard fork to approximately half the ETH supply. Define the burn fraction
\[b = \left(\frac{D}{D_\text{sat}}\right)^{3/2}, \qquad \text{clamped to } b \le 1.\]
For each validator duty, a deduction of \(b\) times the idealised reward for that duty is applied (via decrease_balance) to every validator assigned the duty, immediately after rewards and penalties are applied for the epoch; the deducted ETH is destroyed. The deduction is a function of effective balance and total active balance only — it is charged whether or not the duty was performed. The attestation portion of the deduction is suspended while the chain is in an inactivity leak.
The only modification to the existing rewards machinery is temporary: to avoid a sudden drop in yield when the burn activates, get_base_reward_per_increment reads a time-varying effective base reward factor that starts at TRANSITION_BASE_REWARD_FACTOR (128) and decays linearly to BASE_REWARD_FACTOR (64) over TRANSITION_DURATION_EPOCHS (≈ 18 months). Because both rewards and the burn’s reference rewards derive from get_base_reward_per_increment, this elevation scales the whole schedule — rewards, penalties, and burn — uniformly, so the balance between them is preserved. Once the transition completes the effective factor is permanently 64, and process_rewards_and_penalties behaves exactly as it does today.
Constants
The following constants are added:
| Name | Value | Notes |
|---|---|---|
SATURATION_BALANCE |
Gwei(60_250_000 * 10**9) |
Total active balance \(D_\text{sat}\) at which the burn fraction reaches 100%; set at the hard fork to approximately half the current ETH supply |
TRANSITION_BASE_REWARD_FACTOR |
uint64(128) |
Effective base reward factor at the start of the transition — twice BASE_REWARD_FACTOR — decaying linearly to BASE_REWARD_FACTOR over the transition |
TRANSITION_START_EPOCH |
Epoch(...) |
Epoch at which the transition begins; set at the hard fork to the activation epoch |
TRANSITION_DURATION_EPOCHS |
Epoch(123_300) |
Transition length; \(123{,}300 = 548 \times 225\) epochs \(\approx 18\) months (225 epochs per day) |
SATURATION_BALANCE is expressed as a balance rather than as the ratio \(f_\text{sat}\) because the protocol observes get_total_active_balance(state) directly but has no notion of total ETH supply, so \(f\) is not something the state transition can compute. Fixing \(D_\text{sat} = f_\text{sat}\,S\) at the hard fork, using the supply at that time, means the effective saturation ratio drifts slowly as supply changes thereafter; the drift is small over any reasonable horizon, and a future EIP that made the protocol aware of total supply could recover \(D_\text{sat}\) from \(f_\text{sat}\,S\) directly.
Helper functions
get_issuance_burn applies the burn fraction to a reward. It is expressed as the cube of a square-root ratio so that it can be computed as three successive uint64 multiply-divides, keeping every intermediate value within uint64 — consistent with the rest of the reward machinery, which never forms a value wider than 64 bits. The two square roots are computed once per epoch by the caller and passed in.
def get_issuance_burn(reward: Gwei, sqrt_active: uint64, sqrt_sat: uint64) -> Gwei:
# reward * (sqrt_active / sqrt_sat)**3 == reward * (D / SATURATION_BALANCE)**(3/2)
burn = uint64(reward)
for _ in range(3):
burn = burn * sqrt_active // sqrt_sat
return Gwei(burn)get_attestation_participation returns the weighted participating balance that attestation issuance is actually paid on. It mirrors the scaling already present in get_flag_index_deltas, where each flag’s reward is multiplied by the share of active balance that attained it; summing weight * participating_increments across the three attestation flags gives the numerator the burn must match.
def get_attestation_participation(state: BeaconState, epoch: Epoch) -> uint64:
total = uint64(0)
for flag_index, weight in enumerate(PARTICIPATION_FLAG_WEIGHTS):
indices = get_unslashed_participating_indices(state, flag_index, epoch)
increments = get_total_balance(state, indices) // EFFECTIVE_BALANCE_INCREMENT
total += weight * increments
return totalThis EIP also relies on one lookup not present in the current specification: get_beacon_proposer_index_at_slot, the existing get_beacon_proposer_index generalised to an arbitrary slot in the epoch.
The base reward factor transition
get_base_reward_factor returns the effective base reward factor for an epoch: TRANSITION_BASE_REWARD_FACTOR at the start of the transition, decaying linearly to BASE_REWARD_FACTOR over TRANSITION_DURATION_EPOCHS, and permanently BASE_REWARD_FACTOR thereafter.
def get_base_reward_factor(epoch: Epoch) -> uint64:
# Elevated during the transition to cushion the yield reduction, decaying
# linearly from TRANSITION_BASE_REWARD_FACTOR at TRANSITION_START_EPOCH to
# BASE_REWARD_FACTOR after TRANSITION_DURATION_EPOCHS. Permanently
# BASE_REWARD_FACTOR — today's value — once the transition completes.
if epoch <= TRANSITION_START_EPOCH:
return TRANSITION_BASE_REWARD_FACTOR
elapsed = epoch - TRANSITION_START_EPOCH
if elapsed >= TRANSITION_DURATION_EPOCHS:
return BASE_REWARD_FACTOR
remaining = uint64(TRANSITION_DURATION_EPOCHS - elapsed)
boost = uint64(TRANSITION_BASE_REWARD_FACTOR - BASE_REWARD_FACTOR)
duration = uint64(TRANSITION_DURATION_EPOCHS)
return BASE_REWARD_FACTOR + boost * remaining // durationget_base_reward_per_increment is modified to use this factor in place of the BASE_REWARD_FACTOR constant; this is the sole change to the existing rewards machinery, and it reverts to today’s behaviour once the transition completes:
def get_base_reward_per_increment(state: BeaconState) -> Gwei:
active = get_total_active_balance(state)
factor = get_base_reward_factor(get_current_epoch(state))
return Gwei(EFFECTIVE_BALANCE_INCREMENT * factor // integer_squareroot(active))Beacon chain state transition
A new step, process_issuance_burn, is added to process_epoch immediately after process_rewards_and_penalties and before process_effective_balance_updates. Running it there means effective balances still hold the epoch’s values, so the proposer burn below charges exactly the proposers that were selected during the epoch. Each duty is charged where its issuance is paid: the attestation and proposer burns in this new epoch step, the sync committee burn in process_sync_aggregate.
- Attestation burn: a burn of \(b\) times the attestation reward a perfect attester earned, applied to every active validator;
- Proposer burn: a burn of \(b\) times an equal share of the epoch’s proposer issuance, charged to each of the 32 proposers;
- Sync committee burn: a burn of \(b\) times the sync committee reward for each block, charged to each of the 512 sync committee members. Because sync committee rewards are paid per block rather than per epoch, this deduction is applied in
process_sync_aggregaterather than in the epoch step.
Each basis is sized on the issuance the duty actually paid, not on what it would have paid under perfect network conditions: the attestation and proposer bases scale with the participating balance, and the sync committee burn is levied only when a block exists to pay the reward it offsets. Every one of those factors is a network-wide aggregate, so no deduction depends on the behaviour of the validator paying it; see the Rationale.
Splitting the burn by duty, rather than applying a single uniform per-validator deduction, keeps the variance between validators low despite the rare duties of proposal and sync committee participation. Every deduction reads base from get_base_reward_per_increment, so during the transition all three scale with the elevated effective factor automatically, and no further change is needed. Only the attestation pass is suspended during an inactivity leak, for the reasons given in the Rationale.
def process_issuance_burn(state: BeaconState) -> None:
# Clamping sqrt_active to sqrt_sat keeps the burn fraction at or below 1.
sqrt_sat = integer_squareroot(SATURATION_BALANCE)
sqrt_active = min(integer_squareroot(get_total_active_balance(state)), sqrt_sat)
increment = EFFECTIVE_BALANCE_INCREMENT
base = get_base_reward_per_increment(state)
epoch = get_current_epoch(state)
n_total = get_total_active_balance(state) // increment
attest_weight = TIMELY_SOURCE_WEIGHT + TIMELY_TARGET_WEIGHT + TIMELY_HEAD_WEIGHT
# Attestation and proposer issuance are both paid in proportion to the
# balance that attested, so both burns are sized on that same quantity.
# process_rewards_and_penalties settles the previous epoch's attestations.
participation = get_attestation_participation(state, get_previous_epoch(state))
# 1. Attestation burn — every active validator. Suspended during an
# inactivity leak, when attestation rewards are withheld entirely.
if not is_in_inactivity_leak(state):
for index in get_active_validator_indices(state, epoch):
n = state.validators[index].effective_balance // increment
attest_reward = Gwei(
n * base * participation // (n_total * WEIGHT_DENOMINATOR)
)
burn = get_issuance_burn(attest_reward, sqrt_active, sqrt_sat)
decrease_balance(state, index, burn)
# 2. Proposer burn — the 32 proposers of the epoch. Proposer rewards are
# paid during a leak, so this pass is never suspended.
ideal_proposer_reward = Gwei(
base * PROPOSER_WEIGHT * participation
// WEIGHT_DENOMINATOR // attest_weight // SLOTS_PER_EPOCH
)
proposer_burn = get_issuance_burn(
ideal_proposer_reward, sqrt_active, sqrt_sat
)
start_slot = compute_start_slot_at_epoch(epoch)
for slot in range(start_slot, start_slot + SLOTS_PER_EPOCH):
proposer = get_beacon_proposer_index_at_slot(state, Slot(slot))
decrease_balance(state, proposer, proposer_burn)
decrease_balance(state, proposer, proposer_burn)The sync committee burn is applied in block processing instead, because sync committee rewards are paid per block. process_sync_aggregate is modified to deduct \(b\) times participant_reward from every committee member, alongside the rewards and penalties it already applies:
def process_sync_aggregate(state: BeaconState, sync_aggregate: SyncAggregate) -> None:
# ... signature verification and reward computation unchanged, yielding
# participant_reward, proposer_reward and committee_indices ...
# Burn the tapered fraction of the sync committee issuance for this block.
sqrt_sat = integer_squareroot(SATURATION_BALANCE)
sqrt_active = min(integer_squareroot(get_total_active_balance(state)), sqrt_sat)
sync_burn = get_issuance_burn(participant_reward, sqrt_active, sqrt_sat)
# Apply participant and proposer rewards
for participant_index, participation_bit in zip(
committee_indices, sync_aggregate.sync_committee_bits
):
if participation_bit:
increase_balance(state, participant_index, participant_reward)
increase_balance(state, proposer_index, proposer_reward)
else:
decrease_balance(state, participant_index, participant_reward)
decrease_balance(state, participant_index, sync_burn)The deduction sits outside the participation branch, so it is charged to every committee member whether or not it participated: were only participants charged, a member could avoid the burn by abstaining, and the balance difference between participating and not would fall from twice participant_reward to \((2-b)\) times it. The proposer’s share of the sync reward is deliberately left alone, since a deduction contingent on having produced a block would weaken the incentive to propose; it remains covered by the proposer pass above.
The dominant new cost is one O(1)-per-validator deduction (the attestation burn) — foldable into the existing rewards/penalties pass — plus a fixed pass over the 32 proposers. The sync committee deduction adds one balance update per member to a loop process_sync_aggregate already runs.
Rationale
Why a burn
An alternative route to lower issuance would be to redesign the reward curve itself, and proposals for this exist.2 This EIP nonetheless prefers a burn, for the following reasons:
- A single parameter, with a natural value. Reward curves engineered to exhibit several desirable properties at once (a cap on total issuance, a yield floor, a target ratio) tend to introduce several new parameters, each of which must be set and defended. The burn introduces exactly one,
SATURATION_BALANCE, and its value has a natural focal point: half the ETH supply. (Temporary parameters are introduced to specify the transition, butSATURATION_BALANCEis the only permanently operative parameter this proposal introduces.) - A market-determined yield. To avoid introducing a vulnerability to griefing attacks, rewards and penalties must remain matched. With matched incentives, a performing validator always earns a positive yield, so any reshaped reward curve without burn still imposes a floor on the yield, and stake growth stops only if the market’s risk premium happens to sit above that floor. A deduction removes the floor: the staking ratio settles at the point where the yield meets the premium stakers demand, so the equilibrium yield is set by the market rather than by the shape of the curve.
- Micro-incentives at full strength. Reaching a low yield by scaling the reward and penalty schedule down weakens the per-duty incentives for correct and timely participation. With substantial MEV (here including priority fees) available, consensus rewards and penalties must remain large relative to the external incentives to misbehave (through block-timing games or reorgs, for example), or chain stability is put at risk. The burn leaves the entire schedule at its current magnitude and nets macro yield off afterwards.
- Credible neutrality. Any redirection of the deducted ETH, whether to other validators, a treasury, or any other recipient, would leave total issuance unchanged and so defeat the proposal’s monetary purpose, while creating a new claimant whose incentives must be analysed and whose share can be lobbied over. Destroying it, as established by the base-fee burn of EIP-1559,3 is the neutral alternative: the value removed accrues pro rata to all ETH holders.
Why a 50% saturation ratio
The saturation ratio is not a target. It marks where the issuance incentive is fully neutralised, with the market settling below it, wherever net yield meets the premium stakers demand. Several of the risks set out above are qualitatively different once a majority of ETH is staked: a rescue coalition drawn from stakers is then a majority of the economy by construction, and a fork opposing a captured validator set has no larger constituency left to appeal to. The same threshold governs ETH’s monetary role. Once most ETH is staked, the derivatives representing it are drawn from a larger pool than the unstaked ETH they compete with, and liquidity and collateral acceptance tend to bestow moneyness onthe larger pool.
Furthermore, above half there is no next natural stopping place. Nothing distinguishes 60% from 70%, or 70% from 80%. Half the supply is the only value in the range defensible without appeal to preference, which matters for a constant that will come under pressure to move. The choice is bounded from below too. With today’s ratio near 33%, a saturation point at or beneath it would clamp the burn at 100% on activation and take net consensus yield to zero for every validator, forcing stake out rather than curbing its growth.
Why the burn uses idealised rewards
The same concern that keeps the reward schedule at full magnitude governs how each deduction is sized: were it to track the reward actually earned, every duty’s marginal payoff would be multiplied by \((1-b)\). It is sized instead from what perfect performance would have earned — perfect with respect to the validator’s own conduct, not the network’s, since consensus rewards already fall with participation and with missed blocks. Sizing on the headline figure would over-collect whenever the network fell short, and once the shortfall exceeded \(b\) would push a faultless validator into a net loss. Each basis is therefore scaled to the issuance its duty actually paid, by aggregates no individual validator can move; during an inactivity leak, where attestation rewards are withheld outright, the attestation deduction is suspended entirely.
Why the burn is split by duty
Applying \(b\) as a single, uniform per-validator deduction each epoch would be simpler to specify, but every validator only proposes and joins a sync committee rarely. A uniform deduction sized to also cover those infrequent, larger rewards would exceed a typical epoch’s attestation reward as the burn fraction grows, leaving even a perfectly performing validator with a negative balance change in every epoch spent waiting for a rare duty assignment. Allocating the deduction by assigned duty avoids this: a validator that performs its attestation duties is never pushed into a negative balance change merely for lack of a proposal or sync-committee assignment, and each deduction stays proportionate to the reward on offer at each opportunity.4
Deriving the burn fraction
Expressed as a function of the staking ratio \(f = D/S\) (with \(S\) the total ETH supply), the current consensus-layer yield is
\[y(f) = \frac{B\,E}{\sqrt{f\,S}},\]
with BASE_REWARD_FACTOR \(B\) and epochs per year \(E\). Issuance is the yield paid on the staked fraction, \(i(f) = B\,E\sqrt{f/S}\). The burn fraction derived below is independent of \(B\): it scales the reward whatever its magnitude. The permanent policy uses today’s \(B = 64\); during the transition \(B\) is temporarily elevated, which lifts \(y(f)\) uniformly without changing \(b(f)\).
The goal is to subtract from the yield a term that is zero at \(f = 0\) and grows linearly to cancel the yield entirely at a saturation ratio \(f_\text{sat}\), so that the net yield reaches zero there:
\[\tilde y(f) = \begin{cases} y(f) - \dfrac{f}{f_\text{sat}}\,y(f_\text{sat}) & f \le f_\text{sat} \\ 0 & f > f_\text{sat} \end{cases}\]
BASE_REWARD_FACTOR at today’s value of 64. Under the tapered curve the burn exactly cancels issuance at the 50% saturation ratio.
Writing \(\tilde y(f) = (1 - b(f))\,y(f)\) and solving for the burn fraction \(b(f)\) that reproduces this linear taper gives
\[b(f) = \left(\frac{f}{f_\text{sat}}\right)^{3/2}.\]
The exponent of \(3/2\) rather than \(1\) follows from the reward curve’s \(f^{-1/2}\) shape: the absolute deduction needed is linear in \(f\), but expressed as a fraction of a reward that itself scales as \(f^{-1/2}\), it picks up an extra half power. With \(f_\text{sat} = 50\%\), the resulting issuance curve
\[\tilde i(f) = \begin{cases} f\,\tilde y(f) & f \le f_\text{sat} \\ 0 & f > f_\text{sat} \end{cases}\]
no longer rises monotonically with \(f\): it rises, peaks at \(f^* = 2^{-7/3} \approx 19.8\%\), and is fully cancelled by the burn at \(f_\text{sat}\).
BASE_REWARD_FACTOR at today’s value of 64. The tapered curve peaks at \(f^* = 2^{-7/3} \approx 19.8\%\) and is fully cancelled by the burn at \(f = \tfrac{1}{2}\).
The effect on large operators
An operator’s income from consensus issuance is its share of the stake multiplied by the total amount issued. Under the current curve both factors move in its favour as it grows: its share rises, and because issuance keeps rising with the staking ratio, so does the pot being shared. There is no size, and no staking ratio, at which adding another validator fails to increase its income.
The tapered burn changes this. Issuance now peaks at a staking ratio of roughly 20% and declines beyond it, so an operator that keeps growing is claiming a larger share of a shrinking pot, and past some point the second effect dominates the first. The point at which an operator’s income reduces from increased scale comes sooner the larger the operator already is. An operator holding half the stake finds that growth stops paying once about 31% of the ETH supply is staked. Every operator has such a point somewhere below the 50% saturation staking ratio, but the smaller it is, the closer that point sits to saturation.
It should be noted that MEV is unaffected by the burn and accrues in proportion to an operator’s share whatever the staking ratio, so it always rewards growth and will act to increase the staking ratio at which a large operator is no longer rewarded for further growth.
The transition period
Imposed in full at the fork, the burn would cut the net yield at today’s staking ratio (\(f \approx 33\%\)) by more than half, from about 2.6% to 1.2% — enough to prompt a substantial exit of stake on activation. TRANSITION_BASE_REWARD_FACTOR is set to 128 because doubling the factor lifts the net yield curve to cross the current one at \(f \approx 31\%\), close to today’s ratio: stakers begin at a yield near what they receive now, and the reduction arrives gradually rather than at the fork.
The 18-month figure is measured from activation, but the window for participants to adjust is longer. A hard fork is generally scheduled for inclusion (SFI) six months or more before it goes live, and this proposal is fully specified and predictable from that moment. Adding that lead time gives ecosystem participants on the order of two years, from the change becoming certain to yields reaching their permanent level, in which to respond.
The transition defers none of the security benefit: the burn fraction reaches 100% at the saturation balance whatever the base reward factor, so from the first epoch after activation issuance no longer rewards growth in the staking ratio beyond 50%.
Issuance and MEV
Lowering issuance raises the question about the role of MEV, since if consensus rewards reduce, MEV becomes a larger share of a validator’s return. Block proposal timing games are the most pernicious distortions caused by MEV, but these are unaffected by this proposal, since the microincentive levels are preserved. By contrast, reducing issuance by reshaping the reward curve would instead shrink the proposer reward and increase the significance of MEV on a per-block basis.
Proposers received about 72,000 ETH through MEV-Boost in the year to 31 July 2026,5 a return of roughly 0.2% on the ETH staked over that period. Consensus issuance therefore accounts for about 94% of the staking yield today. Under this proposal, if the staking ratio were to settle at 40%, issuance would still account for around 82% of the yield. So the equilibrium staking ratio remains set predominantly by the issuance curve and the risk premium.
Nonetheless, proposals which would address MEV (such as MEV burn) remain worth pursuing, and compose with this one: removing MEV from proposers would lower total staking yield, and with it the equilibrium staking ratio.
Backwards Compatibility
This EIP introduces a backwards-incompatible change to the consensus-layer state transition and must be accompanied by a hard fork. No changes are required to the execution layer or to existing on-chain contracts.
Test Cases
Test vectors are not yet included in this draft. On progressing toward implementation, test cases would be added to the epoch_processing and block_processing test suites in the consensus-specs repository,6 following the existing formats for process_rewards_and_penalties and process_sync_aggregate, covering: zero active balance below saturation, active balance at and above SATURATION_BALANCE, the boundary behaviour of get_issuance_burn at sqrt_active == sqrt_sat, the suspension of the attestation pass alone while is_in_inactivity_leak(state) holds (and its resumption on the first finalising epoch thereafter), get_attestation_participation at full and at partial participation, the equivalence of the attestation and proposer bases with their unscaled forms at full participation, the sync committee deduction falling on participating and non-participating members alike, and the value of get_base_reward_factor at the transition boundaries (TRANSITION_START_EPOCH, its midpoint, and TRANSITION_START_EPOCH + TRANSITION_DURATION_EPOCHS).
Reference Implementation
The Python in the Specification section constitutes the reference implementation, in the same style used throughout the beacon chain consensus specification. An implemtation of this EIP has been completed in the Prysm consensus layer client.
Security Considerations
Incentive compatibility. The burn fraction \(b(f)\) is a deterministic, publicly computable function of total active balance, and applies identically to every validator. No validator or coalition can shift a larger share onto another, nor reduce its own, so it introduces no new griefing or discrimination vector. Because each deduction is computed from the idealised duty reward rather than the reward actually earned, it is independent of the validator’s behaviour within the epoch, leaving every marginal performance incentive intact; during the transition the elevated base reward factor scales the reward and penalty schedule up together, preserving the balance between them, and once the transition completes the schedule is exactly as it is today. And because \(b(f) \le 1\) for all \(f\) (clamped via sqrt_active = min(..., sqrt_sat)), no deduction ever exceeds the reward it is derived from. Because each basis is scaled to the issuance the duty actually paid rather than to a headline figure the network may not have reached, a validator performing its duties correctly retains a non-negative net reward for the epoch — specifically \((1-b)\) times what it earned — at any level of participation or block production, and the burn cannot by itself drive aggregate net issuance negative. The attestation pass is suspended outright during an inactivity leak, when attestation rewards are withheld entirely, so the guarantee holds in that case too.
Cost of downtime. Because the deduction is independent of behaviour, an offline validator pays it alongside the usual penalties. The marginal incentive to be online is unaffected (the balance difference between performing a duty and missing it is exactly what it is today), so the cost of an outage relative to remaining online is no greater in ETH than it is today; what rises is that cost measured in days of net earnings. Since the penalty is unchanged while net earnings fall to \((1-b)\) of the idealised reward, the period needed to make good an outage grows by a factor of \((1 + b/p)/(1-b)\), where \(p \approx 0.74\) is the ratio of penalty to idealised reward: roughly 2.3× at a 25% staking ratio, and rising as the ratio approaches saturation.
Effect on economic security. This EIP deliberately results in a lower equilibrium quantity of stake than the current curve. In proof-of-stake with slashing, the cost of attack is set by the stock of slashable stake an attacker must acquire and forfeit, and at any staking ratio in the tens of percent that stock remains vast relative to any plausible attack reward. Nor does economic security increase monotonically with stake: as set out in the Motivation, beyond a certain level the accompanying concentration of stake and supply makes the network less secure, not more. To the extent the proposal protects ETH’s monetary premium, it also supports the real value of the stake securing the chain.
Computational cost. The additional per-epoch cost is one O(1) deduction per active validator (foldable into the existing rewards/penalties pass) plus a fixed-size pass over the 32 proposers, so this EIP does not introduce a new DoS surface. Per block, the sync committee deduction adds one balance update for each of the 512 members, within a loop process_sync_aggregate already performs.
Constant drift. As noted in the Specification, SATURATION_BALANCE is fixed at the fork and does not track live supply, so the effective saturation ratio will drift slowly over time. This drift changes only the location of the equilibrium point, not any safety property of the mechanism, and is not expected to be security-relevant on the timescale of a single fork’s lifetime.
Copyright
Copyright and related rights waived via CC0.
Footnotes
pa7x1, The Shape of Issuance Curves to Come. https://github.com/pa7x1/ethereum-issuance↩︎
Anders Elowsson, FAQ: Ethereum issuance reduction. https://ethresear.ch/t/faq-ethereum-issuance-reduction/19675↩︎
Anders Elowsson, Properties of Issuance Offsets and Increased Penalties under Low/Zero/Negative Issuance Policies. https://ethresear.ch/t/properties-of-issuance-offsets-and-increased-penalties-under-low-zero-negative-issuance-policies/25292↩︎
Based on data from Toni Wahrstätter’s, MEV-Boost Dashboard. https://mevboost.pics/↩︎