Avalanche is a prominent blockchain platform designed to provide high throughput, low latency, and strong decentralization without the energy costs of proof-of-work. Its core innovation lies in a family of randomized, leaderless, and scalable consensus protocols known as the Snow family—comprising Slush, Snowflake, Snowball, and culminating in Avalanche itself. This preliminary write-up provides a technical description of the Avalanche consensus protocol, followed by an in-depth security analysis, including its resilience properties, known vulnerabilities, and recent academic findings.

Technical Description of the Avalanche Consensus Protocol

1. The Snow Family: Core Concepts

Avalanche consensus is built on the Snow family of protocols, each introducing increasing sophistication and safety guarantees:

• Slush: The simplest protocol, where each node repeatedly samples a small, random subset of peers to observe their current "color" (opinion on a binary decision). If a sufficient majority (parameter α) in the sample supports a color, the node adopts it. This process repeats for a fixed number of rounds, leading to rapid convergence but with only probabilistic guarantees and no Byzantine fault tolerance.
• Snowflake: Extends Slush by introducing a counter. A node only finalizes its decision after observing β consecutive successful samples for the same color. This reduces the chance of oscillation and increases confidence in the decision.
• Snowball: Further augments Snowflake by maintaining a confidence counter for each color, tracking the cumulative number of successful samples. A node switches its preferred color only when the confidence for another color surpasses its current preference. This history-aware mechanism improves convergence and safety in adversarial settings.
• Avalanche: Generalizes Snowball to operate on a Directed Acyclic Graph (DAG) of transactions. Each transaction is a node in the DAG, and transactions reference their parents (previous transactions). Avalanche runs a Snowball instance for each conflict set (i.e., set of transactions attempting to spend the same inputs), and uses the DAG structure to batch votes and propagate confidence efficiently. This design allows parallel processing and partial ordering of unrelated transactions, boosting throughput and scalability.

Protocol Parameters

Key parameters govern the protocol's behavior:

• k: Number of peers sampled in each round (e.g., 20).
• α: Majority threshold for adopting a color (e.g., 15 out of 20).
• β: Number of consecutive successful samples required to finalize a decision (e.g., 150).

DAG Structure and Voting

In Avalanche, transactions are appended to the DAG by referencing parents (recent, non-conflicting transactions). When a node receives a transaction, it queries k random peers to check if the transaction and all its ancestors are preferred in their respective conflict sets. A transaction receives a "chit" if it passes this check in a majority of responses. The confidence in a transaction is then the sum of chits in its descendants, and a transaction is accepted when its confidence or consecutive successful queries reach the threshold β.

This DAG-based approach allows for:

• Efficient batching of votes.
• Parallel confirmation of unrelated transactions.
• Entanglement of transaction fate, making it harder for adversaries to revert decisions[1][2].