Shared State Consensus

The core principle where all honest nodes deterministically execute the same sequence of transactions, transitioning from an initial state (S0) to a final, agreed-upon state (Sn). This ensures every node's ledger is an identical copy, providing consistency and deterministic finality.

The underlying communication primitive that guarantees all nodes receive the same set of transactions in the same total order. It ensures two key properties:

• Validity: If a correct node broadcasts a transaction, all correct nodes eventually deliver it.
• Agreement: If one correct node delivers a transaction, all correct nodes eventually deliver it. This prevents forks and double-spending.

Protocols are classified by the types of failures they can withstand while maintaining safety (no conflicting states) and liveness (progress). Key models include:

• Crash Fault Tolerance (CFT): Tolerates nodes that stop responding (e.g., Raft, Paxos).
• Byzantine Fault Tolerance (BFT): Tolerates arbitrarily malicious nodes (e.g., PBFT, Tendermint).
• Nakamoto Consensus: Tolerates Byzantine faults in open, permissionless settings using Proof-of-Work.

Mechanisms layered atop probabilistic consensus (like Nakamoto) to provide absolute finality. A finality gadget allows a separate committee of validators to periodically cast votes, creating cryptographic certificates that irreversibly finalize a block. This hybrid approach, used in Ethereum's Casper FFG, combines the security of BFT finality with the decentralization of proof-of-stake.

A key architectural distinction in how consensus is achieved.

• Leader-Based (e.g., PBFT, HotStuff): A designated proposer or leader creates a block proposal, which is then voted on by validators. This is efficient but can create bottlenecks.
• Leaderless (e.g., DAG-based protocols, Avalanche): Nodes propose and vote on multiple blocks concurrently, often using a Directed Acyclic Graph (DAG) structure. This enables higher throughput and parallel processing.

A critical recovery mechanism in leader-based BFT protocols. If the current leader fails or acts maliciously, halting progress, a view change protocol is triggered. Validators vote to demote the faulty leader and elect a new one, ensuring the network maintains liveness and continues to produce blocks despite adversarial conditions.

A 51% attack occurs when a single entity or coalition gains control of the majority of the network's consensus power (e.g., hash rate, stake). This allows them to:

• Censor transactions by excluding them from blocks.
• Double-spend by reorganizing the blockchain.
• Halt block production to freeze the network. This is a fundamental vulnerability in Proof-of-Work and Proof-of-Stake systems, where economic or computational dominance can compromise security.

A long-range attack targets Proof-of-Stake (PoS) systems where an attacker acquires old, compromised validator keys to rewrite history from a point far in the past. Defenses include:

• Checkpointing: Periodically finalizing blocks to create immutable anchors.
• Weak Subjectivity: Requiring new nodes to trust a recent, valid state snapshot.
• Slashing for equivocation: Penalizing validators that sign conflicting blocks, even retroactively.

Shared state consensus must handle network partitions (split-brain scenarios) where the network fragments. The challenge is to maintain safety (no conflicting states) and liveness (progress) during and after the partition. Protocols like Raft prioritize safety, halting during partitions, while Nakamoto Consensus (Bitcoin) prioritizes liveness, allowing forks that are later resolved by the longest chain rule, creating temporary uncertainty.

The tendency for consensus participation to centralize around a few large entities (e.g., mining pools, staking providers) creates systemic risks:

• Collusion: Reduced number of parties needed to coordinate a 51% attack.
• Censorship: Centralized points can be coerced by regulators.
• Single points of failure: Software bugs or infrastructure outages in major validators can destabilize the network. This is a persistent challenge for both PoW (pool centralization) and PoS (wealth concentration).

In PoS, the Nothing-at-Stake problem describes a rational validator's incentive to vote on multiple blockchain forks during a conflict, as it costs nothing. This undermines consensus finality. It is solved by slashing conditions that financially penalize (slash) a validator's stake for provably malicious behavior like equivocation. The system's security then depends on the economic value of the total slashable stake.

This is the fundamental trade-off in distributed systems, formalized by the CAP theorem. In blockchain consensus:

• Safety guarantees all honest nodes agree on the same, valid state (no forks).
• Liveness guarantees the network eventually produces new blocks and processes transactions. Under a network partition, a protocol cannot guarantee both. Classical BFT (e.g., PBFT) sacrifices liveness for safety. Nakamoto Consensus sacrifices immediate safety (allowing temporary forks) for liveness.

The deterministic rule set that defines how the blockchain's shared state changes when a new block of transactions is applied. It is the core logic executed by every node. For example, in Ethereum, this function deducts balances, runs smart contract code, and updates storage. Consensus ensures all nodes apply the same function to the same inputs, guaranteeing state consistency across the network.

The guarantee that a confirmed transaction or block is permanently settled and cannot be altered or reverted. It is a critical property for shared state consensus. Mechanisms differ:

• Probabilistic Finality (e.g., Bitcoin PoW): Confidence increases with more blocks on top.
• Absolute Finality (e.g., Tendermint BFT): A block is finalized after a supermajority of validators votes for it. Finality is essential for applications requiring strong settlement assurances, like financial transfers.

The specific group of nodes authorized to participate in the consensus protocol to propose and attest to new blocks. In Proof of Stake, this set is determined by stakeholders who have bonded tokens. The security of the shared state depends on the economic honesty and decentralization of this set. Changes to the validator set (slashing, adding new validators) are themselves state changes that must be agreed upon via consensus.

The algorithm nodes use to select the canonical chain when multiple valid chains (forks) exist. It is the decision logic that resolves conflicts and ensures all nodes converge on the same history. Common rules include:

• Longest Chain Rule: Used in Nakamoto Consensus (Bitcoin).
• GHOST / LMD-GHOST: Used in Ethereum to account for uncle blocks.
• Heaviest Subtree: Used in protocols like Avalanche. This rule is executed locally by each node but leads to global agreement on the shared state.