EIP-7657 Sync committee slashing conditions (Sync committee slashings)

No call decision · Consensus & staking · EIP status Stagnant · created 2024-03-21

Newly defines rules for slashing (revoking eligibility of) sync committee validators used for light client sync when they engage in malicious behavior such as signing fake block roots.

Why it is needed

Ethereum's light client sync protocol lets applications such as wallets, new beacon nodes, and trust-minimized bridges confirm the latest state without downloading the full chain. This verification relies on trusting the signatures of a 512-member sync committee, but currently there is no rule to punish a sync committee majority that is bribed into signing a fake (non-canonical) finalized header. As a result, an attacker who merely pays the bribery cost can trick light clients into believing an incorrect checkpoint, which can be used to drain bridge funds or manipulate token distribution. Without economic punishment for bribery, the light client protocol was only safe for small-value uses.

What changes

Today

After EIP-7657

Who is affected

In depth

Three slashing conditions

process_sync_committee_slashing treats three cases as subject to slashing. First, signing different attested_headers at the same slot. Second, within the same sync committee period, where both attested_header and finalized_header belong to that period, finalizing different next_sync_committees. Third, signing a finalized_header that, based on recent_finalized_block_root, does not match the actual finalized history (a linear chain). Simply signing an alternative but internally consistent history is not subject to slashing; only 'non-linear' signatures, where two different chains are each signed once without internal contradiction, are punished.

Structure of the evidence container

SyncCommitteeSlashingEvidence consists of the attested_header and the next_sync_committee contained in its state (plus its merkle path), the finalized_header (plus finality_branch), the sync_aggregate and sync_committee_pubkeys representing the bitmap and public key list of participants in the signature, the signature_slot at which the signature was made, and actual_finalized_block_root and actual_finalized_branch, the actual finalized block root based on recent_finalized_block_root and its merkle path. SyncCommitteeSlashing contains two such pieces of evidence (evidence_1, evidence_2), a list of validator indices subject to slashing, and the reference recent_finalized_block_root and recent_finalized_slot.

Only the current and previous period are subject to punishment

evidence_1_attested_period must be at most 1 period greater than evidence_2_attested_period. In other words, only conflicts between the current and immediately preceding sync committee periods are subject to slashing; conflicts with older periods are not considered. This is because the sync committee sometimes signs blocks from the previous period at the start of a new period, and it also leaves a path for a validator who was bribed and synced to a non-canonical checkpoint to honestly participate again in a later period.

Limits on the value that can be protected

Even with slashing, this mechanism alone is not sufficient to protect value exceeding SYNC_COMMITTEE_SIZE (512) x MAX_EFFECTIVE_BALANCE (32 ETH) = 16384 ETH on mainnet. The source states that such larger-scale uses may require combining with existing approaches like multisig, or requiring additional collateral to be staked in order to be eligible to submit updates. It also explicitly notes that slashing, in any mechanism, can only be applied after the fact, once an attack has already occurred.

Evidence verification logic

is_valid_sync_committee_slashing_evidence checks that the number of participants in sync_aggregate is at least MIN_SYNC_COMMITTEE_PARTICIPANTS, verifies via finality_branch that finalized_header matches the finalized checkpoint in the attested_header's state, and verifies via next_sync_committee_branch with a merkle proof that next_sync_committee is actually the value stored in the attested_header's state. It also checks via actual_finalized_branch, depending on distance, through either state.block_roots or historical_roots, whether actual_finalized_block_root matches the block root at the position of finalized_header.slot based on recent_finalized_block_root, and finally verifies the signature itself using BLS FastAggregateVerify against the participating public keys.

Required follow-up infrastructure

This EIP introduces new consensus validation rules and therefore requires a hard fork. Once the consensus rules are in place, additional supporting infrastructure is needed separately, including slashing protection DB updates (so honest validators are not slashed upon reorganization), validator client/remote signer APIs, a libp2p mesh for beacon nodes to exchange slashing evidence, a Slasher that constructs evidence, and a Beacon API for submitting and querying evidence.

Current status

This EIP is in Stagnant status, and its Test Cases, Reference Implementation, and Security Considerations sections all remain TBD (unwritten). The call records available contain no decision on whether this EIP will be included in a fork.

Original EIP · ← EIPs