Lifefin: Escaping Mempool Explosions in DAG-based BFT

arXiv:2511.15936 · cs.CR · Submitted 2025-11-20 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.

Nadia: I'm Nadia.

Elias: And I'm Elias, here with Priya.

Nadia: We're looking at the paper: "Lifefin: Escaping Mempool Explosions in DAG-based BFT".

Elias: Here's the gist of the paper. Directed Acyclic Graph (DAG)-based Byzantine Fault-Tolerant (BFT) protocols have emerged as promising solutions for high-throughput blockchains by decoupling data dissemination from transaction ordering and constructing a well-connected DAG in the mempool, yet an adversary can trigger mempool explosions to prevent transaction commitment, ultimately compromising the protocol’s liveness The Core Problem Identified The fundamental liveness vulnerability in existing partially synchronous DAG-based BFT protocols arises from a gap between theoretical guarantees relying on infinite resources and the practical reality of nodes having bounded resources, specifically when nodes exhaust their resources maintaining an ever-growing set of uncommitted vertices in the DAG-based mempool during periods of asynchrony This resource exhaustion blocks correct nodes from generating new vertices or collecting enough votes, ultimately halting the protocol’s progress The paper identifies this issue as mempool explosion and demonstrates that inflation attacks can exploit it by preventing even a single correct node from participating for a temporary period before the Global Stabilization Time (GST), which ultimately compromises liveness The Proposed Solution Lifefin To address this vulnerability, the work proposes Lifefin, a generic and self-stabilizing protocol designed to integrate seamlessly into existing DAG-based BFT protocols to “save the lives” of these fish named protocols The key insight is that if nodes can complete the ordering task with finite resource usage, they can ensure enough resources are available for ordering, thereby avoiding mempool explosions Lifefin leverages the Agreement on Common Subset (ACS) mechanism to allow nodes to escape mempool explosions by committing transactions with bounded resource usage even in adverse conditions Mechanism and Integration Lifefin incorporates an ACS protocol into the underlying DAG-based protocol, switching to a fallback path when necessary, which is triggered by conditions such as uncommitted data exceeding a predefined limit or failing to commit DAG vertices for a large timeout period The ACS mechanism allows nodes to agree on a common subset V of proposals with bounded resources, and nodes can then commit these decided vertices with bounded resources Furthermore, Lifefin introduces the Proof-of-STuck (PoST) block to decouple the ACS protocol from the underlying DAG-based protocol, allowing for easy integration into any existing DAG-based protocol regardless of its structure Performance and Security Results Experimental evaluations on Sailfish and Mysticeti show that Lifefin achieves comparable transaction throughput while introducing only a minor latency overhead to effectively resist the exploited inflation attacks The safety analysis proves that correct nodes commit the same leader vertices in the same order, ensuring consistent ordering of transactions Liveness is guaranteed because the ACS properties ensure that every correct node eventually has V ≤ n − f referred vertices to move to a new round and propose new vertices In this work, we identify a fundamental liveness issue in existing DAG-based BFT protocols and show how it can be exploited by the adversary, proposing Lifefin as a generic and self-stabilizing solution that can efficiently eliminate the liveness issue while only introducing acceptable latency The results demonstrate that Lifefin can commit DAG vertices with fixed and relatively small resources, enabling nodes to escape mempool explosions The protocol satisfies both safety and liveness properties under adverse conditions Inflation Attack Details Inflation attacks are achieved by Byzantine nodes actively propagating DAG vertices while permanently refraining from voting for leader vertices, causing correct nodes to exhaust their resources maintaining the DAG-based mempool The attack can be made successful by temporarily making a correct node unavailable through a distributed denial-of-service (DDoS) attack or misconfiguration error before GST Non-DAG Protocol Vulnerabilities Mempool explosions can also compromise the liveness of non-DAG decoupled BFT protocols, such as linear-chain protocols, because they rely on continuously growing data for ordering and lack a cleanup strategy for uncertified blocks The paper notes that traditional garbage collection mechanisms cannot circumvent this issue because consensus is never reached in those cases Dual-Mode Protocols The family of dual-mode protocols, exemplified by Ditto, Bullshark, Flexico, and Bolt-Dumbo, combines a partially-synchronous protocol optimized for latency during synchrony with a second protocol optimized for asynchronous conditions Only the dual-mode Bullshark is designed for DAG structure but its full implementation does not exist Lifefin minimizes the overhead of these protocols by operating within a partially synchronous protocol and resorting to ACS protocols only in rare, adversarial scenarios Study on Bounded Models The bounded model plays a role in the liveness guarantee of DAG-based BFT protocols due to the new features introduced by maintaining a DAG-based mempool, which prior theoretical analyses often overlook The paper shows that the bounded model also plays a role in the liveness guarantee of DAG-based BFT protocols due to the new features introduced by maintaining a DAG-based mempool Final Summary In this work, we identify a fundamental liveness issue in existing DAG-based BFT protocols and show how it can be exploited by the adversary, proposing Lifefin as a generic and self-stabilizing solution that can efficiently eliminate the liveness issue while only introducing acceptable latency The results demonstrate that Lifefin can commit DAG vertices with fixed and relatively small resources, enabling nodes to escape mempool explosions The protocol satisfies both safety and liveness properties under adverse conditions References

Title and authors: Nadia: So we’re looking at this paper today titled "Lifefin: Escaping Mempool Explosions in DAG-based BFT". It tackles a real problem where these high-throughput blockchains that use Directed Acyclic Graphs for ordering transactions can get stuck.

Elias: Yeah, it zeroes in on this issue where an adversary can intentionally cause mempool explosions to stop the whole system from committing transactions, which messes up the liveness of the protocol.

Priya: It sounds like a way to fix a situation where the theoretical guarantees of these DAG protocols break down because they rely on infinite resources that nodes just don't have in reality.

Nadia: Exactly. The core problem they identify is this gap between what’s theoretically possible with infinite resources and what happens when real nodes run out of memory or processing power maintaining a huge backlog of uncommitted vertices during periods of asynchrony.

Elias: They call this mempool explosion, and the paper shows that inflation attacks can exploit it by making sure even one correct node can't participate for a short time before some global stabilization time is hit, which stops progress.

Priya: So what’s the actual mechanism they propose to stop this stalling? Is it just a quick patch or something more structural?

Nadia: They present Lifefin as this generic and self-stabilizing protocol that you can plug into existing DAG-based BFT protocols to save them, and the main idea is that if nodes can order things using only a finite amount of resources, they can guarantee enough resources are there for ordering, which avoids those explosions.

Elias: The key insight they use is the Agreement on Common Subset mechanism, which lets nodes agree on a common subset of proposals using bounded resources and then commit those decided vertices also with bounded resource usage even when things are bad.

Priya: So it’s about finding a way for nodes to escape that backlog by committing only what they can handle right now, rather than trying to keep every single uncommitted vertex in the mempool forever?

Title and authors: Nadia: That's right. They show that Lifefin adds almost zero overhead in normal cases, but when things get tough, it switches to this fallback path if uncommitted data gets too big or if they fail to commit DAG vertices for a long timeout.

Elias: And they introduce something called the Proof-of-STuck block which helps decouple this new agreement process from the original DAG structure, making it easier to fit into any existing protocol regardless of its setup.

Priya: What kind of results did they get? Did this fix the liveness problem without slowing down the transaction throughput too much?

Nadia: They did. Experiments on Sailfish and Mysticeti show that Lifefin achieves transaction throughput comparable to the original system while only adding a small latency overhead when resisting those inflation attacks.

Elias: And they prove safety by showing that correct nodes commit the same leader vertices in the same order, which keeps the transaction ordering consistent even when things are chaotic.

Priya: So for someone just listening to this, what does it actually mean that liveness is guaranteed because of these properties?

Nadia: It means that every correct node eventually has enough referred vertices to move into a new round and propose new ones, which keeps the whole chain moving forward under adverse conditions.

Elias: The inflation attack they discuss involves Byzantine nodes flooding the DAG with vertices but refusing to vote for leader vertices, forcing correct nodes to run out of resources maintaining that mempool backlog before the global stabilization time hits.

Priya: I wonder what happens if you look outside this specific context, because they also mentioned vulnerabilities in non-DAG protocols like linear-chain protocols as well.

Nadia: They did. They pointed out that mempool explosions can still compromise liveness in those linear-chain setups because they rely on continuously growing data for ordering without a proper cleanup strategy for uncertified blocks.

Elias: And they said traditional garbage collection mechanisms don't help much there because consensus never actually gets reached in those cases, which is a significant limitation of that approach.

Title and authors: Priya: So where does Lifefin fit into the bigger picture of these dual-mode protocols they mentioned? Are we talking about a specific solution for everything?

Nadia: They look at the family of dual-mode protocols like Ditto or Bullshark, which try to balance latency during sync with handling asynchrony, and Lifefin tries to minimize the overhead of those protocols by only switching to their ACS fallback in rare, bad scenarios.

Elias: It seems they are focusing on making the protocol robust enough that it only needs that extra mechanism when an inflation attack is actively trying to stall it before the global stabilization time arrives.

Priya: So, looking at this whole paper "Lifefin: Escaping Mempool Explosions in DAG-based BFT", what’s the main thing we should remember about its practical application?

Nadia: The main thing is that they show you can commit those DAG vertices using fixed and relatively small resources, which lets nodes escape those mempool explosions while still keeping the safety and liveness properties intact under stress.

Elias: It’s a self-stabilizing solution that integrates into existing systems, meaning it’s designed to handle these specific resource exhaustion problems without requiring a complete rewrite of the underlying DAG protocol.

Priya: So to wrap this up, what's the big picture implication for how we think about building resilient distributed systems on blockchains?

Nadia: It shows that even with high-throughput DAG structures, you can build in mechanisms like Lifefin that allow nodes to handle resource pressure by switching to a bounded resource commitment strategy when necessary.

Elias: It proves that the practical, resource-bounded model is realistic and needs to be included in theoretical analyses because the infinite resources assumption just doesn't work for real nodes.

Priya: We’ll keep an eye on how this approach holds up when we look at more complex Byzantine scenarios or maybe when we try to apply this logic to those linear-chain protocols they mentioned.

Nadia: That’s the plan. It was interesting looking at how they handled that mempool explosion issue in "Lifefin: Escaping Mempool Explosions in DAG-based BFT".

The paper's summary: Nadia: So, Lifefin is basically this new layer you put on top of those Directed Acyclic Graph protocols to stop them from just freezing up when things get messy with uncommitted data.

Elias: Right, it tackles that core liveness problem where an adversary can trigger a mempool explosion by flooding the system with vertices while staying silent on voting.

Nadia: The authors show that the fix is integrating this Agreement on Common Subset mechanism to let nodes commit transactions using only bounded resources even when conditions are really bad.

Elias: They're using this fallback path triggered if uncommitted data hits a certain limit or if they don't get any DAG vertices committed for a long time.

Priya: So, the core idea is that if you can order things with a limited amount of processing power, you can guarantee there’s always enough room to keep making progress and not just stall.

Nadia: Exactly. They show this works on Sailfish and Mysticeti, keeping transaction speeds pretty similar while just adding a small bit of extra latency when the attack is happening.

Elias: They prove safety too, which means even though they’re switching to this fallback mechanism, correct nodes still commit the exact same leader vertices in the same order.

Priya: But what about those non-DAG systems, like linear chains? The paper touches on how mempool explosions can still hurt those protocols too because they lack a cleanup strategy for uncertified blocks.

Nadia: Yeah, that’s a limitation they point out; traditional garbage collection doesn't fix it in linear chain systems because consensus never actually gets reached in those scenarios.

Elias: Lifefin tries to be generic and self-stabilizing, so you can plug this into any existing DAG protocol structure without having to rewrite the whole thing, using something called Proof-of-STuck blocks for that decoupling.

Priya: It sounds like they’re showing that the bounded model of resource usage is actually crucial here because theoretical analyses often ignore how much memory or processing power real nodes have.

Nadia: That's true; the paper highlights how this specific mechanism lets nodes commit DAG vertices with fixed and relatively small resources, effectively letting them escape those mempool explosions under stress.

Elias: It means even when you’ve got an inflation attack trying to stop you before the global stabilization time hits, your system can still maintain both safety and liveness.

Priya: So for someone just listening to this, it changes how you think about building these high-throughput systems by making resource management a primary part of the consensus design rather than an afterthought.

Nadia: It’s about showing that even with the complexity of DAG structures, you can build in mechanisms like Lifefin that handle resource pressure by switching to a bounded commitment strategy when needed.

Elias: It proves that the assumption of infinite resources doesn't work for real nodes, and you need these fallback strategies to make things practical.

Priya: We’ll definitely want to see how this approach holds up when we look at more complex Byzantine scenarios or maybe try to apply this logic to those linear-chain protocols they mentioned later.

The paper's improvements: Nadia: So, we’re talking about the specific technical improvements Lifefin suggests for making this protocol better, moving beyond just adding a fallback path when things get bad.

Elias: Yeah, they are proposing several specific ways to make this integration smoother and more robust against those inflation attacks.

Nadia: One big improvement is using that Proof-of-STuck block which they say helps decouple the new agreement process from the original DAG structure itself.

Elias: That’s smart because it means you can integrate Lifefin into almost any existing DAG protocol, no matter how weird its structure is right now.

Priya: From a measurement standpoint, I’m interested in how they handle things when the uncommitted data record gets massive, like when we talk about the limit being exceeded.

Nadia: They detail that the Agreement on Common Subset mechanism lets nodes agree on a common subset of proposals using bounded resources before committing those vertices with bounded resource usage too.

Elias: That’s key because it directly addresses the resource exhaustion issue by ensuring that even in adverse conditions, nodes are only committing what they can actually handle.

Priya: So, it’s not just a timeout; it’s a mechanism where the protocol autonomously decides to commit a specific subset of transactions with limited resources when things go south.

Nadia: Exactly. It shifts the burden from trying to keep everything in the mempool forever to committing what's necessary for progress within those bounded limits.

Elias: And they’ve shown that this approach keeps transaction ordering consistent, meaning safety isn't sacrificed just because you’re using a fallback mechanism.

Priya: But what about the performance trade-off? Does this new mechanism slow down the system significantly during normal operation, or is it mostly for those high-stress scenarios?

Nadia: The authors claim that the latency overhead introduced by Lifefin is only minor in normal operation, but it kicks in when those specific adversarial conditions trigger.

Elias: It means you get the benefits of a DAG structure without having to pay a massive performance penalty for handling worst-case scenarios like inflation attacks.

Priya: So, if we look at the data they presented on Sailfish and Mysticeti, does that minor latency overhead actually matter in real-world throughput terms?

Nadia: The experiments show that they achieve comparable transaction throughput to the original system while only adding that small bit of latency when those specific attacks occur.

Elias: It seems they’ve managed to keep the system responsive while significantly bolstering its resilience against these kinds of resource exhaustion attacks.

Conclusion: Tom: So we're wrapping up this discussion on "Lifefin: Escaping Mempool Explosions in DAG-based BFT". We talked about how it tackles resource exhaustion by using bounded commitment strategies during stress.

Nadia: Right, essentially showing that you can make these high-throughput DAG protocols more resilient to those inflation attacks by just adding this self-stabilizing mechanism.

Elias: I agree, the integration of the Agreement on Common Subset and Proof-of-STuck blocks seems like a solid way to address the liveness gap without messing up transaction ordering consistency.

Priya: I’m still thinking about how this impacts the real world; does this mean we can actually deploy these DAG systems in environments where we don't have infinite resources, which is most places?

Nadia: It means it makes the practical model of resource usage more important because it shows how to handle those finite constraints by switching to a bounded commitment strategy when necessary.

Elias: It validates the idea that you can build systems that are designed for both ideal and adversarial conditions, rather than just optimizing for one perfect scenario.

Priya: From my side, it’s good that they clearly separated what the protocol does—what it guarantees—from the specific resource model they used to prove it.

Nadia: Exactly, they prove safety and liveness even when those specific resource constraints are pushed to their limits by an attacker.

Elias: It’s a practical addition that doesn't require rewriting the entire underlying protocol, which is a big deal for existing systems right now.

Priya: I just hope this mechanism scales well when we start looking at even more complex Byzantine scenarios, because those are where things usually break down next.

Nadia: We'll have to see how it performs under those harder conditions, but for now, Lifefin shows a way to handle the immediate threat of mempool explosions in DAG-based systems.

Elias: It’s definitely a piece of work that bridges the gap between theoretical guarantees and practical deployment on real hardware.

Priya: It gives us confidence that we can build these high-throughput systems with more realistic resource assumptions baked into the design from the start.

Jianting Zhang, Sen Yang, Alberto Sonnino, Sebastian Loza ´, Aniket Kate

Purdue University · Yale University · Mysten Labs/UCL

cs.CR

Submitted: 2025-11-20

Updated: 2026-11-01

Comments: Improved the presentation; added a strawman solution

Code: https://github.com/nibeshrestha/sailfish

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 83/100

The gist: Directed Acyclic Graph (DAG)-based Byzantine Fault-Tolerant (BFT) protocols have emerged as promising solutions for high-throughput blockchains by decoupling data dissemination from transaction…

Key concepts

Mempool Explosion
This occurs when an adversary floods the system with DAG vertices while refusing to vote for leaders. Correct nodes then spend all their finite resources trying to maintain this massive, uncommitted set of data in the mempool, eventually exhausting their capacity and halting protocol progress.
Lifefin
A generic, self-stabilizing protocol designed to fix liveness issues in DAG-based BFT systems. It integrates an ACS mechanism that allows nodes to commit a common subset of proposals using only bounded resources. This prevents resource exhaustion during attacks.
Agreement on Common Subset (ACS)
An underlying mechanism within Lifefin that enables nodes to agree on a specific, manageable subset of proposals (V). Nodes can then commit these decided vertices with limited resources. This allows the protocol to escape mempool explosions by focusing on a smaller, agreed-upon set.
Proof-of-STuck (PoST)
A block introduced in Lifefin that decouples the ACS protocol from the main DAG structure. It is used during fallback instances to verify consistent ordering of leader vertices using a quorum of signatures. This ensures safety by maintaining correct transaction ordering even when the DAG structure is compromised.

Terminology

Summary

Directed Acyclic Graph (DAG)-based Byzantine Fault-Tolerant (BFT) protocols have emerged as promising solutions for high-throughput blockchains by decoupling data dissemination from transaction ordering and constructing a well-connected DAG in the mempool. p. 0 However, this work identifies a fundamental liveness vulnerability where an adversary can trigger mempool explosions to prevent transaction commitment, ultimately compromising the protocol’s liveness. p. 0 In response, Lifefin is presented as a generic and self-stabilizing protocol designed to integrate seamlessly with existing DAG-based BFT protocols and circumvent such vulnerabilities. p. 0

The Vulnerability Identified

The core issue stems from a gap between the theoretical reliance on infinite resources in theory and the bounded resources of nodes in practice. Specifically, nodes are allowed to create new vertices even when prior vertices remain uncommitted due to implicit view change. p. 2 This leads to resource exhaustion because correct nodes cannot generate new vertices or collect enough votes for leader commitment, causing the protocol to stall and prevent transactions from being committed. p. 1

The Exploitation Mechanism

To exploit this liveness vulnerability, the paper introduces a class of inflation attacks. The attack works by having Byzantine nodes actively propagate DAG vertices while preventing correct nodes from completing the ordering task. p. 3 This can be achieved by launching a Distributed Denial-of-Service (DDoS) attack on correct nodes to prevent them from voting for leader vertices before the Global Stabilization Time (GST). p. 3

The Lifefin Solution

Lifefin is proposed as a generic and self-stabilizing protocol that integrates into existing DAG-based BFT protocols to save the lives of these protocols. The key insight is that if nodes can complete the ordering task with finite resource usage, they can ensure enough resources are available for ordering, thereby avoiding mempool explosions. p. 1

Protocol Integration and Performance

Lifefin operates by incorporating an Agreement on Common Subset (ACS) protocol into the underlying DAG-based protocol, switching to a fallback path when suspecting inflation attacks or resource exhaustion. The evaluation demonstrates that Lifefin achieves comparable transaction throughput while introducing only minimal additional latency to resist similar attacks. p. 0

Security and Liveness Guarantees

The security analysis shows that Sailfish-Lifefin satisfies safety by ensuring all correct nodes commit transactions in the same order. Liveness is guaranteed because the timeout Tst ensures that all correct nodes trigger the ACS mechanism if the protocol fails to commit new transactions after GST. p. 7 This ensures that Sailfish-Lifefin can continuously generate and commit new DAG vertices even though correct nodes have limited resources to maintain pending DAG vertices. p. 7

Inflation Resistance Evaluation

Experimental results show that after the attack starts at around 20 seconds, the throughput (i.e., committed BPS) drops to 0 while nodes continue proposing new DAG vertices, leading to sharply increasing uncommitted vertices. p. 3 Crucially, after the protocol triggers the fallback mechanism, nodes stop creating new DAG vertices, causing the cumulative UB to remain unchanged. p. 5 This demonstrates that Lifefin can prevent an adversary from exhausting nodes’ resources. p. 3

Conclusion and Applicability

Lifefin is a generic and self-stabilizing solution that can be seamlessly integrated into any existing DAG-based protocol, including certified and uncertified ones. The work concludes that Lifefin efficiently eliminates the liveness issue while only introducing acceptable latency. p. 1

Related Work Context

The paper notes that asynchronous DAG-based BFT protocols do not fundamentally address the liveness vulnerability since they still rely on continuously growing data to commit DAG vertices—the root cause of mempool explosions. Lifefin minimizes this overhead by operating within a partially synchronous protocol and resorting to ACS protocols only in rare, adversarial scenarios. p. 1

Mempool Explosions on Non-DAG Protocols

The discussion extends to non-DAG decoupled BFT protocols, noting that they are inherently sensitive to mempool explosion attacks because they rely on continuously growing data for ordering. The paper suggests that future work should explore whether validators could retain only the latest two or three rounds of blocks to ensure storage requirements grow only linearly with the size of the committee. This forces nodes to allocate resources to uncommitted vertices, eventually causing mempool explosions. p. 3 The attack can be sustained indefinitely if the adversary stops creating new vertices when a node is exhausted. p. 3

Final Summary Statement

In this work, we identify a fundamental liveness issue in existing DAG-based BFT protocols and show how it can be exploited by the adversary. The response is to propose Lifefin, a generic and self-stabilizing solution that can efficiently eliminate the liveness issue while only introducing acceptable latency. p. 1

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Identify and eliminate mempool explosions in DAG-based BFT protocols by integrating Lifefin, which uses an Agreement on Common Subset mechanism to commit transactions with bounded resource usage even during adverse conditions. This allows AI systems to maintain liveness by preventing correct nodes from exhausting their resources while maintaining the DAG-based mempool.

  2. Implement a self-stabilizing fallback mechanism in AI consensus protocols that triggers when uncommitted data exceeds a predefined limit or after a timeout, switching to an ACS protocol to commit backlogs with bounded resources. This ensures that even if an inflation attack occurs, the system can autonomously recover and continue processing transactions without stalling.

  3. Enhance transaction ordering consistency by using Proof-of-STuck (PoST) blocks that are verified via a quorum of 2f+1 signatures during the fallback instance, allowing for consistent commitment of leader vertices even when underlying DAG structures are uncertified or malicious nodes propose invalid history. This prevents safety issues like skipping committed leader vertices.

  4. Improve resilience against inflation attacks by ensuring that nodes can always preserve sufficient resources to complete the agreement process, as stated in the paper, which allows Sailfish-Lifefin and Mysticeti-Lifefin to resist inflation attacks by preventing adversaries from exploiting mempool explosions.

Sources

Related papers