Ebb-and-Flow Protocols: Balancing Availability & Finality

• Ebb-and-flow protocols are distributed consensus mechanisms that use a dual-chain design to achieve dynamic availability and irreversible finality.
• They combine a fast, available chain for live chain growth with a finalized chain that remains safe during network asynchrony or partitions.
• The layered design employs quorum-based voting, checkpointing, and cryptographic slashing to ensure accountability and mitigate Byzantine faults.

Ebb-and-flow protocols constitute a class of distributed protocols designed to reconcile the trade-offs between dynamic availability and strong finality in the presence of Byzantine faults, message delays, validator churn, and network partitions. They operate by outputting two chains at all times: an “available” chain that is maximally live under synchrony and dynamic participation, and a finalized chain—always a prefix of the available chain—whose safety is guaranteed even under periods of asynchrony or partitions. This dual-ledger approach rigorously resolves the availability-finality dilemma identified in the CAP theorem, which states that blockchains cannot be simultaneously live under dynamic participation and safe under network partitions (Neu et al., 2020).

1. Model and Formal Definitions

Ebb-and-flow protocols are typically cast in a model with $n$ validators, up to $f < n/3$ Byzantine (adaptively corruptable), and honest validators subject to a sleepy/churn model, meaning they may go offline and later rejoin (D'Amato et al., 7 Jan 2026, D'Amato et al., 2024). Network synchrony is captured formally: before a (possibly unknown) Global Stabilization Time (GST), communication may be arbitrarily delayed; after GST, message delays are bounded by $\Delta$ and clocks are loosely synchronized.

Two chains are maintained:

• Available chain $C^{(D)}$: dynamically available and probabilistically safe under bounded asynchrony; live under synchrony and adaptive participation.
• Finalized chain $C^{(F)}$: guaranteed safe (no conflicting finalizations) under asynchrony and live after $\Delta$ beyond GST, with irrevocable finality. $C^{(F)}$ is always a prefix of $C^{(D)}$ (D'Amato et al., 7 Jan 2026, Neu et al., 2020).

Safety is defined as the property that no two honest validators ever output conflicting confirmed chains after the relevant start time, while liveness requires that every transaction in the pool at time $r$ is included in every active validator’s confirmed chain by $r + T_{\rm conf}$, for some $T_{\rm conf} = O(\kappa)$.

2. Protocol Construction: Layered Approach

Ebb-and-flow protocols are constructed by composition of:

• A dynamically available protocol (e.g., TOB-SVD (D'Amato et al., 7 Jan 2026), LMD-GHOST (D'Amato et al., 2024), Sleepy/Ouroboros-SnowWhite (Neu et al., 2020)) for chain growth under synchrony and participation churn.
• A partially synchronous finality protocol (e.g., Casper FFG, PBFT-style gadgets) that irrevocably finalizes a chain prefix via supermajority quorums and checkpointing (D'Amato et al., 2024, D'Amato et al., 7 Jan 2026).

In Majorum (D'Amato et al., 7 Jan 2026), each slot $t$ splits into phases: propose (4$\Delta$t), vote (4$\Delta$t+$\Delta$), fast-confirm (4$\Delta$t+2$\Delta$), and merge (4$\Delta$t+3$\Delta$). Chain growth proceeds via majority quorums ($Q_{\rm maj}$: $|Q| > n/2$ for fork-choice) while finality uses supermajority quorums ($Q_{\rm smf}$: $|Q| \geq 2n/3$ for checkpoint links).

Pseudocode for the TOB-SVD mechanism incorporates locked chain prefixes, fast-confirmed chains, and ghost-choice chain computation. Fast confirmation occurs optimistically when a chain receives $2n/3$ votes in the slot. The finality gadget operates by checkpointing, supermajority linking, and justification/finalization, with accountable safety ensured via intersection properties ($|Q_1 \cap Q_2| \geq n/3 > f$ for $Q_1, Q_2 \in Q_{\rm smf}$).

3. Security Properties, Optimality, and Theorems

The security criteria for ebb-and-flow protocols are optimal under the CAP-style impossibility (Neu et al., 2020). The main theorems establish:

• Dynamic Availability: Under $f < n/3$ and the sleepy model, the dynamically available chain is safe and live after time zero, with confirmation time $T_{\rm conf} = O(\kappa)$ (D'Amato et al., 7 Jan 2026, D'Amato et al., 2024).
• Accountable Safety: If two conflicting chains are finalized, at least $n/3$ validators must have violated double-voting or surround-voting conditions, yielding cryptographic evidence for slashing (D'Amato et al., 7 Jan 2026, D'Amato et al., 2024).
• Prefix Consistency: The finalized chain is always a prefix of the available chain, even under adversarial conditions (Neu et al., 2020).
• Latency Bounds: In Majorum and related protocols, blocks are finalized in as few as three slots under optimistic conditions—a $>20\times$ improvement in finality latency over Gasper's 64–95 slot window (D'Amato et al., 2024, D'Amato et al., 7 Jan 2026).
• Quorum Dynamics Under Churn: Chain growth adapts to the majority of the active set; finality requires stable participation above $2n/3$ for continuity (D'Amato et al., 7 Jan 2026).

4. Instantiations and Variants

Major instantiations include:

• Ethereum Gasper (LMD-GHOST + Casper FFG): Two attestation rounds per epoch; 64+ slot finality under ideal conditions, resulting in windowed MEV exposure (D'Amato et al., 2024, Neu et al., 2020).
• Majorum: TOB-SVD dynamic layer and one-vote-per-slot finality gadget, yielding three-slot finality (D'Amato et al., 7 Jan 2026).
• Slipstream: DAG-based consensus with slot-sleepy optimistic ordering and ELSS finality; integrates fast-path UTXO confirmation distinct from block ordering (Polyanskii et al., 2024).
• Flexible BFT “Snap-and-Chat”: Layered longest-chain for availability and Streamlet/HotStuff-style BFT for finality, achieving corner-point security $(f_{\rm sync}, f_{\rm psync})=(n/3, n/2)$ (Neu et al., 2020, D'Amato et al., 2024).

Protocols vary in fork-choice algorithms (majority vs. latest-message), number of voting rounds per slot, quorums, and communication complexity (O($n$) per slot with aggregation, worst case O($n^2$) unaggregated).

5. Application Domains

Ebb-and-flow principles underpin protocol design in:

• Proof-of-stake blockchains: Resolution of availability-finality trade-offs and mitigation of reorganizations/MEV risk (D'Amato et al., 2024, Neu et al., 2020).
• Payment channel networks: Flow and price-control schemes (e.g., DEBT control (Sankagiri et al., 27 Feb 2025)) realize an ebb-and-flow dynamic, balancing routed liquidity and enforcing steady-state detailed balance via gradient descent on routing prices.
• Peer-to-peer sharing systems: Tit-for-tat and thresholded service schemes (e.g., BitTorrent, BAR Gossip) embody “ebb-and-flow” through satiation rules (0806.1711), though they are vulnerable to targeted ablation attacks (Lotus-Eater).

6. Attacks, Limitations, and Mitigations

Protocols based on thresholded reciprocity or dynamic availability are susceptible to targeted disruption:

• Lotus-Eater Attack: Attackers “satiate” peers by flooding them with service, so they no longer serve others, starving the network (0806.1711). The quantitative threshold for attack success is $s \leq fC/T$, where $s$ is fraction targeted, $f$ is attacker’s node fraction, $C$ is attack capacity, and $T$ is peer threshold.
• Synchronous Liveness Attack on Gasper: Adversaries exploit message scheduling and equivocation to block finalization indefinitely while oscillating chain growth (Neu et al., 2020). Mitigation approaches include graph-resilience design, raising satiation thresholds (network coding, scrip), rate-limiting via obedience mechanisms, calibrated altruism, and enforceable service caps (0806.1711). Protocol-level mitigations involve tight coupling between dynamic and finality quorums, accountable slashing, and pipelined confirmation.

7. Comparative Analysis and Design Trade-offs

Key trade-offs emerge between quorum strength, voting phases, latency, and tolerance to churn:

• Majority versus supermajority quorums: Majorum uses stricter majority quorums for chain growth; finality always requires $2n/3$ participation (D'Amato et al., 7 Jan 2026).
• Voting phase reduction: Majorum’s single-vote-per-slot structure reduces $\Delta$-amplified aggregation delays relative to multi-round designs (Gasper/SP21) (D'Amato et al., 2024, D'Amato et al., 7 Jan 2026).
• Finality latency versus pipeline tightness: Three-slot finality protocols drastically reduce reorganizational and MEV risk, but require more tightly coupled quorum management (D'Amato et al., 2024). DAG-based protocols (Slipstream) support fast transaction confirmation independent of block finality (Polyanskii et al., 2024).

Comparison Table:

Protocol	Chain Growth Quorum	Finality Quorum	Finality Latency (slots)
Gasper (Eth2)	$\geq$(weight-based)	$2n/3$	64–95
Majorum	$>$ $n/2$	$\geq$ $2n/3$	3
Snap&Chat	LC ($< n/2$), BFT ($< n/3$)	$2n/3$	$O(1)$
Slipstream	$n/2$ (optimistic)	$2n/3$ (final)	3 (DAG fast-path)

This suggests that protocols with tighter voting phases and majority-based chain extension sharply improve both latency and reorganizational resistance, at the cost of quorums tolerating less churn during finalization.

• Majorum: Ebb-and-Flow Consensus with Dynamic Quorums (D'Amato et al., 7 Jan 2026)
• The Lotus-Eater Attack (0806.1711)
• Slipstream: Ebb-and-Flow Consensus on a DAG (Polyanskii et al., 2024)
• 3-Slot-Finality Protocol for Ethereum (D'Amato et al., 2024)
• Pricing for Routing and Flow-Control in Payment Channel Networks (Sankagiri et al., 27 Feb 2025)
• Ebb-and-Flow Protocols: A Resolution of the Availability-Finality Dilemma (Neu et al., 2020)