DAG-based Consensus with Asymmetric Trust [Extended Version]

Christian Cachin; Ignacio Amores-Sesar; Juan Villacis; Luca Zanolini

REVIEW 2 major objections 4 minor 33 references

DAG-based Consensus with Asymmetric Trust [Extended Version]

T0 review · 2 major / 4 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read The paper presents the first randomized asynchronous DAG-based consensus protocol with asymmetric quorums, where each participant trusts its own list of peers, and claims expected constant-round progress.

desk verdict The counterexample and asymmetric gather are solid, but the headline consensus protocol has a round-transition bug that invalidates the proof as printed. read the letter →

arxiv 2505.17891 v1 pith:3AHR6DJS submitted 2025-05-23 cs.DC

Ignacio Amores-Sesar , Christian Cachin , Juan Villacis , Luca Zanolini This is my paper · ORCID

classification cs.DC MSC 68M1468W15

keywords asymmetricquorumsystemsDAG-basedconsensusasynchronousatomicbroadcastcommoncoregatherprotocolDAG-Ridertrust

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Most DAG-based consensus protocols assume every participant shares the same threshold trust assumption. This paper replaces that with asymmetric quorums, where each process maintains its own list of trusted peers, and argues that the standard constant-round gather primitive breaks under such per-process quorums. It exhibits a 30-process quorum system in which the naive quorum-replacement version of gather produces no common core, and then introduces a corrected constant-round asymmetric gather that uses ACK/READY/CONFIRM control messages to amplify quorum knowledge. On top of that gather, the paper adapts DAG-Rider into an asynchronous randomized atomic broadcast protocol that is claimed to be the first DAG-based consensus protocol with asymmetric quorums, deciding within an expected constant number of waves bounded by the ratio of the participant count to the smallest quorum size.

What carries the argument

The load-bearing object is the asymmetric gather (Algorithm 3), which replaces threshold counting with per-process quorum conditions and inserts an amplification handshake: a process distributes its candidate set, waits for ACK messages from one of its own quorums, sends READY, waits for READY from a quorum, sends CONFIRM, and only then distributes its second-round sets. The effect is that some candidate set from a guild member is guaranteed to have reached a full quorum before second-round sets spread; quorum consistency forces every other guild member's chosen quorum to intersect that set's quorum, so one first-round candidate is contained in every delivered output. In the consensus protocol (Algorithm 4), each four-round wave is one execution of this gather structure, and the commit rule requires that a quorum of round-4 vertices have strong paths to the randomly chosen wave leader. The paper also defines the 'guild' as the set of wise processes that contains a quorum for each of its members; all guarantees are stated for this maximal guild.

What would settle it

Run Algorithm 4 on the 30-process quorum system of Figure 1 with all processes correct and check whether, along any execution, a process reaches line 107 and broadcasts a round-2 vertex while its local DAG for round 1 is missing at least one vertex from every quorum in $Q_i$. The existence of such a vertex would show that the printed code does not satisfy the quorum-membership invariant on which Lemma 4.2 and the liveness argument depend; a corrected guard at line 105 would restore it.

Watch

Extended reading notes

Core claim

The central claim is that randomized asynchronous DAG-based consensus can be realized over asymmetric quorum systems, despite the fact that simply swapping asymmetric quorums into existing common-core primitives does not work. The paper proves the failure by giving a 30-process fail-prone system satisfying the asymmetric quorum-system condition where the quorum-replacement version of the standard three-round gather leaves no common core in any output. It then introduces Algorithm 3, a constant-round asymmetric gather whose ACK/READY/CONFIRM handshake guarantees that at least one guild member's candidate first-round set is held by every guild member when the protocol delivers. Building on this, Algorithm 4 adapts DAG-Rider's wave structure to asymmetric quorums, with round changes gated by per-process quorum conditions and a commit rule requiring strong paths from a quorum of round-4 vertices to the randomly chosen wave leader. The paper argues that the expected number of waves until a leader is committed is at most $|P|/q(Q)$, where $q(Q)$ is the size of the smallest quorum, making the expected latency constant when quorums have linear size.

Load-bearing premise

The load-bearing premise is that a process advances from a round only after receiving that round's vertices from at least one of its own quorums, meaning a set of peers it trusts enough; Algorithm 4 as printed appears to violate this at lines 105-108, where a process can leave round 1 and broadcast a round-2 vertex immediately after broadcasting its own round-1 vertex, before any round-1 quorum has been received, and if that printed transition is real the quorum-membership property used by the proofs does not hold.

Editorial extensions

If this is right

With Algorithm 4, DAG-based atomic broadcast no longer needs a single global failure threshold: each node's own quorum list determines what it waits for, and the protocol still orders messages.
Expected progress remains constant: the number of waves until a leader is committed is at most $|P|/q(Q)$, so as long as quorum sizes grow linearly with the participant count, per-wave latency is bounded in expectation.
The new asymmetric gather is itself a reusable constant-round common-core primitive, so other DAG protocols with common-core commit rules can be converted to the asymmetric model using this machinery rather than the failed quorum-replacement heuristic.
The 30-process counterexample shows that existing asymmetric translations of common-core protocols cannot be used as-is, establishing that the extra control messages in Algorithm 3 are necessary rather than cosmetic.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

A testable next step is to instantiate the new asymmetric gather in a protocol with a two-round common core, mirroring the Tusk-style approach, to see whether the extra control round can be trimmed without losing the common-core guarantee.
The paper's guarantees are stated for the maximal guild; an open question is whether a weaker liveness property can be proven for correct processes that are not wise, since the paper itself notes that naive processes can affect safety and liveness.
Another stress test is to simulate Algorithm 4 on the paper's 30-process counterexample quorum system and compare the empirical commit rate against the $|P|/q(Q)$ bound, using a system engineered to defeat quorum replacement as a clean benchmark.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Two things to know upfront. The Section 3.2 counterexample is real and valuable: it demonstrates that replacing threshold quorums with asymmetric ones inside Canetti-Rabin's three-round gather does not yield a common core. The 30-process quorum system and the Python script in Appendix A check out; this is a genuine negative result that was missing from the literature. The constant-round asymmetric gather in Section 3.3 (Algorithm 3) is also a substantive contribution — a new primitive with plausible, detailed proofs. If I were working on asymmetric trust, I would use this paper as the starting point.

The headline result, however, is not correct as printed. The stress-test note lands. In Algorithm 4, lines 105-108 unconditionally increment the round counter from 1 to 2 and broadcast a round-2 vertex immediately after broadcasting the process's own round-1 vertex, without waiting to receive round-1 vertices from a quorum. The code is very clear: starting from r=0 with a hardcoded quorum in DAG[0], the process reaches the round-1 broadcast, then immediately moves to round 2. Section 4.3 states the round-change rule explicitly — a round is complete only after receiving vertices from all members of one quorum — and the code violates that for round 1. Lemma 4.2 opens with the invariant that any vertex in DAG_i[r] has a strong path to some quorum's vertices in DAG_i[r-1], citing line 99. That invariant is false for r=2 as the code stands. Lemma 4.3, which argues each wave executes an asymmetric gather, is unsupported. The expected-constant-round liveness argument collapses.

This is load-bearing, but it looks localized. A corrected round-advance rule likely restores the proof framework; I do not see an obvious conceptual gap beyond this. The paper also glosses over the leader-sampling setup in Lemma 4.4, but that is minor by comparison.

Bottom line: the negative result and Algorithm 3 deserve to survive. The consensus protocol needs a serious revision and a re-proof before anyone cedes on the main claim. I would send this to referees — the core ideas are important and the flaw is fixable — but accept only after a careful revision.

Referee Report

2 major / 4 minor

Summary. The paper proposes adapting DAG-based consensus to the asymmetric-trust model. It first shows, via a 30-process counterexample and a verifying Python script, that the standard three-round gather protocol fails when threshold quorums are replaced by asymmetric quorums (Section 3.2, Lemma 3.2). It then introduces Algorithm 3, a constant-round asymmetric gather protocol with proofs in Lemmas 3.3-3.8, and Algorithm 4, a DAG-Rider-style asymmetric atomic broadcast protocol claimed to terminate in an expected constant number of rounds proportional to |P|/q(Q). The main contribution is stated as the first randomized asynchronous DAG-based consensus protocol with asymmetric quorums.

Significance. If the protocol were correct as intended, this would be a genuinely novel contribution: it extends the DAG-Rider paradigm to a model where each process chooses its own quorums, and it identifies a non-obvious obstacle in adapting common-core primitives to asymmetric trust. The counterexample of Section 3.2 is a useful negative result, and the provision of a runnable Python verifier is a concrete checkability asset. The intended asymmetric gather protocol (Algorithm 3) and the expected-constant-round argument (Lemma 4.4) are plausible. However, the paper currently contains load-bearing pseudocode errors: Algorithm 4 does not implement the round-change rule on which the proofs of Lemmas 4.2 and 4.3 rely, and Algorithm 3's line 60 has a type-incorrect guard. These issues must be fixed before the central claims can be accepted.

major comments (2)

[Section 4.3, Algorithm 4, lines 105-108 and 117-120] Section 4.3 states that a round is considered complete only when a process has delivered vertices from all members of at least one of its quorums, and that this rule applies to round 1 and round 3 sets. Algorithm 4 does not implement this rule. After line 99 is satisfied for r=0, lines 100-104 create and broadcast the round-1 vertex; then lines 105-108 immediately increment r from 1 to 2 and create/broadcast a round-2 vertex, without checking Q |= DAG[1]. Likewise, after lines 109-116 move from round 2 to round 3, lines 117-120 immediately create a round-4 vertex without waiting for a quorum of round-3 vertices. Because line 81 records strong edges only to the creator's current DAG[round-1] at creation time, a round-2 or round-4 vertex created in this way may have strong edges to only a subset of the previous round, not to a quorum. The invariant used in Lemma 4.2 ("any vertex in DAG_i[r] has a strong path to the vertices produced by some quorum in DAG_i[r-1]") is therefore false for r=2 and r=4, and the claim in Lemma 4.3 that each wave executes an asymmetric gather is not supported. The proofs in Section 4.4 are proofs of a different, more constrained protocol than the one printed.
[Algorithm 3, line 60] The guard "T_j ⊆ S_i" in Algorithm 3 is type-incorrect and appears to be a typo: S_i (lines 38/45) is the set of (process, value) pairs delivered from reliable broadcast, whereas T_j is a set of E-sets. The condition can never be satisfied for a non-empty T_j, so line 60 will never add received T_j sets to U and processes would ag-deliver an empty set even after receiving DISTRIBUTE T messages from a quorum (line 62). The surrounding text says "all correct processes wait to deliver the original input messages before accepting any E or T set that contains them (Lines 48 and 60)", which suggests the intended guard is "T_j ⊆ T_i" or an explicit check that all S-sets in T_j have been accepted. As printed, the asymmetric gather protocol of Section 3.3 does not satisfy the liveness part of Definition 3.1.

minor comments (4)

[Algorithms 4 and 6] The procedure getWaveVertexLeader is defined twice, once in Algorithm 4 (lines 89-93) and again in Algorithm 6 (lines 158-162); one definition should be removed.
[Section 3.3, paragraph 4] There is a typo "DISTRIBTUE T" where "DISTRIBUTE T" is meant.
[Lemma 4.4 and preceding paragraph] The notation q(Q) is used in the abstract and in Lemma 4.4 but is defined only informally in the sentence before Lemma 4.4; please introduce it as a formal definition for precision.
[Algorithm 4, line 140] The condition "∃Q ∈ Q_j for some Q_j ∈ Q : Q |= v.strongEdges" is ambiguous: it should state clearly whether the quorum must belong to the sender's quorum system Q_j or may be drawn from any process's quorum system, since this affects the soundness of vertex validation.

Circularity Check

0 steps flagged · score 2.0 of 10

No substantive circularity; the gather counterexample and Algorithms 3/4 proofs are self-contained, and the only overlapping-author citations are to prior published primitives that are not derived in this paper.

full rationale

The paper's main derivation chain is: (i) show that the quorum-replacement gather fails via an explicit 30-process counterexample with a Python verifier (Section 3.2 and Appendix A); (ii) propose Algorithm 3 and prove common core, validity, and agreement from quorum consistency and the asymmetric reliable-broadcast interface (Lemmas 3.3-3.8); and (iii) build Algorithm 4 as a DAG-embedding of Algorithm 3 and prove safety and liveness via the common-core property and common-coin matching (Lemmas 4.2-4.10). None of these steps defines a claimed result in terms of itself, fits a parameter and then presents it as a prediction, or imports a uniqueness theorem from the authors' prior work to force a choice. The only overlapping-author citations are to Alpos et al. [3] for asymmetric reliable broadcast and common coin and to Amores-Sesar and Cachin [4] in related work; these are prior published building blocks with independent content and are not re-derived or re-defined here, so they do not make the central claim circular. The reader-identified issue in Algorithm 4 lines 105-108, where a process advances from round 1 to round 2 before receiving a quorum of round-1 vertices, is a correctness gap between the printed code and the invariant assumed in Lemma 4.2; it concerns soundness, not circularity, since it does not reduce a prediction to an input by construction. Accordingly, no specific circular step meets the evidentiary bar, and the score reflects only the minor, non-load-bearing self-citation.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

No numerical parameters are fitted. The protocol rests on standard asymmetric quorum theory and on primitives from prior work, plus an unstated uniformity assumption on the common coin. The counterexample uses a constructed quorum system, but that is an input to the negative result, not a fitted parameter.

assumptions (4)

domain assumption Asymmetric Byzantine quorum systems satisfy consistency and availability as defined in Definition 2.1, taken from Alpos et al. [3].
All correctness proofs assume any two quorums of any two processes intersect in a process considered correct by both; this is the standard backbone of quorum-based protocols in the asymmetric model.
domain assumption The maximal guild contains a quorum for each of its members, as stated in Definition 2.2.
Safety and liveness are only guaranteed for processes in the maximal guild; the protocols inherit this guild assumption from the asymmetric trust literature.
domain assumption There exists an asymmetric reliable broadcast and an asymmetric common coin with the properties required by Algorithm 4, attributed to Alpos et al. [3].
The consensus protocol composes these primitives without re-proving them; the paper only cites the prior construction.
ad hoc to paper The asymmetric common coin outputs a uniformly random process as the wave leader.
Lemma 4.4's probability bound requires that the selected leader is uniformly distributed over all processes. The paper does not prove or reference a coin with this specific leader-sampling property.

how reviews work

0 comments

Cite this review

Pith. "Pith review of DAG-based Consensus with Asymmetric Trust [Extended Version]." pith.science (2026). https://pith.science/paper/3AHR6DJS

@misc{pith2026250517891,
  author       = {Pith},
  title        = {Pith review of: DAG-based Consensus with Asymmetric Trust [Extended Version]},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/3AHR6DJS}},
  note         = {Machine review of arXiv:2505.17891}
}

read the original abstract

In protocols with asymmetric trust, each participant is free to make its own individual trust assumptions about others, captured by an asymmetric quorum system. This contrasts with ordinary, symmetric quorum systems and with threshold models, where all participants share the same trust assumption. It is already known how to realize reliable broadcasts, shared-memory emulations, and binary consensus with asymmetric quorums. In this work, we introduce Directed Acyclic Graph (DAG)-based consensus protocols with asymmetric trust. To achieve this, we extend the key building-blocks of the well-known DAG-Rider protocol to the asymmetric model. Counter to expectation, we find that replacing threshold quorums with their asymmetric counterparts in the existing constant-round gather protocol does not result in a sound asymmetric gather primitive. This implies that asymmetric DAG-based consensus protocols, specifically those based on the existence of common-core primitives, need new ideas in an asymmetric-trust model. Consequently, we introduce the first asymmetric protocol for computing a common core, equivalent to that in the threshold model. This leads to the first randomized asynchronous DAG-based consensus protocol with asymmetric quorums. It decides within an expected constant number of rounds after an input has been submitted, where the constant depends on the quorum system.

Figures

Figures reproduced from arXiv: 2505.17891 by the authors.

**Figure 1.** Fail-prone system that leads to no common core in an asymmetric execution of gather. Each process (row) has only one fail-prone set, which is represented by the processes in striped red on its row. Processes in blue represent the canonical quorum associated to said fail-prone set. 3.3 Algorithm Algorithm 3 presents a novel solution to the asymmetric gather problem in a constant number of rounds. It circumvents the i… view at source ↗

**Figure 2.** Values possessed by each process after one round of hearing messages coming from its quorums. Also denoted as sets 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 Messages received after two rounds of receiving messages Processes [PITH_FULL_IMAGE:figures/full_fig_p028_2.png] view at source ↗

**Figure 3.** Values possessed by each process after the second round of receiving messages from one of their \ . Also denoted as sets [PITH_FULL_IMAGE:figures/full_fig_p028_3.png] view at source ↗

Figures from the paper (1 more)

**Figure 4.** Figure 4: Values possessed by each process after the third round of receiving messages from the processes in \ . Also denotes as sets. Observe that there is no set + (where + is a quorum of a wise process) that is received by all processes. This happens because all quorums of al…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

33 extracted references · 21 canonical work pages

[1]

Ittai Abraham, Marcos Kawazoe Aguilera, and Dahlia Malk hi. 2010. Fast Asynchronous Consensus with Optimal Resilie nce. In Distributed Com- puting, 24th International Symposium, DISC 2010, Cambridg e, MA, USA, September 13-15, 2010. Proceedings (Lecture Not es in Computer Science, Vol. 6343). Springer, 4–19. https://doi.org/10.1007/978-3-642-15 763-9_3

work page doi:10.1007/978-3-642-15 2010
[3]

Orestis Alpos, Christian Cachin, Björn Tackmann, and Lu ca Zanolini. 2024. Asymmetric distributed trust. Distributed Comput. 37, 3 (2024), 247–277. https://doi.org/10.1007/S00446-024-00469-1

work page doi:10.1007/s00446-024-00469-1 2024
[4]

Ignacio Amores-Sesar and Christian Cachin. 2024. We Wil l DAG Y ou. In Computer Security. ESORICS 2024 International Workshops - DPM, CBT, and CyberICPS, Bydgoszcz, Poland, September 16-20, 20 24, Revised Selected Papers, Part I (Lecture Notes in Comput er Science, Vol. 15263). Springer, 276–291. https://doi.org/10.1007/978-3-031- 82349-7_19

doi:10.1007/978-3-031- 2024
[5]

Ignacio Amores-Sesar, Christian Cachin, and Jovana Mic ic. 2020. Security Analysis of Ripple Consensus. In 24th International Conference on Principles of Distributed Systems, OPODIS 2020, December 1 4-16, 2020, Strasbourg, France (Virtual Conference) (LIPI cs, Vol. 184) . Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 10:1–10:16. ht tps://doi.org/10.4...

work page doi:10.4230/lipics.opodis.2020.10 2020
[6]

Balaji Arun, Zekun Li, Florian Suri-Payer, Sourav Das, a nd Alexander Spiegelman. 2025. Shoal++: High Throughput DA G BFT Can Be Fast and Robust!. In 22nd USENIX Symposium on Networked Systems Design and Imple mentation, NSDI 2025, Philadelphia, PA, USA, April 28-30, 2 025. USENIX Association, 813–826. https://www.usenix.org/co nference/nsdi25/presentation/arun

work page 2025
[7]

Hagit Attiya and Jennifer Welch. 2004. Distributed Computing: Fundamentals, Simulations and Adv anced Topics (second ed.). Wiley

work page 2004
[8]

Kushal Babel, Andrey Chursin, George Danezis, Anastasi os Kichidis, Lefteris Kokoris-Kogias, Arun Koshy, Alberto Sonnino, and Mingwei Tian. 2025. Mysticeti: Reaching the Latency Lim its with Uncertiﬁed DAGs. In 32nd Annual Network and Dis- tributed System Security Symposium, NDSS 2025, San Diego, C alifornia, USA, February 24-28, 2025 . The Internet Socie...

work page 2025
[10]

Michael Ben-Or and Ran El-Y aniv. 2003. Resilient-opti mal interactive consistency in constant time. Distributed Computing 16, 4 (2003), 249–262

work page 2003

Show all 33 references

[11]

Sam Blackshear, Andrey Chursin, George Danezis, Anast asios Kichidis, Lefteris Kokoris-Kogias, Xun Li, Mark Loga n, Ashok Menon, Todd Nowacki, Alberto Sonnino, Brandon Williams, and Lu Zhang. 2 024. Sui Lutris: A Blockchain Combining Broadcast and Conse nsus. In Proceedings of...

2024
[12]

Gabriel Bracha. 1987. Asynchronous Byzantine Agreeme nt Protocols. Inf. Comput. 75, 2 (1987), 130–143. https://doi.org/10.1016/0890-5401(87)90054-X

1987 doi
[13]

Christian Cachin, Rachid Guerraoui, and Luís E. T. Rodr igues. 2011. Introduction to Reliable and Secure Distributed Programmi ng (2. ed.) . Springer

2011
[14]

Martina Camaioni, Rachid Guerraoui, Matteo Monti, Pie rre-Louis Roman, Manuel Vidigueira, and Gauthier V oron. 20 24. Chop Chop: Byzantine Atomic Broadcast to the Network Limit. In 18th USENIX Symposium on Operating Systems Design and Imple mentation, OSDI 2024, Santa Clara, C...

2024
[15]

Ran Canetti. 1996. Studies in Secure Multiparty Computation and Applications . Ph. D. Dissertation. The Weizmann Institute of Science

1996
[16]

Ran Canetti and Tal Rabin. 1993. Fast asynchronous Byza ntine agreement with optimal resilience. In Proceedings of the Twenty-Fifth Annual ACM Symposium on Theory of Computing, May 16-18, 1993, San Diego , CA, USA, S. Rao Kosaraju, David S. Johnson, and Alok Aggarwal (Eds.) . ...

1993
[17]

Miguel Castro and Barbara Liskov. 2002. Practical byza ntine fault tolerance and proactive recovery. ACM Trans. Comput. Syst. 20, 4 (2002), 398–461

2002
[18]

Brad Chase and Ethan MacBrough. 2018. Analysis of the XR P ledger consensus protocol. arXiv preprint arXiv:1802.07242 (2018)

2018 arXiv
[19]

Raymond Strong, and Danny Dolev

Flaviu Cristian, Houtan Aghili, H. Raymond Strong, and Danny Dolev. 1995. Atomic Broadcast: From Simple Message Di ffusion to Byzantine Agreement. Inf. Comput. 118, 1 (1995), 158–179

1995
[20]

Ivan Damgård, Yvo Desmedt, Matthias Fitzi, and Jesper B uus Nielsen. 2007. Secure Protocols with Asymmetric Trust. In Advances in Cryptology - ASIACRYPT 2007, 13th International Conference on the Theo ry and Application of Cryptology and Information Security, Kuching, Malaysia...

2007 doi
[21]

George Danezis, Lefteris Kokoris-Kogias, Alberto Son nino, and Alexander Spiegelman. 2022. Narwhal and Tusk: a DA G-based mempool and efﬁcient BFT consensus. In EuroSys ’22: Seventeenth European Conference on Computer S ystems, Rennes, France, April 5 - 8, 2022 . ACM, 34–50. h...

2022
[22]

Idit Keidar, Eleftherios Kokoris-Kogias, Oded Naor, a nd Alexander Spiegelman. 2021. All Y ou Need is DAG. In PODC ’21: ACM Symposium on Principles of Distributed Computing, Virtual Event, Italy , July 26-30, 2021 . ACM, 165–175. https://doi.org/10.1145/3465084.346790 5 DAG-ba...

2021
[23]

Idit Keidar, Oded Naor, Ouri Poupko, and Ehud Shapiro. 2 023. Cordial Miners: Fast and Efﬁcient Consensus for Every E ventuality. In 37th International Symposium on Distributed Computing, DISC 2023, October 10-12, 2023, L’Aquila, Italy (LIPIcs, Vol. 281). Schloss Dagstuhl - Le...

2023
[24]

Marta Lokhava, Giuliano Losa, David Mazières, Graydon Hoare, Nicolas Barry, Eli Gafni, Jonathan Jove, Rafal Malin owsky, and Jed McCaleb
[25]

Giuliano Losa, Eli Gafni, and David Mazières. 2019. Ste llar Consensus by Instantiation. In 33rd International Symposium on Distributed Com- puting, DISC 2019, October 14-18, 2019, Budapest, Hungary ( LIPIcs, Vol. 146). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 27:1– ...

2019 doi
[26]

Dahlia Malkhi and Michael K. Reiter. 1998. Byzantine Qu orum Systems. Distributed Comput. 11, 4 (1998), 203–213. https://doi.org/10.1007/S004460050050

1998 doi
[27]

David Mazieres. 2015. The Stellar consensus protocol: A federated model for internet-level consensus. Stellar Development Foundation 32 (2015), 1–45. Available online from https://stellar.org/learn/s tellar-consensus-protocol

2015
[28]

Moni Naor and Avishai Wool. 1998. The Load, Capacity, an d Availability of Quorum Systems. SIAM J. Comput. 27, 2 (1998), 423–447

1998
[29]

Victor Shoup. 2024. Blue ﬁsh, red ﬁsh, live ﬁsh, dead ﬁsh . IACR Cryptol. ePrint Arch. (2024), 1235

2024
[30]

Alberto Sonnino. 2024. BFT Consensus: From Academic Pa per to Mainnet (Invited Talk). In 28th International Conference on Principles of Distributed Systems, OPODIS 2024, December 11-13, 2024, Lu cca, Italy (LIPIcs, Vol. 324) . Schloss Dagstuhl - Leibniz-Zentrum für Informatik,...

2024 doi
[31]

Alexander Spiegelman, Balaji Aurn, Rati Gelashvili, a nd Zekun Li. 2023. Shoal: Improving DAG-BFT Latency And Robu stness. CoRR abs/2306.03058 (2023)

2023 arXiv
[32]

Alexander Spiegelman, Neil Giridharan, Alberto Sonni no, and Lefteris Kokoris-Kogias. 2022. Bullshark: DAG BFT P rotocols Made Practical. In Proceedings of the 2022 ACM SIGSAC Conference on Computer an d Communications Security, CCS 2022, Los Angeles, CA, USA, N ovember 7-11,

2022
[33]

Reiter, Guy Golan -Gueta, and Ittai Abraham

Maofan Yin, Dahlia Malkhi, Michael K. Reiter, Guy Golan -Gueta, and Ittai Abraham. 2019. HotStuff: BFT Consensus wi th Linearity and Respon- siveness. In Proceedings of the 2019 ACM Symposium on Principles of Distr ibuted Computing, PODC 2019, Toronto, ON, Canada, July 29 - A ...

2019
[2019]

In Proceedings of the 27th ACM Symposium on Operating Systems P rinciples, SOSP 2019, Huntsville, ON, Canada, October 27-30, 2019

Fast and secure global payments with Stellar. In Proceedings of the 27th ACM Symposium on Operating Systems P rinciples, SOSP 2019, Huntsville, ON, Canada, October 27-30, 2019 . ACM, 80–96. https://doi.org/10.1145/3341301.3359636

2019
[2022]

https://doi.org/10.1145/3548606.3559 361

ACM, 2705–2718. https://doi.org/10.1145/3548606.3559 361

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [1]

Ittai Abraham, Marcos Kawazoe Aguilera, and Dahlia Malk hi. 2010. Fast Asynchronous Consensus with Optimal Resilie nce. In Distributed Com- puting, 24th International Symposium, DISC 2010, Cambridg e, MA, USA, September 13-15, 2010. Proceedings (Lecture Not es in Computer Science, Vol. 6343). Springer, 4–19. https://doi.org/10.1007/978-3-642-15 763-9_3

work page doi:10.1007/978-3-642-15 2010

[2] [3]

Orestis Alpos, Christian Cachin, Björn Tackmann, and Lu ca Zanolini. 2024. Asymmetric distributed trust. Distributed Comput. 37, 3 (2024), 247–277. https://doi.org/10.1007/S00446-024-00469-1

work page doi:10.1007/s00446-024-00469-1 2024

[3] [4]

Ignacio Amores-Sesar and Christian Cachin. 2024. We Wil l DAG Y ou. In Computer Security. ESORICS 2024 International Workshops - DPM, CBT, and CyberICPS, Bydgoszcz, Poland, September 16-20, 20 24, Revised Selected Papers, Part I (Lecture Notes in Comput er Science, Vol. 15263). Springer, 276–291. https://doi.org/10.1007/978-3-031- 82349-7_19

doi:10.1007/978-3-031- 2024

[4] [5]

Ignacio Amores-Sesar, Christian Cachin, and Jovana Mic ic. 2020. Security Analysis of Ripple Consensus. In 24th International Conference on Principles of Distributed Systems, OPODIS 2020, December 1 4-16, 2020, Strasbourg, France (Virtual Conference) (LIPI cs, Vol. 184) . Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 10:1–10:16. ht tps://doi.org/10.4...

work page doi:10.4230/lipics.opodis.2020.10 2020

[5] [6]

Balaji Arun, Zekun Li, Florian Suri-Payer, Sourav Das, a nd Alexander Spiegelman. 2025. Shoal++: High Throughput DA G BFT Can Be Fast and Robust!. In 22nd USENIX Symposium on Networked Systems Design and Imple mentation, NSDI 2025, Philadelphia, PA, USA, April 28-30, 2 025. USENIX Association, 813–826. https://www.usenix.org/co nference/nsdi25/presentation/arun

work page 2025

[6] [7]

Hagit Attiya and Jennifer Welch. 2004. Distributed Computing: Fundamentals, Simulations and Adv anced Topics (second ed.). Wiley

work page 2004

[7] [8]

Kushal Babel, Andrey Chursin, George Danezis, Anastasi os Kichidis, Lefteris Kokoris-Kogias, Arun Koshy, Alberto Sonnino, and Mingwei Tian. 2025. Mysticeti: Reaching the Latency Lim its with Uncertiﬁed DAGs. In 32nd Annual Network and Dis- tributed System Security Symposium, NDSS 2025, San Diego, C alifornia, USA, February 24-28, 2025 . The Internet Socie...

work page 2025

[8] [10]

Michael Ben-Or and Ran El-Y aniv. 2003. Resilient-opti mal interactive consistency in constant time. Distributed Computing 16, 4 (2003), 249–262

work page 2003