DAG-Based Consensus

Unlike blockchains where transactions are processed in sequential blocks, DAGs allow for asynchronous and parallel transaction validation. Multiple transactions can be added to the graph simultaneously by different nodes, significantly increasing potential throughput. This eliminates the bottleneck of waiting for the next block to be produced, a key limitation in traditional Proof-of-Work and Proof-of-Stake chains.

• Key Benefit: Higher theoretical transaction throughput (TPS).
• Example: IOTA's Tangle allows users to validate two previous transactions when submitting their own, enabling parallel confirmation streams.

Many pure DAG consensus models eliminate the need for dedicated miners or validators to create blocks. Instead, participants themselves contribute to network security and consensus by validating previous transactions when they issue new ones. This can lead to a more decentralized and permissionless structure, as there is no competition for block space or specialized hardware requirements.

• Key Benefit: Reduces centralization pressure and potential for miner extractable value (MEV).
• Mechanism: New transactions directly reference and validate older ones, building a web of attestations.

A core principle of many DAG systems is that network performance scales with usage. As more transactions are issued, there are more opportunities for parallel validation and a denser web of confirmations. This is in contrast to blockchain models where increased usage often leads to network congestion and higher fees due to limited block space.

• Key Benefit: Theoretically infinite horizontal scalability.
• Consideration: Requires robust anti-spam mechanisms, as submitting a transaction has low to zero cost.

DAGs often achieve probabilistic finality through concepts like cumulative weight or confidence score. A transaction's security increases as more subsequent transactions directly or indirectly reference it, making it computationally harder to reverse. This is a departure from blockchain's deterministic finality after a set number of block confirmations.

• Key Benefit: Faster initial confirmation with increasing security over time.
• Example: In IOTA, the Tip Selection Algorithm chooses which previous transactions to validate based on their accumulated weight.

DAGs handle double-spend attempts and conflicting transactions through specific consensus rules. Common approaches include:

• Voting-based: Nodes run a consensus algorithm (like Avalanche) to repeatedly sample the network and converge on the validity of conflicting transactions.
• Weight-based: The transaction embedded in the heaviest subgraph (most cumulative work/references) is considered valid.
• Leader-based: Some hybrid DAGs (e.g., Fantom's Lachesis) use a committee of leaders to finalize batches of transactions, adding a BFT layer.

The absence of miners and block competition allows many DAG architectures to operate with zero or negligible transaction fees. This is because the cost of validation is distributed across participants submitting their own transactions. This feature makes DAGs particularly suited for machine-to-machine (M2M) payments and microtransactions, where fees on traditional blockchains would be prohibitive.

• Key Benefit: Enables new economic models and IoT use cases.
• Requirement: Relies on alternative anti-spam measures, such as Proof-of-Work puzzles or stake-based access.

In a DAG, transactions directly reference previous ones, creating a web of dependencies. A double-spend attack occurs when a malicious actor issues two conflicting transactions and attempts to get both confirmed by embedding them in different parts of the DAG graph. Security relies on the cumulative weight of subsequent transactions that reference and thus 'approve' one branch over another. This makes the initial period after a transaction is issued a vulnerable confirmation window.

Nodes must choose which previous transaction tips to reference when issuing a new transaction. A poor tip selection algorithm can lead to:

• Liveness attacks: An attacker can create a parasitic chain that is never referenced, starving honest transactions.
• Network splits: The DAG can fragment into disconnected subgraphs if tips are not selected to promote convergence. Algorithms like the Markov Chain Monte Carlo (MCMC) in IOTA are designed to weight tips based on cumulative work, favoring the main chain.

Many DAG networks are vulnerable to Sybil attacks, where an attacker creates many fake identities (nodes) to gain disproportionate influence over tip selection and consensus. To mitigate this during bootstrapping, some networks like IOTA historically used a Coordinator—a centralized checkpointing node. This creates a security-centralization tradeoff, as the network's liveness depends on a trusted entity, which contradicts decentralization goals. Moving to a coordinator-less, fully decentralized state is a major challenge.

DAGs often exhibit probabilistic finality, where a transaction's acceptance becomes more certain as more subsequent transactions reference it. However, this can lead to:

• Deep reorgs: In some designs, a sufficiently powerful attacker could theoretically rewrite large portions of the DAG history.
• Delayed finality: Unlike blockchains with immediate finality per block (e.g., Tendermint), confidence in a DAG transaction grows gradually, requiring confirmations from a significant portion of future network activity.

A specific attack vector where a malicious actor builds a private, heavier branch of the DAG in secret. When released, this parasite chain could outpace the honest main chain due to its accumulated weight, allowing the attacker to reverse previously confirmed transactions. Defenses include requiring Proof-of-Work for each transaction to slow down the creation of a secret chain, and tip selection algorithms that penalize branches that were not published in a timely manner.

A 2018 research paper demonstrated a theoretical attack where an entity controlling 34% of the network's hash rate could consistently double-spend in the IOTA DAG. This highlighted the criticality of honest majority assumptions in cumulative weight-based security models. The vulnerability stemmed from the ability to manipulate the MCMC tip selection algorithm by focusing computational power, leading to subsequent protocol revisions to increase attack cost.

A Directed Acyclic Graph (DAG) is a mathematical data structure consisting of vertices (nodes) and directed edges (connections) with no cycles. In a blockchain context:

• Vertices represent individual transactions or blocks.
• Edges represent approval or validation relationships (e.g., a new transaction references and validates two previous ones).
• Acyclic means no transaction can indirectly reference itself, preventing loops. This structure enables parallel transaction processing and is the foundational data model for protocols like IOTA's Tangle and Avalanche.

Nakamoto Consensus, used by Bitcoin, is the canonical Proof-of-Work blockchain consensus model. Key contrasts with DAG-based systems include:

• Linear Chain: Transactions are ordered into sequential blocks, creating a single chain of history.
• Probabilistic Finality: Settlement certainty increases with subsequent blocks (confirmations).
• Leader-Based: Miners compete to append the next block, leading to potential forks. DAG-based systems often seek to improve on this model by enabling parallel block creation and faster confirmation times, though they face different challenges in achieving network-wide agreement.

Avalanche Consensus is a leaderless, probabilistic protocol used by the Avalanche platform. It employs repeated sub-sampled voting to achieve consensus:

• Snowball Protocol: Nodes repeatedly query a small, random subset of peers, adjusting their preference based on responses.
• Metastability: The network rapidly converges on a single decision with high probability.
• DAG Structure (Blockchain): Transactions are organized into a DAG of blocks, allowing high throughput. This approach provides sub-second finality and scales to thousands of transactions per second without a fixed validator set size.

The Tangle is IOTA's feeless, DAG-based data structure designed for the Internet of Things (IoT). Its core mechanics are:

• No Miners/Validators: To issue a transaction, a user must approve two previous transactions, directly contributing to network security.
• Cumulative Weight: Transactions gain weight as more subsequent transactions approve them.
• Coordinator (Previously): A temporary centralized checkpointing system was used to protect the nascent network, with plans for full decentralization. The Tangle aims to enable microtransactions and data integrity for IoT devices with minimal resource requirements.

Finality in DAG-based systems refers to the point where a transaction is considered immutable. Approaches differ from linear blockchains:

• Probabilistic Finality: Common in leaderless DAGs (e.g., Avalanche), where confidence increases exponentially with repeated voting rounds.
• Absolute Finality: Some DAG protocols use a finality gadget (e.g., a BFT layer) to provide instant, cryptographic finality for certain checkpoints.
• Confirmation Confidence: Transactions deep within the DAG graph, referenced by many others, achieve practical finality as rewriting them becomes computationally infeasible.

Block Lattice is a DAG-inspired architecture used by Nano, where each account has its own blockchain (account-chain).

• Asynchronous Updates: Users broadcast transactions to their own chain without global consensus on ordering.
• Representative Voting: Account holders delegate voting weight to Representatives who run a Delegated Proof-of-Stake (DPoS) consensus to settle conflicting transactions.
• Feeless & Fast: This design enables instant, feeless transactions, as there are no miners and no transaction fees for basic transfers. The Block Lattice demonstrates a hybrid approach, combining a DAG-like data structure with a separate consensus layer for conflict resolution.