ethereum/consensus-specs

Features

• Proof-of-Stake Consensus - Defines the technical rules and state transition logic for the Ethereum proof-of-stake consensus layer.
• Consensus Specifications - Specifies the formal data structures and state transition rules for the chain coordinating validators.
• Fork Choice Rules - Implements the fork-choice rules used to determine the canonical chain head based on validator attestations.
• Consensus Verification - Provides reference tests to verify that the software implementation adheres to the formal consensus specifications.
• Effective Balance Adjustments - Implements the hysteresis-based logic for calculating validator effective balances to ensure network stability.
• Validator Balance Adjustments - Reduces validator balances and manages their removal from the registry upon detection of protocol offenses.
• Block Mining - Selects a parent block, creates a child block that satisfies state transitions, and signs it.
• Beacon Block Requesting - The project retrieves signed beacon blocks by range or root and resolves the correct version based on the fork epoch.
• Blockchain Genesis Initializations - Bootstraps the initial network state from a proof-of-work chain using deposit receipts to create the genesis state.
• Data Availability Sampling - Verifies specific data segments via sampling to reduce node load while ensuring blob availability.
• Data Availability Layers - Implements mechanisms to ensure blob data is available for independent verification before blocks are processed.
• Data Serialization - Converts complex data objects into a canonical bytestring representation based on defined schemas for consistent networking.
• Data Serialization Formats - Defines the formal standards for serialization and Merkle proof formats to ensure uniform encoding across all nodes.
• Execution Chain Synchronization - Updates the execution engine by reorganizing the payload chain to a new head and persisting finalized state.
• Fund Deposit and Withdrawal Workflows - Implements standardized procedures for moving funds into the staking contract via public keys and signatures.
• Light Client Synchronization - Establishes protocols for low-resource nodes to verify chain state via sync committees and finalized headers.
• Header Verifications - The project validates the authenticity of a light client header by checking the hash against a Merkle branch.
• Asset Deposits - Processes asset deposits into the beacon chain to activate validators or increase their balances.
• Withdrawal Credential Specification - Specifies the addresses used to constrain and authorize the withdrawal of staked funds by validators.
• Network Churn Control - Enforces per-epoch limits on validator activations and exits to maintain network stability.
• Staking and Slashing Mechanisms - Implements mechanisms to penalize malicious validator behavior by forfeiting their staked economic balance.
• Validator Lifecycle Management - Handles the full validator lifecycle, including staking deposits, reward calculations, and balance withdrawals.
• Validator Registries - The project assigns new deposits to inactive validator records with zero balance to limit list growth.
• Consensus Payload Validation - Verifies that execution payloads are correctly attested by a balance-weighted committee.
• Signed Provenance Attestations - Combines multiple attestations with similar data into a single message to reduce network load.
• Attestation Aggregation - Combines multiple network aggregates with identical data into a single on-chain attestation object.
• Validator Registries - The project stores and manages the registry of validators, including public keys, balances, and status.
• Validator Registry Churn Management - Calculates activation, exit, and consolidation limits to control the rate of changes in the validator registry.
• Activation Queues - The project handles the progression of validators from deposit to active status via a queue.
• Balance Consolidations - The project merges the balance of one active validator into another and manages the exit.
• Exit Epoch Calculations - The project triggers the exit process for validators, calculating the exit epoch based on churn limits.
• Validator Participation Management - Retrieves the committee index and slot assigned to a validator for a specific epoch.
• Activation Churn Management - Limits the number of validators activated per epoch to prevent excessive churn in the validator set.
• Attestation Gossip Validation - Implements validation logic to ensure attestations are attributed to the correct validator committees during network propagation.
• Blockchain Protocols - A detailed standard defining block production, validator duties, and fork-choice rules to ensure network agreement.
• Gossip Protocols - Propagates blocks and attestations across a peer-to-peer network using topic-based gossip routing.
• Blob Sidecar Validation - Verifies KZG proofs and inclusion indices for blob sidecars to ensure data availability before network propagation.
• Committee Message Verification - Validates the authenticity and timeliness of sync committee contributions used for light client synchronization.
• Message Filtering Rules - Implements specific rules for filtering and rejecting invalid P2P network messages to protect node resources.
• Message Signature Verification - Filters incoming network gossip by verifying signatures to maintain data consistency and prevent spam.
• P2P Network Specifications - Standardizes how nodes discover peers, negotiate versions, and gossip blocks and attestations across the network.
• Data Availability Verification - Validates that all required blobs and proofs are retrieved and verified before marking a block valid.
• Polynomial Commitments - Uses KZG-based polynomial commitments and evaluation proofs to verify blob data availability.
• Blob Sidecar Management - Bundles blobs with commitments and proofs into sidecars for distribution via the pubsub network.
• Object Deserialization - Reconstructs complex data objects from bytestrings while validating the input against strict schema constraints.
• Polynomial Evaluation Proofs - Generates cryptographic proofs for multiple polynomial evaluation points to support blob data verification.
• Committee Weight Estimations - Computes the expected total weight of validators assigned to a range of slots.
• Attestation Aggregations - Collects and aggregates payload timeliness attestations to be included in new blocks.
• Block Support Calculations - Determines the total effective balance of active validators who voted for a specific block.
• Block Weight Calculations - Computes a score for a block based on the effective balance of validators who attest to it.
• Blockchain Transaction Execution - Processes execution payloads within a block by verifying consistency and notifying the external execution engine.
• Consensus Attestations - Updates payload timeliness and data availability votes upon receiving consensus attestation messages.
• Fork Digest Computation - Generates unique identifiers for network forks by hashing base data with blob parameters.
• Consensus Execution Proofs - Produces BLS signatures for execution proofs using validator private keys to ensure block validity.
• Aggregate Signatures - Implements committee-based signature aggregation to reduce network overhead during block attestation.
• Fast Block Confirmations - Provides algorithms to identify the most likely canonical block to reduce finality latency based on safety and synchrony.
• Inclusion List Management - Processes and stores inclusion list data while detecting equivocation and tracking timeliness.
• Inclusion List Validations - Checks if an execution payload satisfies a list of required transactions to prevent censorship.
• Execution Payload Validation - Validates the signature and consistency of execution payloads against the current state and execution engine.
• Cryptographic Hash Computations - Generates cryptographic roots for data objects by recursively hashing serialized chunks.
• Signature Verification Tools - Verifies that block headers are attested to by a sufficient number of sync committee participants.
• Staking Withdrawals - The project handles full and partial withdrawals of balances to execution addresses based on withdrawability epochs.
• Withdrawal Threshold Configurations - The project processes automatic and partial withdrawals of balances based on credential prefixes and thresholds.
• Polynomial Commitment Verifications - Implements the verification of data cells against KZG commitments to ensure blob data availability.
• Polynomial Proof Verifications - Validates single and batch cryptographic proofs for polynomial evaluations to ensure data integrity.
• Block Header Validations - Uses historical accumulators to validate the sequence of block headers and transitions leading to a specific state.
• Block Ancestry Validations - Verifies that a block is a descendant of the most recent finalized checkpoint.
• Consensus State Transitions - Specifies how the network state evolves through forks and validator actions to maintain agreement.
• Beacon Block Processing - Validates received blocks against current state and finalized checkpoints before updating the local store.
• Beacon Block Propagation - Distributes signed blocks and validates them based on timing, signatures, and parent state.
• Binary Canonical Serialization - Implements SSZ serialization to ensure a canonical byte representation for consistent Merkle root calculations.
• Block Attestation Production - Creates and signs an attestation for an assigned slot and broadcasts it to the network.
• Consensus-Execution Layer Integration - Provides the integration that passes the parent beacon block root to the execution engine for consensus-layer data access.
• Chain Event Processing - Updates the fork choice store by handling new blocks, attestations, slashing events, and time ticks.
• Consensus State Tracking - Maintains a store of justified and finalized checkpoints and validator messages critical for the fork choice algorithm.
• Weight Management - Excludes invalidated blocks from the canonical chain and prevents weights from applying to ancestors in the fork choice process.
• State-Transition Execution - Provides the runtime logic to compute the subsequent beacon state and validator rewards during epoch transitions.
• Epoch State Transitions - Processes epoch-level transitions for justification, finalization, and validator committee rotations.
• Consensus Rule Validators - Verifies block validity by calculating the total effective balance of validators attesting to a specific head.
• Consensus Standard Definitions - Establishes the technical standards for block production and validation to ensure ledger agreement.
• Validator Lifecycle Tracking - Identifies whether a validator is active and determines its specific responsibilities during a given epoch.
• Validator Removals - The project executes voluntary and forced validator removals based on penalties or user requests.
• Availability Bitmaps - Communicates possessed data cells and requests missing ones using availability bitmaps for efficient synchronization.
• Balance Manager Registries - Implements a registry for payload builders, tracking their public keys, balances, and deposit signatures.
• Block-based State Synchronization - Retrieves missing blocks via slot ranges or root hashes to synchronize the local beacon state.
• Optimistic Importing - Allows faster synchronization by importing beacon blocks without verifying their execution payloads.
• Range-based Block Requesting - Retrieves lists of signed beacon blocks within specified slot ranges for network synchronization.
• Blockchain History Backfilling - Fetches ranges of beacon blocks along a root's ancestry to synchronize historical chain data.
• Builder Lifecycle Management - Handles the activation of payload builders and processes authorized exit requests.
• Canonical JSON Encodings - Implements canonical JSON encoding for schema-defined types to ensure consistent data representation across network nodes.
• Consensus Participation Rewards - Grants baseline rewards to attestations that contribute to chain justification.
• Blob-Based Throughput Scaling - Increases network throughput by incorporating shard blob transactions and commitments directly into blocks.
• Data Synchronization Checkpoints - Implements synchronization using anchor checkpoints to establish a trusted state without full execution verification.
• Checkpoint Validations - The project verifies that a provided checkpoint is recent enough to prevent takeover during sync.
• Availability Sampling - Selects and retrieves a subset of data columns at each slot to verify network data availability.
• Range-based Synchronization - Provides the ability to request and retrieve sequences of blob sidecars across specific slot ranges.
• Inactivity Penalties - Tracks inactivity scores and applies balance penalties to validators who fail to participate in checkpoints.
• Bootstrapping Packages - The project provides a bootstrap package containing block headers and sync committee data to allow light clients to start tracking the chain.
• Header Conversions - The project transforms a signed beacon block into a lightweight header with a corresponding Merkle proof.
• Light Client Data Exchange - Transmits finality updates and bootstrap data across the P2P network to synchronize light client state.
• State Store Initialization - The project sets up a new state store using a trusted block root and a bootstrap object.
• State Update Generation - The project generates updates containing attested headers and sync committee signatures to advance a light client's view of the chain.
• Subjectivity-Based Synchronizations - The project ensures a client syncs to a trusted checkpoint and treats failure as a critical error.
• Asset Withdrawals - Processes the periodic withdrawal of validator balances for both exited and active validators.
• Event Inclusion Proofs - Mandates the inclusion of specific transactions in a block through the use of signed inclusion lists.
• Penalty Parameterization - Calculates validator penalties using updated multipliers to adjust balance deductions over time.
• Slashing Calculations - Computes penalties for slashed validators and distributes the resulting rewards to proposers.
• Slashing Prevention - Validates signed messages to ensure validators do not produce conflicting attestations that would lead to slashing.
• Staking Reward Calculations - Computes base rewards and participation incentives based on effective balance and epoch participation flags.
• Validator Incentive Calculations - Computes micro-rewards and penalties based on participation, inclusion delay, and inactivity.
• Consensus Committee Assignments - Determines the specific slots when validators are assigned to the timeliness committee for block verification.
• Blob Data Propagation - Fetches blob data from local execution-layer clients and propagates it to the network as sidecars.
• Committee Subnet Coordination - Coordinates validator distribution into subcommittees and manages corresponding network topic subscriptions.
• Subnet Stability Management - Manages subnet membership and joins using random epoch offsets to maintain network stability.
• Peer Handshake Protocols - The project exchanges node status and finalized checkpoints to verify chain compatibility before establishing a session.
• Light Client Bootstrapping - The project retrieves the initial bootstrap structure for a block root to allow synchronization.
• Execution Payload Delivery - Broadcasts signed envelopes containing the execution payload once a proposer accepts a bid.
• Optimistic Header Propagation - Broadcasts and validates the latest optimistic header to provide a fast-track view of the chain.
• Payload Bid Propagation - Broadcasts signed bids from builders to proposers while validating activity and gas limits.
• Payload Bid Submission - Creates and broadcasts signed commitments to provide an execution payload for a specific slot.
• State Update Requesting - The project retrieves the most recent finality or optimistic updates from a peer to sync the store.
• Aggregate Gossip Validation - Verifies the data index, committee membership, and signatures of aggregated attestations to determine if they should be gossiped.
• Sidecar Gossip Validation - Checks the semantic validity and authenticity of partial data column sidecars during P2P propagation.
• Sidecar Distribution - Packages block blobs into vertical sidecars and distributes them to targeted network subnets.
• Sidecar Synchronization - Retrieves missing data column sidecars from peers using specific slot range requests.
• Peer Discovery - Implements mechanisms for locating other nodes in the decentralized network using discovery protocols and node records.
• Peer Metadata Management - Exchanges node capabilities and fork digests to determine peering compatibility between nodes.
• Peer Metadata Querying - Retrieves peer local metadata, including subscriptions to attestation and committee subnets.
• Bidding and Payment Coordination - Implements the coordination logic for the proposer-builder separation process, managing payload bids and builder payments.
• Finality Update Propagation - Broadcasts and validates the latest finalized header to light clients via a pubsub topic.
• Finality Update Provisioning - The project produces specialized updates that notify light clients when a block has been finalized on the network.
• Execution Payload Envelope Retrieval - Retrieves specific or range-based execution payload envelopes from peers to recover missing data.
• Secure Communication Channels - The project encrypts communication and identifies peers using a secure channel handshake.
• Subnet Assignment Logic - Implements the logic for assigning and advertising specific attestation subnets based on node identity and epoch.
• Committee Message Routing - Computes subnet IDs assigned to validators to target gossip broadcasts for committee messages.
• Sync Committee Management - Manages the selection of sync committee validators and verifies aggregated signatures for light client synchronization.
• Commitment Inclusion Proofs - Ensures that KZG commitments in a sidecar are correctly included in a beacon block using Merkle branch verification.
• Sidecar Inclusion Verification - Validates that a blob sidecar is linked to a block via Merkle proofs and polynomial commitments.
• Sidecar Semantic Validation - Validates data column sidecars by checking index ranges, blob limits, and commitment consistency.
• Erasure Coding Matrices - Transforms raw blobs into a structured matrix of cells and proofs using erasure coding for data redundancy.
• Erasure Coding Reconstruction - Recovers the full data matrix from a partial set of columns once a specific threshold is met.
• Polynomial Arithmetic - Provides fundamental arithmetic operations on polynomials in coefficient form used for cryptographic proofs.
• Polynomial Data Recovery - Reconstructs all cells and proofs of a blob from partial cells using polynomial recovery techniques.
• Cryptographic Execution Proofs - Coordinates the request and signing of cryptographic execution proofs by monitoring payload events.
• Builder Deposit Processing - Processes pending deposits to register new payload builders or top up their balances.
• Equivocation Tracking - Synchronizes lists of equivocating validator indices to maintain network security and integrity.
• Root-based Retrieval - Requests specific blob sidecars using block roots and indices to recover missing data.
• Merkle Tree Utilities - Uses Merkle tree structures to validate the integrity of deposits by checking branches against the deposit root.
• Multi-Proof Verifiers - Implements Merkle multiproof verification to authenticate multiple data nodes using a subset of auxiliary nodes.
• Path-to-Index Mappings - Provides mechanisms to translate object paths into generalized indices for Merkle tree positioning.
• Proof Generation - Generates Merkle proofs for objects at specific indices within SSZ structures.
• Payload Bid Verification - Validates signed bids from builders, ensuring signature authenticity and alignment with fork-choice.
• Public Key Aggregation - Combines multiple public keys into a single aggregate key using elliptic curve addition.
• Subjectivity Window Verifications - Checks if the current epoch falls within the allowed window relative to a trusted checkpoint.
• Weak Subjectivity Windows - Computes the time window required for a new node to trust a state checkpoint.
• Batch KZG Proof Verification - Confirms that data cells in a sidecar match their corresponding commitments and proofs using batch verification.
• Consensus Proofs - Initiates the creation of consensus proofs when new payloads or fork-choice changes occur.
• Header Conversions - The project transforms signed blocks into condensed header formats for light client verification.
• Merge Transition Validation - Verifies that a block transitioning from proof-of-work to proof-of-stake links to a valid terminal block.
• Root-based Block Requesting - Retrieves specific signed beacon blocks based on their unique cryptographic root hashes.
• Consensus State Upgrades - Handles the transition of the system state to new protocol versions by updating fork variables.
• Deterministic Validator Lookaheads - Implements deterministic calculations for predicting future validator indices to support block production lookahead.
• Execution Payload Generation - Constructs execution payloads by aggregating state, head information, and expected withdrawals for processing.
• Execution Payload Management - Fetches the most recent version of a built execution payload using specific identifiers for inclusion in a block.
• Block Validation Tracking - Tracks the validation status of imported blocks and updates descendants based on engine responses.
• Execution Block Mapping - Maps execution block hashes to specific positions within the beacon block body for consistent data tracking.
• Protocol Versioning - Identifies the active consensus version for specific epochs to ensure the correct protocol rules are applied.
• Consensus State Verifications - The project implements a protocol allowing participants to sync and validate the chain without full history.
• Subject Validation - Calculates the trust window for checkpoints by analyzing validator set changes and balance limits.
• Payload Build Initiation - Triggers block payload construction using timestamps and fee recipients to produce a new block.
• Payload Generation Coordination - Triggers execution payload creation by notifying engines of the current fork-choice head.
• Payload Preparation - Constructs execution payload attributes and initiates the build process based on the parent payload.
• Payload Timeliness Assessment - Determines if an execution payload is timely by checking local availability and counting validator votes.
• Random Sampling - Uses seeded random sampling to select validators for proposers and committees based on their effective balance.
• Validator Exit Processing - The project validates and executes requests from validators to leave the network using a fixed fork version.
• Safe Block Identification - Retrieves the block hash of the payload included in the most recent confirmed block.
• Stateless Payload Validation - Verifies execution payloads using proofs and signatures without requiring the full execution state.
• Timeliness Attestation Generation - Creates and signs messages indicating if a block's payload and blob data were available.
• Transaction Inclusion Lists - Implements the processing and timeliness verification of signed inclusion lists to ensure required transactions are tracked.
• Parallel Client Testing - Executes reference tests across different client implementations to verify consistent behavior and standard adherence.
• Builder Item Managers - Manages the full lifecycle of block builders, including registration deposits and exit processing.
• Builder Registration - Registers payload builders on the beacon chain by processing validated deposit requests.
• Execution Request Processing - Parses and validates bytes from the execution engine to extract deposit, withdrawal, and consolidation requests.
• Execution - Deserializes and categorizes execution requests, including builder deposits and exits, from raw bytes.

Star-Verlauf