Live prices are currently unavailable — the exchange feed could not be reached and no recent cached reading is held.

Research · Ethereum

Proof of stake and the beacon chain

Ethereum's consensus is a separate chain from its execution. The beacon chain keeps the validator registry, assigns duties in fixed slots and epochs, and decides which chain the network agrees on — while the execution layer keeps accounts and contracts.

Last reviewed 2026-09-21Source: Ethereum Consensus Specs (Phase 0) and ethereum.org proof-of-stake documentationMechanism descriptions only; no staking yields or participation figures are claimed.

The beacon chain

The beacon chain is Ethereum's consensus layer. It does not hold accounts or execute contracts; it holds the validator registry and the information needed to decide which chain is canonical. Its specification describes it as the store and manager of the validator registry, and it names attestations — validators voting on what they believe the head of the chain to be — as its primary source of load.

The separation is deliberate and it is what made the transition from proof of work possible without discarding the existing chain. The execution layer kept its accounts, its state and its transaction format; the consensus layer took over the job of choosing blocks. The two are joined by the engine API, through which the consensus client asks the execution client to validate and execute a block, and the execution client reports back the state root it computed. The execution and consensus layers page in this cluster covers that interface.

The security argument is different from proof of work's. A validator posts ether as collateral and is penalised by the protocol if it breaks the rules, rather than paying an external cost for every attempt. Ethereum's own documentation draws the parallel explicitly: this is similar to proof-of-work networks in which miners provide collateral in the form of hardware and hash power. The difference is that a miner's cost is sunk whether or not it attacks, while a validator's bond is forfeited only if it does.

Slots, epochs and committees

The time structure of Ethereum's consensus layer and what happens in each unit.
UnitLengthWhat happens in it
SlotTwelve secondsOne validator is selected to propose a block; every other assigned validator attests to the head it sees
EpochThirty-two slotsCommittees are reshuffled, rewards and penalties are settled, and checkpoints are justified and finalised
CommitteeA subset of the active validator setThe validators assigned to attest in a given slot; membership rotates each epoch
Sync committeeA rotating subset serving light clientsSigns the head of the chain so a light client can follow it without validating every attestation

Last reviewed 2026-09-21Source: Ethereum Consensus Specs, Phase 0Constants are specified in the consensus specs and change only through a consensus upgrade.

Time on the consensus layer is divided into slots of twelve seconds, grouped into epochs of thirty-two slots. In each slot one validator is chosen to propose a block, and a committee of validators is chosen to attest to the block they see. If the chosen proposer is offline, the slot passes without a block; the chain does not stall, it simply misses that slot. That is a meaningful difference from proof of work, where a missed block is not a concept because blocks are produced whenever a miner finds one.

Committees exist to keep the signature load manageable. If every validator attested to every block, the number of signatures per slot would grow with the size of the validator set and the chain would become unusable. Instead the active set is partitioned into committees, each committee attests in its assigned slot, and the attestations within a committee are aggregated into a single signature before they are included in a block. The committee size is a parameter chosen so that a committee is large enough that a randomly selected majority is implausible, and small enough that the aggregation is cheap.

The rotation of committee membership is what makes the assignment unpredictable. A validator cannot know far in advance which slot it will attest in, and the assignment is derived from the chain's own randomness, so an attacker cannot position itself to control a committee without controlling a large share of the whole set. The trade-off is that a validator must be online for its assigned slots or forgo the reward, which is why running a validator is an availability commitment rather than a passive one.

The validator lifecycle

A validator begins as a deposit. The deposit contract on the execution layer accepts ether and a set of validator keys, and the consensus layer observes the deposit and places the validator in a queue. The queue exists because the size of the active set is a security parameter: admitting validators without limit would let an attacker grow the set faster than the protocol's assumptions allow, and it would also change the issuance rate abruptly. The queue therefore admits validators at a rate the protocol controls.

Once activated, a validator is assigned duties each epoch and earns rewards for performing them. It can be penalised for being offline and slashed for breaking the two rules the specification defines as offences. It remains active until it signals an exit, at which point it enters an exit queue and then a withdrawal period before its balance becomes withdrawable. The exit queue is the mirror of the entry queue: it bounds how quickly the active set can shrink, which matters because a mass exit would reduce the stake securing the chain.

The lifecycle has a property that is easy to miss: a validator's balance is not fixed at its deposit. Rewards accrue to it and penalties are deducted from it while it is active, so the effective balance drifts. The protocol caps the effective balance used for weighting purposes, which means rewards above the cap accumulate as withdrawable balance rather than increasing the validator's weight. That design keeps a single large validator from having disproportionate influence relative to the same stake split across several validators.

Sources and references

The beacon chain structure, the slot and epoch timing, and the validator lifecycle described above are taken from Ethereum's consensus specification.

  • The beacon chain and its responsibilities. Ethereum Consensus Specs, Phase 0 — The Beacon Chain: the registry, the slot and epoch structure, and attestations as the primary source of load.
  • Validator duties and the honest-validator behaviour. Ethereum Consensus Specs, Phase 0 — Honest Validator: what a validator is expected to do in each slot and epoch.
  • Proof of stake explained for readers. ethereum.org, Proof-of-stake (PoS): the collateral model and how it differs from proof of work.
  • The deposit contract and validator keys. ethereum.org, Staking: how a validator is created and what it requires.