Abstract 1 Introduction 2 Related Work 3 Preliminaries 4 Impossibility Result 5 Possibility Results 6 Conclusion References

How Much Public Randomness Do Modern Consensus Protocols Need?

Joseph Bonneau ORCID New York University, NY, USA Benedikt Bünz ORCID New York University, NY, USA Miranda Christ ORCID Columbia University, New York, NY, USA Yuval Efron ORCID Columbia University, New York, NY, USA
Abstract

Modern blockchain-based consensus protocols aim for efficiency (i.e., low communication and round complexity) while maintaining security against adaptive adversaries. These goals are usually achieved using a public randomness beacon to select roles for each participant. We examine to what extent this randomness is necessary. Specifically, we provide tight bounds on the amount of entropy a Byzantine Agreement protocol must consume from a beacon in order to enjoy efficiency and adaptive security. We first establish that no consensus protocol can simultaneously be efficient, be adaptively secure, and use O(logn) bits of beacon entropy. We then show this bound is tight and, in fact, a trilemma by presenting three consensus protocols that achieve any two of these three properties.

Keywords and phrases:
Consensus, Randomness Beacon
Copyright and License:
[Uncaptioned image] © Joseph Bonneau, Benedikt Bünz, Miranda Christ, and Yuval Efron; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Distributed algorithms
Editors:
Zeta Avarikioti and Nicolas Christin

1 Introduction

Consensus is a cornerstone of distributed computing, with research spanning over four decades [33, 28]. In the consensus problem, n players (or nodes) with respective inputs must engage in communication in order to reach agreement on a value. The challenge stems from the presence of at most f corrupted (eq. Byzantine) players, which may deviate from any given protocol in arbitrary ways.

The consensus problem has been considered under a myriad of constraints and allowances across various axes, including network synchrony, setup assumptions, the use of randomness by honest players, and the capabilities of the adversary (Garay and Kiayias [20] provide a detailed survey). With the renewed interest in this problem due to its foundational role in blockchains, two properties of particular importance from a practical point of view have been efficiency and adaptive security.

  1. 1.

    Efficiency. We consider an efficiency notion motivated by modern blockchain-related consensus protocols. We say that a protocol has low communication (or in other words, is laconic) if in every round few of the players (i.e., o(n)<<n) send messages. A protocol has low latency if it requires at most o(n) rounds. We refer to a protocol as efficient if it has both low communication and low latency. Our efficiency notion is essential for consensus protocols to scale to thousands of players and finalize transactions quickly. Indeed, most modern blockchain systems (e.g., Bitcoin and Ethereum) are efficient in this sense.

  2. 2.

    Adaptive Security. We say that a consensus protocol is secure against an adaptive adversary if it solves consensus even when the adversary may choose to corrupt players “on the fly,” based on its observations thus far. We consider both a basic adaptive adversary which can corrupt up to f players at any point based on the current transcript of the protocol, but cannot un-corrupt them, and a mobile blocking adversary which can choose potentially new players to target in each round but can only block their messages, and not cause arbitrary behavior.

Observe that either of these properties is straightforward to achieve without the other: if efficiency is not important, classical Byzantine fault-tolerant consensus protocols [10] are adaptively secure. On the other hand, Nakamoto-style consensus [32] with round-robin leader election is efficient against a non-adaptive adversary, but has linear latency against an adaptive adversary.

In practice, the vast majority of blockchains, including Ethereum and Bitcoin, aim to achieve both of the above properties. They do so by relying on a source of shared randomness for the players, for tasks such as leader election and committee sampling [5, 32, 14]. Such a primitive that provides access to fresh randomness at every point in time is referred to in the literature as a randomness beacon [34]. Implementing such a beacon, however, is an expensive task, with current constructions either employing delay functions [29, 7], requiring many rounds or much communication [37, 12, 35, 24], or achieving a sub-optimal version of the ideal functionality subject to manipulation [22, 5].

On the other hand, it turns out, that the use of unpredictable randomness is essential to the design of efficient consensus protocols [17, 6, 1]. Dolev and Reischuk [17] show that any deterministic protocol must have Ω(n2) communication complexity. Bar-Joseph and Ben-Or [6] show that against a computationally unbounded adaptive adversary that can view the local state of all players, any (even randomized) synchronous 𝖡𝖠 protocol requires Ω~(n) rounds. Abraham et al. [1] show that without unpredictable randomness, any consensus protocol must use Ω(n2) communication.

1.1 Our Setting

The goal of this paper is to quantify the precise amount of randomness that must be drawn from such a beacon to allow for efficient and adaptively secure consensus protocols. We make minimal auxiliary assumptions, focusing on the information-theoretic (i.e., a computationally unbounded111Under computational assumptions, e.g., using a delay function, a beacon can be constructed. The unbounded adversary setting enables us to isolate the utility of the beacon. adversary and no PKI), synchronous setting. Specifically, we consider the following ideal functionality for a beacon: At each round t, a fresh, uniformly random string is revealed to all players.

Such an assumption, referred to as an idealized common coin or randomness beacon is a common assumption in the 𝖡𝖠 protocols for asynchronous networks [15, 31]. We say that a protocol has low beacon entropy if it can be implemented using a randomness beacon that generates O(logn) bits in total during the protocol. We stress that it is important that the random string revealed to all players at round t is not only uniform, but also is unpredictable prior to round t. In other words, no adversary can predict the contents of the string of round t prior to round t. Abraham et al. [1] show that any protocol secure against an adversary that can predict the content of the beacon ahead of time, must use Ω(n2) communication. We emphasize that our lower bound applies even when the protocol has access to our beacon with stronger unpredictability.

1.2 Our Results

We provide a complete and tight characterization of efficiency, adaptive security, and low beacon randomness:

Impossibility (Section 4, Theorems 7 and 8):

We show that no consensus protocol can simultaneously achieve all three properties. That is, any efficient, adaptively secure consensus protocol must use a randomness beacon that outputs ω(logn) bits. Our impossibility result holds against a computationally unbounded adversary in a broadcast communication model.

Possibility (Section 5, Lemmas 9, 15, and 17):

We show that the above impossibility is tight by presenting three consensus protocols, each realizing exactly two of the above three properties. Our protocols work against a computationally unbounded adversary in a peer-to-peer communication model. Together, they demonstrate a trilemma: consensus protocols can achieve any two of efficiency, adaptive security and low-entropy, but not all three.

2 Related Work

A long line of work considers a computationally bounded adversary [13, 2, 18, 21]. Protocols in this setting employ cryptographic tools to enable adaptive secure consensus protocols with as few as O(1) rounds (in expectation). This research culminates in the work of Ghinea, Goyal and Liu-Zhang [21], which matches the decades-old lower bound Chor, Merritt, and Shmoys [13] which states that any r round consensus protocol has error probability at least Ω(1rr).

Coming back to an unbounded adversary, other works [26, 36, 8, 1, 16] consider relaxed versions of the adaptive adversary, and design consensus protocols that circumvent the aforementioned round and communication lower bounds of [1, 6].

Adaptively secure consensus.

By Abraham et al. [1], any protocol that is secure against a strongly adaptive adversary must use Ω(n2) bits of communication. This bound is known to be tight in the setting of a computationally bounded adversary by the work of Abraham et al. [2]. The protocol of this work also achieves optimal O(1) round complexity, in expectation.

Adversary Relaxations.

On the road to circumventing the lower bounds of [1, 6], various relaxations to the strongly rushing adversary have been considered.

  • A typical relaxation is that if the adversary chooses to corrupt a player p at round r, player p still performs the honest behaviour of round r prior to the adversary taking control of p (at which point the adversary can send additional messages, still in round r). Protocols achieving o(n2) communication complexity under this assumption include the work of King and Saia [26], and the follow up work by King, Lonargan, Saia and Trehan [25] in which they show protocols with O(n1.5) communication complexity. Additional cryptographic assumptions allow the design of protocols with nearly linear communication complexity [8, 11, 2, 9]. Another class of protocol circumventing the communication lower bound of [1] are motivated by blockchain applications, and make use of proof-of-work or proof-of-stake assumptions [16, 32].

  • Another line of work considers a late adaptive adversary. Roughly, this is an adaptive adversary with an outdated view of the state of the protocol. At each round the adversary may choose players to corrupt based on all information available so far, however the actual corruption occurs several rounds later. Most of these works consider relaxed variants of the consensus problem, e.g., almost-everywhere consensus [36, 4, 3, 27].

  • A mobile blocking adversary has been considered previously in [36], and is generally related to the well studied model of omission failures [30, 23].

Randomness beacon entropy.

As mentioned, the idealized randomness beacon assumption, also known as a common coin, is extensively used in consensus protocol design in asynchronous networks (See [31] and references within). A recent work [23] studies a similar question to ours. Specifically, they consider protocols secure against an adaptive omission failure adversary, and characterize the trade-off between the required number of oracle calls to a random beacon and the round complexity.

3 Preliminaries

Notation.

We let λ denote the security parameter. If a function f(λ) is O(1/𝗉𝗈𝗅𝗒(λ)) for every polynomial in λ, we say f is negligible in λ. We write f=𝗇𝖾𝗀𝗅(λ). We let log(x) denote the logarithm base 2 of x. If X is a random variable over domain Ω, and Supp(X)={xΩPr[X=x]>0}, we denote the min-entropy of X by H(X)=minxSupp(X)1Pr[X=x].

Model.

We consider a network of n players (eq. nodes or participants). We focus here on the permissioned setting, in which the set of n players is fixed and known to all players in advance. At most f players can be corrupt. We further assume that communication takes place over a synchronous network with maximum message delay of Δ, i.e. a player p at round t has received all messages sent to it up to round tΔ. For simplicity of exposition, we assume that Δ=1, but all our results extend naturally to the general case of delay parameter Δ. Throughout the paper we consider two models for a communication network. In the peer-to-peer model, players may send different messages to different players during each round. In the broadcast model, players (including corrupted players) may only broadcast a message, which is received by all other players.

Specifically, the latter model does not allow corrupt players to equivocate. Our lower bound holds even in the more generous broadcast model, and our upper bounds hold even in the more general peer-to-peer model of communication.

Adversary model.

All of the adversaries considered in the paper are computationally unbounded, and in particular we assume no PKI (though we do assume authenticated channels between participants). Specifically, we consider three types of adversaries, static, adaptive, and mobile blocking. Let f be the adversary’s corruption budget. It is useful for us to consider an adversary as a pair of algorithms 𝒜=(𝒜0,𝒜1), where 𝒜0 is responsible for choosing the identities of up to f corrupted players at every round t, and 𝒜1 is the adversary participating in the protocol. A bit more formally, at each round t, 𝒜0 may observe (Π,t,Trt) and output a set t of at most f players. Here, Π is a description a protocol and Trt refers to the transcript of a protocol up to round t (see Definition 2). Each adversary type we consider imposes different restrictions on either 𝒜0 or 𝒜1.222One might ask about the possibility of a mobile adversary capable of corruption, but this is tricky to reason about as it requires a notion of “un-corrupting” players.

  • Static. The static adversary chooses the identities of f corrupt players at round t=0, and this choice is fixed throughout the execution of the protocol. The adversary has complete control over the behaviour of the corrupted players. In other words t=0 for all t. There are no restrictions on 𝒜1.

  • Adaptive. At the beginning of each round t, the adversary chooses the identities of ft<f players to corrupt in that round, based on its observations of the transcript of the protocol and the players it has corrupted thus far. These players stay corrupted for the rest of the execution. In other words, tt+1 for all t. There are no restrictions on 𝒜1.

  • Mobile blocking. A mobile blocking adversary can, at every round, observe (Π,t,Trt), where t is a round, and Trt is the transcript of Π up to round t, and output a set t of at most f players that are prohibited from sending messages at round t. We emphasize that unlike the adaptive adversary which is constrained by the total number of corruptions, the mobile adversary may corrupt up to f players in each round regardless of how many players it has corrupted in the past. A mobile blocking adversary is also captured by the (𝒜0,𝒜1) notation via 𝒜0(Π,t,Trt)=S, and 𝒜1 be an adversary behaviour in which corrupted players send no messages.

In any adversary variant, we say that an adversary corrupting at most f=ρn players is ρ-bounded.

Randomness.

The protocols we consider in this work have two main sources of randomness. For both of them, we assume an ideal functionality as our goal is to reason about the nature and amount of randomness required to design consensus protocols.

  1. 1.

    Common Random String (CRS). We assume that at round t=0, an arbitrarily long (as per the protocol’s specification) uniformly random string 𝖢𝖱𝖲 is revealed to all players. A static adversary must choose the identities of corrupt players prior to the CRS being revealed. An adaptive or mobile adversary can choose the identities of corrupt players after 𝖢𝖱𝖲 is revealed.

  2. 2.

    Randomness Beacon. A randomness beacon is an oracle that at every round t, produces a fresh uniformly random string 𝗌𝖾𝖾𝖽t of an arbitrary length (as per the protocol’s specification). In particular, for each round t, an adaptive or a mobile adversary must choose the identities of corrupted players prior to the revelation of 𝗌𝖾𝖾𝖽t.

Clearly, in the presence of an adaptive adversary the latter source of randomness is significantly more powerful than the former. It is precisely the latter source of randomness that is the main focus of this paper.

Authenticated Channels.

Similarly to prior work [26, 8], we assume that communication channels in our network are authenticated. Intuitively, this means that each player knows the identity of the sender for any message received. This can be formalized by instantiating communication channels with a map that maps a message m to the tuple (m,p), where p is the sender of m. This mapping is fixed and can not be tampered with by the adversary.

Executions.

An execution is a tuple E=(Π,𝒜,r) where Π is the protocol run by honest players. 𝒜 is a particular adversary, i.e. 𝒜 is an algorithm that chooses corrupt players (only at t=0 if static, otherwise 𝒜0 chooses at every round t) based on the transcript of the protocol and internal state of corrupt players, and instructions for the behaviour of the environment. r denotes the random coins of all players. Given a protocol Π we say that E is an execution of Π if the first component of E is Π.

We say that an execution is admissible in the adaptive model if for all rounds t0 it holds that ft<13n. In the static model we further demand that the identities of corrupt players remain fixed throughout the execution of the protocol. At times we abuse notation and refer to an execution also as the random variable (Π,𝒜) which is a distribution over executions in which Π is the protocol run by honest players, and 𝒜 is the adversary (corrupt players in each round, and actions taken by them). We denote this random variable by E𝒜.

The specification of the consensus problem we consider takes the form of the well known Byzantine Agreement problem [33, 28].

Byzantine Agreement (𝗕𝗔).

In the 𝖡𝖠 task, n players must come to an agreement on a bit under some constraints. Each player Pi has an input bi{0,1}, and produces an output oi{0,1}. We say that a protocol Π solves the 𝖡𝖠 task if the following three properties are guaranteed by Π, except for with 𝗇𝖾𝗀𝗅(λ) probability.

  1. 1.

    Termination. There exists t such that all honest players have produced an output by round t.

  2. 2.

    Agreement. For any pair of honest players Pi,Pj, the probability (over the randomness of the adversary and the protocol) that these players output different values is at most 𝗇𝖾𝗀𝗅(λ).

  3. 3.

    Validity. If all honest players have the same input bit b, then all honest players always output b.

An additional critical notion relating to a 𝖡𝖠 protocol is latency, which is defined as follows. Intuitively, latency captures the expected number of rounds it takes for Π to terminate.

Definition 1 (Latency).

Let Π be a protocol solving BA, and let Ti,𝒜 denote the random variable indicating the round in which player i terminates given an adversary 𝒜 corrupting some subset of the players. Given an execution E=(Π,𝒜,r), let HE denote the set of players that remain honest throughout the entire execution. Π has expected latency given f corruptions if for all adversaries 𝒜 corrupting at most f players,

max(Π,𝒜)𝒜 corrupts at most f players𝔼E=(Π,𝒜,r)[maxpHETp,𝒜].

Randomness beacon.

In this paper, we consider an -bit randomness beacon to be an n-party protocol Π𝒪 with access to a random oracle 𝒪 that satisfies termination and agreement and, on input 1λ, outputs a string s of length (λ). Furthermore, the value output by the honest parties must be computationally indistinguishable from random, in the random oracle model. In other words, the adversary responsible with distinguishing between the uniform distribution and the output of the beacon is only bounded in its number of queries to the random oracle, but not in any other manner. In particular, it can perform arbitrary computation. More precisely, let 𝒜 be any (computationally unbounded) adversary corrupting f out of n players. Let 𝒪 by any computationally bounded distinguisher, making poly(λ) queries to the random oracle 𝒪. Denote by vΠ𝒜𝒪 the output of the honest parties from an execution of Π with the adversary 𝒜. For any such 𝒜,𝒪 it must hold that:

|Pr[𝒪(1λ,v)=1:vΠ𝒜𝒪]Pr[𝒪(1λ,r)=0:r{0,1}(λ)]|𝗇𝖾𝗀𝗅(λ).

We say that Π𝒪 is secure against a static/adaptive/mobile blocking adversary if the above holds and 𝒜 is a static/adaptive/mobile blocking adversary respectively. We note that the definition of a randomness beacon varies throughout the literature; here, we consider a weak notion where the adversary corrupting parties during the protocol execution is different from the adversary attempting to distinguish the beacon output from random. This notion is still nontrivial.

4 Impossibility Result

In the following, we define formal notions in order to rigorously discuss the amount of common randomness consumed by a 𝖡𝖠 protocol with adaptive security and low communication. Recall that in this section, we assume to be in the broadcast model of communication. We begin with defining the transcript of a protocol.

Definition 2 (Transcript).

Consider a 𝖡𝖠 protocol Π for a network of n players, and let 𝒜=(𝒜0,𝒜1) denote some adversary. Denote by E𝒜 the random variable of executions under (Π,𝒜). We define the transcript TrE𝒜 to be the random variable that indicates the identities and contents of the players speaking in each round. Formally, we have

  • TrE𝒜={TrE𝒜t}t

  • TrE𝒜t=(IE𝒜t,CE𝒜1t,A𝒜t,𝗌𝖾𝖾𝖽t,𝖢𝖱𝖲), where IE𝒜0t[n] is a subset of honest players at round t, and CE𝒜t({0,1})IE𝒜t denotes the messages of those players. Furthermore, an honest player pi speaks in round t iff iIE𝒜t, and the message it sends is consistent with CE𝒜t. A𝒜t contains the identities of the adversarial parties speaking at round t and the contents of their messages

We consider the following notion of unpredictability, that intuitively says that the probability that an adaptive adversary can guess correctly the set of speaking parties in every round, given the transcript of the protocol up to that round is negligible.

Definition 3 (Adversary’s guess of speaking parties).

Let Π be a consensus protocol, and let 𝒜=(𝒜0,𝒜1) be an adversary. We define the adversary’s guess to be a series (I𝒜0^,I𝒜1^,I𝒜2^,) given by an algorithm 𝒜2 of the adversary’s choice where for each t,

I^𝒜,𝒜2t𝒜2(Π,{TrE𝒜i0it1},t)

Given the above definition, we can now define global leader unpredictability:

Definition 4 (Global leader unpredictability).

Let Π be a 𝖡𝖠 protocol. We say that Π has global leader unpredictability if for any adversaries 𝒜=(𝒜0,𝒜1) and 𝒜2,

Pr[t,I^𝒜,𝒜2t=IE𝒜0t𝖢𝖱𝖲]=t=0Pr[I^𝒜,𝒜2t=IE𝒜0t{IE𝒜0i0i<t},𝖢𝖱𝖲]𝗇𝖾𝗀𝗅(λ)

We now prove that if a protocol Π satisfies global leader unpredictability, then its transcript contains a significant amount of min-entropy.

Lemma 5.

Let Π be a 𝖡𝖠 protocol that satisfies global leader unpredictability. Then for any constant c>0 and any adversary 𝒜=(𝒜0,𝒜1),

t=0H(TrE𝒜t{TrE𝒜i0i<t},𝖢𝖱𝖲)clogn.

Proof.

Assume towards a contradiction that there exist a constant c>0 and an adversary 𝒜=(𝒜0,𝒜1) such that

t=0H(TrE𝒜t{TrE𝒜i0i<t},𝖢𝖱𝖲)<clogn.

Now for each t, denote by kt the value H(TrE𝒜t{TrE𝒜i0i<t},𝖢𝖱𝖲). Applying f(x)=12x to both sides of the inequality above, we get that

12t=0kt>1nc

Thus, by definition of min-entropy, we have that there exist strings St,t s.t.

12kt=Pr[TrE𝒜t=St{TrE𝒜i0i<t},𝖢𝖱𝖲]

We thus have that

Pr[t,TrE𝒜t=St𝖢𝖱𝖲]=t=0Pr[TrE𝒜t=St{TrE𝒜i0i<t},𝖢𝖱𝖲]>1nc

where the first transition is by definition of the probability of event intersection. Since IE𝒜t is a part of TrE𝒜t, we thus get that there exists set I^t,t s.t.

Pr[t,IE𝒜t=I^t𝖢𝖱𝖲]>1nc

Now note that an adversary 𝒜2 that predicts at round t the set I^t can realize this success probability, thus violating the global leader unpredictability condition, as required. Such an adversary is realizable both in the adaptive and mobile blocking models since the adversary at round t has definitive knowledge of the transcript up to and including round t1, including 𝖢𝖱𝖲.

We would now like to prove that the lack of the global unpredictability condition, combined with low communication, implies susceptibility to attacks by adaptive adversaries. With the notion of a transcript in hand, we can also now formally define the relevant notion for this paper of low communication.

Definition 6.

Let Π be a consensus protocol, and let 𝒜=(𝒜0,𝒜1) be an adversary. We define the communication complexity of Π to be the random variable C=t|IE𝒜t|. We say that the communication is uniform if there exists T such that except for with 𝗇𝖾𝗀𝗅(λ) probability it holds that |IE𝒜t|=O(CT) for all tT and |IE𝒜t|=0 for all t>T. We refer to CT as the uniform communication complexity of Π. We say that a protocol has low communication if it has uniform communication of o(n).

The goal of defining uniform communication, as opposed to just considering the general number of bits exchanged between players in the protocol, is to speak rigorously about protocols in which only a few players speak in each round. We now aim to prove the following theorem, which says that any 𝖡𝖠 protocol in which few players speak in every round, uses low beacon entropy, and is adaptively secure, requires many rounds. In other words, no 𝖡𝖠 protocol can simultaneously be efficient, adaptively secure, and use low beacon entropy.

Theorem 7.

Let Π be a protocol that has the following properties:

  • Π does not satisfy global leader unpredictability.

  • Except for O(1) initial rounds, Π has uniform communication complexity k

Then w.p. 1p(n) for some polynomial p, Π requires Ω(ρnk) rounds in the presence of a ρ-bounded adaptive adversary, for any ρkn. Furthermore, if a mobile blocking adversary is considered, then Π does not exist for any ρkn.

Proof.

By the assumption that Π does not satisfy global leader unpredictability, we deduce that there exist a polynomial p(n) and adversaries 𝒜=(𝒜0,𝒜1) and 𝒜2 such that

Pr[t,I^𝒜,𝒜2t=IE𝒜0t𝖢𝖱𝖲]1p(n).

Now consider the following adversary =(0,1), acting as follows. Let r=O(1) be the number of initial rounds which may have high communication complexity. In the following, we employ a well-known result [13], which states that any 𝖡𝖠 protocol with r rounds has error probability of at least Ω(1nr), with the adversary needing to corrupt at most r players [13]. In our case, Ω(1nr)=1/nO(1).

  1. 1.

    For the first r rounds, employ the adversary strategy [13], corrupting at most r players in the process.

  2. 2.

    0 acts as follows: At the beginning of any round t>r, use 𝒜2(Π,{TrE𝒜i0i<t}) to obtain I^𝒜,𝒜2t. In the case of the adaptive adversary, corrupt all the players in I^𝒜,𝒜2t until the total number of corrupted parties has reached the corruption budget ρn. In the case of a mobile blocking adversary, corrupt them for round t.

  3. 3.

    1 sends no messages by the corrupted players; that is, the players in I^𝒜,𝒜2t. Note that this is compatible behaviour with the mobile blocking adversary, in addition to the adaptive adversary.

From here on in, the analysis is conditioned on the event that 𝒜2 has guessed correctly the identity of speakers at all rounds, which occurs w.p. at least 1p(n), by assumption. Due to the strategy of [13], we have that with at least inverse polynomial probability, Π does not solve 𝖡𝖠 up to round r of the execution. For the following Ω(ρnk) rounds, no progress is made since the adversary corrupts all parties participating in the protocol for those rounds. Thus at least with inverse polynomial probability, Π requires Ω(ρnk) rounds, as required. In the case of a mobile blocking adversary, no progress is made at all, indefinitely, and so in particular the protocol either has no termination, or has error probability at least Ω(1nrp(n)), which is a contradiction.

We now show that global leader unpredictability implies a randomness beacon. This randomness beacon simply runs Π and computes the hash(i.e. queries the random oracle) of the identities that spoke in each round. Since these identities are unpredictable, given enough parties there is sufficient randomness to construct a beacon.

Corollary 8.

Let Π be an n-party protocol satisfying global leader unpredictability. If nλ, there exists a randomness beacon Π𝒪 such that:

  • Π𝒪 has the same communication complexity and latency as Π.

  • Π𝒪 outputs λ bits that are indistinguishable from random by any efficient (poly(λ) query) adversary in the random oracle model.

Proof.

Let 𝒪:{0,1}{0,1}λ be a hash function which we model as a random oracle. Let Π𝒪 be the protocol obtained by running Π and outputting the hash(i.e. querying the oracle 𝒪) of the identities of the parties that speak in each round of Π. Observe now that Π𝒪 trivially satisfies the first bullet point, since it involves only running Π and applying a function to its transcript. Since we operate in the broadcast setting with authenticated channels, all parties know these identities of speaking parties. Recall that global leader unpredictability states that this tuple of speaking parties has at least clogn min-entropy for any constant c. Therefore, for any fixed string s, the probability that this tuple of identities equals s is at most 1/λc for any constant c. Let 𝒪 be a computationally bounded adversary making a polynomial number of queries to the random oracle 𝒪. The probability that queried the tuple of speaking parties to 𝒪 is smaller than the inverse of any polynomial, which is negligible. Therefore, except with negligible probability the hash of the tuple of speaking parties is a freshly random value from the perspective of 𝒪.

5 Possibility Results

Having established the above trade-off, we turn to showing that it exactly captures the role of randomness in efficient and adaptively secure 𝖡𝖠. Specifically, we present three protocols solving 𝖡𝖠, all simplified versions of known protocols from the literature, and prove that each of them satisfies two of the three properties we described above. To make our results as strong as possible, throughout this section, we consider a model where players are deterministic and all players are given access to an ideal randomness beacon and a 𝖢𝖱𝖲. Recall (see Section 3) that an adaptive adversary must make corruption choices for round r prior to seeing the beacon output of round r. While for the lower bound result we assumed a broadcast model of communication, we assume a peer-to-peer network for the upper bounds, to make our results as strong as possible. In particular, corrupt players can equivocate. We formally describe our framework and general 𝖡𝖠 protocol in the following section, and then showcase how this framework is instantiated in three ways to obtain protocols:

  1. 1.

    Efficiency and adaptive security. We show that when entropy from a beacon is not limited, there exists a protocol that is adaptively secure and efficient. The details, along with our general framework, are in Section 5.1.

  2. 2.

    Low beacon entropy and adaptive security. If one is willing to forgo low communication, we show that there is an adaptively secure, low beacon entropy protocol that also has O(1) expected round complexity. The details are in Section 5.2.

  3. 3.

    Low beacon entropy and efficiency. If one wishes to forgo adaptive security, then there exists an efficient protocol that uses low beacon entropy that is secure against a static adversary. The details are in Section 5.3.

Mobile blocking adversary.

All the proofs relating to security against an adaptive adversary in this section can easily be modified to work for a mobile blocking adversary, with the same protocols. The main observation is that against an adversary that can only silence players, none of our proofs use the property that the same parties are corrupted between rounds, and also that in our protocols, the actions of an honest player depend only on the messages received from the previous round, and not any other round in the past.

5.1 Efficiency and Adaptive Security

In this section we describe our general framework for 𝖡𝖠 protocol design, along with one instantiation of it to obtain a 𝖡𝖠 protocol that has low communication(i.e. O(λ) parties talk in each round) and is secure against an adaptive adversary, as long as 3ft+1<(1ϵ)n for all t and constants ϵ. Formally, we prove the following in this section:

Lemma 9.

For all ϵ>0, assuming a randomness beacon, there exists a protocol Π that except for with exp(λ) probability, solves the 𝖡𝖠 task in the presence of an adaptive adversary that satisfies 3ft+1<(1ϵ)n for all t.
Furthermore, the protocol has O(1) expected latency, and the protocol has uniform O(λ) communication complexity, in expectation.

Our general framework, with which all three of our protocols are designed, resembles that of Gafni and Losa [19] of interlacing executions of the commit-adopt task and leader election. The main differences are the use of the randomness beacon to ensure both low communication and security against an adaptive adversary for some of our considered settings, and the consideration of a stronger adversary (Losa and Gafni assume a non equivocating adversary). With this in mind, we describe in this section the general framework and its concrete implementation to obtain Lemma 9. The following sections explain how to modify the implementation to obtain the other two protocols.

In all our protocols, the set of parties tasked with speaking in each round is denoted by comt for round t. We refer to comt as the committee of round t. Furthermore, each round t has a designated leader, denoted by t. Despite the fact that every round has a leader, in most rounds the leader does not have any special role. The identity of comt and t in each of our considered settings is derived both from the beacon and the given 𝖢𝖱𝖲 in different ways, as follows.

  1. 1.

    Efficiency and adaptive security. To achieve Lemma 9, we use the randomness beacon as follows. Denote the string distributed at round t to the players by the randomness beacon by 𝗌𝖾𝖾𝖽t. We choose |𝗌𝖾𝖾𝖽t|=O(λlogn), where λ is the security parameter, and we treat 𝗌𝖾𝖾𝖽t as 𝗌𝖾𝖾𝖽t=(t,comt) where t[n] is the identity of a player, which is referred to as the leader of round t, and comt[n] is a subset of size O(λ) of players, indicating the committee of round t. The protocol presented in this section makes no use of the given 𝖢𝖱𝖲.

  2. 2.

    Adaptive security and low beacon entropy. This protocol also makes no use of the 𝖢𝖱𝖲. In this protocol, comt=[n] for all t, and the leader t is elected via the randomness beacon string 𝗌𝖾𝖾𝖽t as above. See Section 5.2 for further details.

  3. 3.

    Efficiency and low beacon entropy. This protocol is the only protocol that makes use of the 𝖢𝖱𝖲. We interpret the 𝖢𝖱𝖲 as (𝗌𝖾𝖾𝖽1,𝗌𝖾𝖾𝖽2,) where 𝗌𝖾𝖾𝖽t=(t,comt) with t[n] and comt[n] of size O(λ). See Section 5.3 for further details.

Our framework is comprised from the interlacing of two components.

  • Commit-Adopt (𝖢𝖠). The 𝖢𝖠 protocol consists of 2-rounds. In each of these rounds, only the committee comt speaks. If the 𝖢𝖠 step fails to achieve consensus, players proceed to the second phase of the protocol.

  • Conciliator (𝖢𝖮). Intuitively, the goal of the Conciliator task is to bring back the honest players into a consistent view after the previous 𝖢𝖠 failed. This is done by running an additional 𝖢𝖠 and a leader election, and then outputting a value to continue with for the subsequent 𝖢𝖠.

We now formally define the two procedures 𝖢𝖠, and 𝖢𝖮.

Definition 10 (Commit-Adopt).

In the commit-adopt task (𝖢𝖠), each player receives an input value z, and must produce an output of the form commit(z) or adopt(z) for some value z, with the following guarantees.

  1. 1.

    Agreement. If an honest player outputs commit(z) for some value z, then all honest players must output either commit(z) or adopt(z).

  2. 2.

    Validity. If all honest players input the same value z, then all honest players must output commit(z).

  3. 3.

    Termination. There exists a round r such that by round r, all awake honest players have submitted an output.

Definition 11 (Conciliator).

In the conciliator task (𝖢𝖮), each player has an input value z and must produce an output with the following guarantees.

  1. 1.

    Validity. If all honest players input the same value z, then all honest players output z.

  2. 2.

    Termination. There is a round r such that all honest players output by round r.

  3. 3.

    Probabilistic Agreement. With probability at least 23, all players output the same value z inputted by some honest player.

Figure 1: Illustration of the structure of all three of our protocols. 𝖢𝖠 and 𝖢𝖮 procedures are interlaced, with each 𝖢𝖮 procedure ensuring safety on a potentially locked value, followed by letting a leader propose a value to the decision 𝖢𝖠. In each round t, only the players in comt or t send messages.

Our generic protocol alternates between executions of 𝖢𝖮 and 𝖢𝖠 until 𝖡𝖠 is solved. See Figure 1 for an illustration. We denote the i-th execution of 𝖢𝖠 and 𝖢𝖮 by 𝖢𝖠[i] and 𝖢𝖮[i], respectively. We now provide formal descriptions of the protocols for 𝖢𝖠 and 𝖢𝖮 using t,comt as explained above to obtain Lemma 9. The following sections explain how these implementations are modified to obtain our other protocols.

Algorithm 1 𝖢𝖠.

We employ the following adopt-commit protocol executed by all honest players p with input zp.

  1. 1.

    At round t=0, if pcom0, p broadcasts its input zp. Otherwise, do nothing.

  2. 2.

    At round t=1, if pcom1, do nothing. Otherwise, if there exists a value z that p has received z from more than 2|com0|3 of the players in com0333Here we use our authenticated channels assumption, p broadcasts vote(z). Otherwise, do nothing.

  3. 3.

    At round t2, p decides on its output as follows.

    1. (a)

      If there exists value z such that p has received vote(z) from at least 2|com1|3 of the players in com1, output commit(z).

    2. (b)

      Else if there exists a value z for which p received more vote(z) from players in com1 than for any other value, output adopt(z).

    3. (c)

      Else, output adopt(zp).

We now prove that the above procedure solves the 𝖢𝖠 problem in the presence of an adaptive adversary, as long as there is a constant ϵ>0 s.t. 3ft+1<(1ϵ)n for all t. In general, the above procedure solves the 𝖢𝖠 problem as long as comt contains a greater than 23-majority of honest players for all rounds t. In the context of Lemma 9, we make the following observation, which is used liberally throughout the section. We denote the above protocol by Π.

Observation 12.

Let 𝒜=(𝒜0,𝒜1) be an adaptive adversary. Then for all t it holds that

Pr[|𝒜0(Π,t,Trt)comt||comt|3]=𝗇𝖾𝗀𝗅(λ)

Proof.

The proof follows from standard concentration bounds. Specifically we get that the expected number of corrupted players in comt is upper bounded by |comt|3(1ϵ), and thus by a Hoeffding bound we get the probability that the number of corrupted players in comt exceeds |comt|3 is at most eΩ(ϵ2|comt|)=eΩ(ϵ2λ). For this we use the facts that |comt|=Ω(λ), ϵ is a constant, the choice of each player in comt being independent, and the independence of 𝒜0(Π,t,Trt) on comt.

We thus assume from here on in for the remainder of the analysis that an honest super-majority assumption holds at all rounds amongst the committee members, i.e. |𝒜0(Π,t,Trt)comt|<|comt|3 holds for all t. With that in mind all that is left is to prove that the above protocol solves the 𝖢𝖠 problem.

Lemma 13.

For any constant ϵ>0, except for with 𝗇𝖾𝗀𝗅(λ) probability, Algorithm 1 solves the 𝖢𝖠 task whenever 3ft+1<(1ϵ)n.

Proof.

Termination is clear from the behavior of the protocol. We move on to Validity, assume that all honest parties start the protocol with input z, and let com0,com1 be as in the protocol. Then in particular, all honest players in com0 broadcast z. The above observation implies that any honest player in com1 observes the value z from more than 23 of the players in com0. Thus all honest players in com1 broadcast vote(z) message at round 1. Which in turn causes all honest players to output commit(z) at t=2, as required. For Agreement, let commit(z) be the value output by some honest player p. Which means that p observed vote(z) from more than 23 of the members of com1. Note first that no other honest member of com1 sends vote(z) for a different value, as this implies that that two honest players q1,q2 in com1, respectively received multicasts of z,z from more than 23 of the members of com0, and a quorum intersection argument implies the existence of an honest player in com0 that broadcast two different inputs, which can not occur. Thus for any other value z an honest player can only observe strictly less than |com1|3 vote(z) messages from players in com1. On the other hand, if p observed vote(z) from more than 23 of the members of com1, this implies, together with Observation 12, that more than 13 of the honest members of com1 broadcast vote(z), which means all honest players have seen vote(z) messages from more than 13 of the members of com1. Combined, this means that all honest players have observed more vote(z) messages from players in com1 than for any other value, and thus output either adopt(z) or commit(z), as required.

We now proceed to designing a protocol for the 𝖢𝖮 task.

Algorithm 2 𝖢𝖮.

We employ the following conciliator protocol executed by all honest players p with input zp.

  1. 1.

    If t[0,2], run according to 𝖢𝖠 protocol with input value z.

  2. 2.

    If r=3, if p=3 or pcom3, broadcast 𝖢𝖠 output.

  3. 3.

    if r4, then:

    1. (a)

      If p received commit(z) from more than 13 of the players in com3 for some value z, then p outputs z.

    2. (b)

      Else, if p received adopt(z) or commit(z) for some value z from 3, then output z

    3. (c)

      Else, output zp.

We now proceed to prove the correctness of the above procedure.

Lemma 14.

For any constant ϵ>0, except for with 𝗇𝖾𝗀𝗅(λ) probability, Algorithm 2 solves the 𝖢𝖮 task whenever 3ft+1<(1ϵ)n.

Proof.

Termination is clear from the behavior of the protocol. For Validity, if z is the input of all honest players, then by the Validity of 𝖢𝖠, we get that by round 3, all honest players output commit(z). For probabilistic agreement, note that if no honest player outputs according to item (a), then the property holds as the leader is honest w.p. at least 23. Otherwise, Let p be an honest player that output according to item (a), which implies that p observed more than 13 fraction of commit(z) messages for the same value z from the players in com3. In particular this implies that at least one of those players is honest. Thus by the Agreement property 𝖢𝖠, we have that all honest players output either commit(z) or adopt(z). Thus no player in com3 sends commit(z) for any value zz. In particular this means that no honest player views more than a 13 fraction of commit(z) for any z=z. Thus, all honest players that output according to item (a) agree. Denote that value by z. Now note that w.p. at least 23, 3 is honest, and if this is the case, then 3 also output either commit(z) or adopt(z), by the agreement property of 𝖢𝖠, and all other honest players output z according to item b in that case. Thus, w.p. at least 23, all honest players agree on the output, as required.

We denote by Lc,Lca the number of rounds required to run the 𝖢𝖮,𝖢𝖠 tasks, respectively. We can now describe the generic 𝖡𝖠 protocol we employ. The following protocol is executed by every honest player p with input z.

Algorithm 3 𝖡𝖠 protocol framework.
  1. 1.

    For i=0,,D:

    1. (a)

      If t[(Lc+Lca)i,(Lc+Lca)i+Lc], run as in 𝖢𝖮[i] with input being the output of 𝖢𝖠[i1] or z if i=0 .

    2. (b)

      If r[(Lc+Lca)i+(Lc+1),(Lc+Lca+1)i] run as in 𝖢𝖠[i] with input being p’s output in 𝖢𝖮[i].

    3. (c)

      let o be the output of 𝖢𝖠[i].

      1. i.

        If o=commit(v) for some value, then output v as 𝖡𝖠 decision. Participate in the protocol for one more iteration with inputs to all subroutines being fixed to v.

      2. ii.

        Else, move on to i+1.

With the above instantiations of 𝖢𝖠 and 𝖢𝖮 in mind, we now prove that the above protocol proves Lemma 9.

Proof.

For Termination, consider an iteration i of the protocol above. By probabilistic agreement of 𝖢𝖮, we have that w.p. at least 23, all honest players agree on the output of 𝖢𝖮[i]. Denote it by z. Conditioned on agreement, Validity of 𝖢𝖠 guarantees that all honest players output commit(z), and thus they all terminate at the end of 𝖢𝖠[i]. Thus for every iteration i, w.p. at least 23, all honest players terminate at the end of iteration i+1. Thus, w.h.p. all honest players terminate after O(logn) iterations. For Validity, consider the case where all players have the same input z. The Validity properties of both 𝖢𝖮 and 𝖢𝖠 imply that at end of iteration 1, all honest players output commit(z) from 𝖢𝖠[1] and output z, as required. For Agreement, Let p be the first honest player to output, with output z. I.e. there exists an i such that p output commit(z) from 𝖢𝖠[z], and no honest player has output commit(z) for any z at any iteration i<i. In particular, this implies, by the consistency of 𝖢𝖠, that all other honest players output either commit(z) or adopt(z) from 𝖢𝖠[i]. Which implies that all honest players enter iteration i+1 with input z. The Validity of an iteration, proven above, implies thus that by the end of iteration i+1, all honest players output z.

Combining the fact that for every iteration i, w.p. at least 23, all honest players terminate at the end of iteration i+1 with the small size of comt for all t, we obtain that the protocol halts in O(1) rounds in expectation, and has O(λ) uniform communication complexity, in expectation, as required.

Note that we have essentially proved that Algorithm 3 solves 𝖡𝖠 whenever the number of honest participants in each round exceeds a 23 fraction. Furthermore, it has expected latency of O(1).

Nakamoto Consensus.

Note that Nakamoto consensus [32], also gives an efficient protocol with adaptive security. In each round, a leader is elected from a beacon. The leader adds a block to a chain, and consensus is reached on a prefix of the current longest chain, i.e. on blocks that are k-deep in the longest chain. This implies that in order to agree on a single block with 1exp(λ) confidence, it must be k=O(λ) deep in the longest chain. Thus, the beacon needs to emit klog(n) random bits to reach consensus. We note that the classic implementation of Nakamoto does not satisfy the validity condition of BA. This is easily remedied with a single invocation of 𝖢𝖠 prior to the initiation of the Nakamoto protocol. While 𝖢𝖠 requires Ω(n2) communication, note that our lower bound (Theorem 7) applies even when the protocol has O(1) initial rounds of high communication.

5.2 Adaptive security and low beacon entropy

Next, we showcase a protocol that is secure against an adaptive adversary and does not satisfy Definition 4 (i.e., has low beacon entropy). This, of course, as per Theorem 7, implies that this protocol has to have high communication. Specifically, all n parties send messages in every round. Specifically, we prove the following lemma.

Lemma 15.

For every ρ<13, and assuming a randomness beacon there exists a ρ-secure consensus protocol against an adaptive adversary, with O(1) expected latency. Furthermore, the protocol does not satisfy Definition 4.

We once again in this protocol make no use of 𝖢𝖱𝖲, as we aim to be secure against an adaptive adversary. The protocol Π is going to follow the same structure of Algorithm 3, with the following modifications.

  • All players participate in every round of Algorithm 3. In other words, comt=[n] for all rounds t. In particular, the randomness beacon is not used for committee sampling.

  • The random beacon is still being used to sample a uniformly random leader during the 𝖢𝖮 task. That is the only use of the randomness beacon. In other words, the output of the randomness beacon at round t, denoted by 𝗌𝖾𝖾𝖽t, contains only the identity of a single player t which is the chosen leader for round t.

Correctness of the protocol and its security against an adaptive adversary are immediate from the proof of correctness for Algorithm 3, and the adversary being ρ-bounded for ρ<13. The last item to prove is the following.

Claim 16.

Algorithm 3 when implemented without committees, satisfies that there exists a constant c>0 such that

t=0H(TrE𝒜t{TrE𝒜i0i<t})clogn

Proof.

Note that the only source of entropy in the modified protocol is the leader election in the 𝖢𝖮 subroutine. Besides that, all content of all messages is a deterministic function of the inputs of the players. Furthermore, we have that for each iteration i, w.p. at least 23, all honest players terminate by the end of iteration i+1. Thus, We get that for any adversary 𝒜 and any execution E, and for every iteration i>0 w.p. at least 113i1, IE𝒜t= where t is any round during iteration i. In particular we then get that the total min entropy of the transcript of the protocol Π during iteration i, for all i>1 is upper bounded by log(3i13i11). For i=0,1, the transcript is determined by the identity of the random leader, hence both of these iterations provide logn min entropy each. In total, we get that

t=0H(IE𝒜t|{TrE𝒜i0i<t},𝖢𝖱𝖲)<2logn+t=2log(3t13t11)<2logn+1

as required.

5.3 Efficiency and low beacon entropy

In this section, we showcase a protocol achieving both low communication and low Randomness beacon entropy usage, which in particular implies that it doesn’t have global leader unpredictability (see Definition 4). This is the only protocol in which we make use of the 𝖢𝖱𝖲. Specifically, we run Algorithm 3 but instead of using 𝗌𝖾𝖾𝖽t to select committees and a leader for 𝖢𝖮[i], all the information about the committees and leaders for each iteration are taken from 𝖢𝖱𝖲. I.e. the 𝖢𝖱𝖲 is interpreted as (𝗌𝖾𝖾𝖽1,𝗌𝖾𝖾𝖽2,), where 𝗌𝖾𝖾𝖽t=(comt,t) with t[n] and comt[n] being a subset of players of size O(λ). We assume that 𝖢𝖱𝖲 is sufficiently long to encode such information. We recall that a static adversary makes its choice of corruption before observing the CRS. Formally, we prove the following.

Lemma 17.

For every ϵ>0 and ρ<1ϵ3, and assuming a 𝖢𝖱𝖲, there exists a ρ-secure consensus protocol against a static adversary with O(1) expected latency and O(λ) uniform communication complexity, in expectation.

For simplicity, we abuse notation and refer to t,comt for the purposes of this lemma also as the leader and the committee of round t as described in the 𝖢𝖱𝖲.

Observation 18.

Let 𝒜=(𝒜0,𝒜1) be a static adversary. Then for all t it holds that

Pr[|𝒜0(Π,t)comt||comt|3]=𝗇𝖾𝗀𝗅(λ)

when comt is taken from the 𝖢𝖱𝖲.

The observation follows from the same arguments as Observation 12.

Proof.

The proof of the lemma follows from the correctness of Algorithm 3 whenever the honest fraction of participating parties in every round exceeds 23. Algorithm 3 was shown to have O(1) expected latency and by the size of comt for all t we get that the communication complexity of the protocol is uniform O(λ) in expectation, as required.

6 Conclusion

Our motivation in this paper was to characterize the space of what is possible in modern consensus protocols. Although prior work has examined many desirable properties of consensus, the relationship between randomness, communication efficiency, and adaptive security lacked a rigorous understanding. These properties have become especially desirable in modern-day consensus protocols, yet their theoretical foundations have lagged behind. We further our understanding of the consensus landscape by showing a trilemma: Efficient consensus with adaptive security requires Ω(logn) bits of beacon entropy. On the positive side, we provide protocols that achieve any pair of these properties.

Implications for practice.

In modern blockchains, adaptive security is especially desirable to prevent bribery attacks or other attacks where nodes are temporarily compromised. In practice, modern blockchains often use randomness beacons to unpredictably elect leaders or committees. However, these randomness beacons come at a cost and add design and implementation complexity. Our work shows that efficient and adaptively secure protocols require beacons; this cost is in some sense unavoidable.

A natural next question is exactly how much randomness is needed from the beacon. Our possibility results show that the amount of entropy required is relatively low, growing only logarithmically in the number of parties. Therefore, using a beacon is unavoidable, yet this beacon can be relatively lightweight.

Extensions to other settings.

In this work, we have considered a computationally unbounded adversary and an information-theoretic setting. This choice mainly served to maintain the simplicity and clarity of the exposition. A natural alternative model is the PKI setting, with computationally bounded adversaries. Our positive results trivially extend to this setting, as information-theoretic security implies security against a computationally bounded adversary. Extending our lower bound is slightly more subtle, though we expect it to hold for a notion of pseudorandomness rather than statistical beacon entropy. We leave formalizing this analogous bound as an interesting direction for future work.

In this work, we restricted our attention to a special variety of low-communication protocols, specifically ones where the set of parties speaking in each round is small. This notion of communication efficiency is desirable in practice, and several protocols use a committee subsampling approach to this end (e.g., Algorand, Ethereum). However, one might also be interested in other notions of communication efficiency, for example the setting where communication is simply measured by the total number of bits exchanged by honest parties. An open question is whether our results stand in this alternate setting.

References

  • [1] Ittai Abraham, T.-H. Hubert Chan, Danny Dolev, Kartik Nayak, Rafael Pass, Ling Ren, and Elaine Shi. Communication complexity of byzantine agreement, revisited. Distributed Comput., 36(1):3–28, 2023. doi:10.1007/S00446-022-00428-8.
  • [2] Ittai Abraham, Srinivas Devadas, Danny Dolev, Kartik Nayak, and Ling Ren. Synchronous Byzantine Agreement with Expected O(1) Rounds, Expected O(n2) Communication, and Optimal Resilience. In Financial Crypto, 2019.
  • [3] Mohamad Ahmadi, Abdolhamid Ghodselahi, Fabian Kuhn, and Anisur Rahaman Molla. The cost of global broadcast in dynamic radio networks. Theor. Comput. Sci., 806:363–387, 2020. doi:10.1016/J.TCS.2019.07.013.
  • [4] Mohamad Ahmadi and Fabian Kuhn. Multi-message broadcast in dynamic radio networks. In ALGOSENSORS, 2016.
  • [5] Kaya Alpturer and S. Matthew Weinberg. Optimal RANDAO manipulation in ethereum. In AFT, 2024. doi:10.4230/LIPIcs.AFT.2024.10.
  • [6] Ziv Bar-Joseph and Michael Ben-Or. A tight lower bound for randomized synchronous consensus. In PODC. ACM, 1998. doi:10.1145/277697.277733.
  • [7] Dan Boneh, Joseph Bonneau, Benedikt Bünz, and Ben Fisch. Verifiable Delay Functions. In CRYPTO, 2018.
  • [8] Elette Boyle, Ran Cohen, and Aarushi Goel. Breaking the O(n)-bit Barrier: Byzantine Agreement with Polylog Bits Per Party. In PODC. ACM, 2021. doi:10.1145/3465084.3467897.
  • [9] Nicolas Braud-Santoni, Rachid Guerraoui, and Florian Huc. Fast byzantine agreement. In PODC. ACM, 2013. doi:10.1145/2484239.2484243.
  • [10] Miguel Castro, Barbara Liskov, et al. Practical Byzantine Fault Tolerance. In OSDI, 1999.
  • [11] Jing Chen and Silvio Micali. Algorand: A secure and efficient distributed ledger. Theor. Comput. Sci., 777:155–183, 2019. doi:10.1016/J.TCS.2019.02.001.
  • [12] Kevin Choi, Aathira Manoj, and Joseph Bonneau. Sok: Distributed randomness beacons. In IEEE Security & Privacy, 2023.
  • [13] Benny Chor, Michael Merritt, and David B. Shmoys. Simple constant-time consensus protocols in realistic failure models. J. ACM, 36(3):591–614, 1989. doi:10.1145/65950.65956.
  • [14] Francesco D’Amato and Luca Zanolini. A simple single slot finality protocol for ethereum. In ESORICS, 2023.
  • [15] Sourav Das, Sisi Duan, Shengqi Liu, Atsuki Momose, Ling Ren, and Victor Shoup. Asynchronous Consensus without Trusted Setup or Public-Key Cryptography. In ACM CCS, 2024.
  • [16] Bernardo David, Peter Gazi, Aggelos Kiayias, and Alexander Russell. Ouroboros Praos: An Adaptively-Secure, Semi-synchronous Proof-of-Stake Blockchain. In Eurocrypt, 2018.
  • [17] Danny Dolev and Rüdiger Reischuk. Bounds on information exchange for byzantine agreement. J. ACM, 32(1):191–204, 1985. doi:10.1145/2455.214112.
  • [18] Matthias Fitzi, Chen-Da Liu-Zhang, and Julian Loss. A new way to achieve round-efficient byzantine agreement. In PODC. ACM, 2021. doi:10.1145/3465084.3467907.
  • [19] Eli Gafni and Giuliano Losa. Brief Announcement: Byzantine Consensus Under Dynamic Participation with a Well-Behaved Majority. In DISC, 2023. doi:10.4230/LIPIcs.DISC.2023.41.
  • [20] Juan A. Garay and Aggelos Kiayias. SoK: A Consensus Taxonomy in the Blockchain Era. In CT-RSA, 2020.
  • [21] Diana Ghinea, Vipul Goyal, and Chen-Da Liu-Zhang. Round-optimal byzantine agreement. In Eurocrypt, 2022.
  • [22] Yossi Gilad, Rotem Hemo, Silvio Micali, Georgios Vlachos, and Nickolai Zeldovich. Algorand: Scaling byzantine agreements for cryptocurrencies. In SOSP, 2017.
  • [23] Mohammad Hajiaghayi, Dariusz R. Kowalski, and Jan Olkowski. Nearly-optimal consensus tolerating adaptive omissions: Why a lot of randomness is needed? In PODC. ACM, 2024. doi:10.1145/3662158.3662826.
  • [24] Alireza Kavousi, Zhipeng Wang, and Philipp Jovanovic. SoK: Public Randomness. In Euro S&P, 2024.
  • [25] Valerie King, Steven Lonargan, Jared Saia, and Amitabh Trehan. Load balanced scalable byzantine agreement through quorum building, with full information. In ICDCN, 2011.
  • [26] Valerie King and Jared Saia. Breaking the O(n2) bit barrier: Scalable byzantine agreement with an adaptive adversary. J. ACM, 58(4):18:1–18:24, 2011. doi:10.1145/1989727.1989732.
  • [27] Marek Klonowski, Dariusz R. Kowalski, and Jaroslaw Mirek. Ordered and delayed adversaries and how to work against them on a shared channel. Distributed Comput., 32(5):379–403, 2019. doi:10.1007/S00446-018-0341-7.
  • [28] Leslie Lamport, Robert E. Shostak, and Marshall C. Pease. The Byzantine Generals Problem. ACM Trans. Program. Lang. Syst., 4(3):382–401, 1982. doi:10.1145/357172.357176.
  • [29] Arjen K. Lenstra and Benjamin Wesolowski. A random zoo: sloth, unicorn, and trx. Cryptology ePrint Archive, Paper 2015/366, 2015. URL: https://eprint.iacr.org/2015/366.
  • [30] Julian Loss and Gilad Stern. Zombies and ghosts: Optimal byzantine agreement in the presence of omission faults. In TCC (4), volume 14372 of Lecture Notes in Computer Science, pages 395–421. Springer, 2023. doi:10.1007/978-3-031-48624-1_15.
  • [31] Achour Mostéfaoui, Hamouma Moumen, and Michel Raynal. Signature-free asynchronous binary byzantine consensus with t < n/3, o(n2) messages, and O(1) expected time. J. ACM, 62(4):31:1–31:21, 2015. doi:10.1145/2785953.
  • [32] Satoshi Nakamoto. Bitcoin: A peer-to-peer electronic cash system. https://bitcoin.org/bitcoin.pdf, 2008.
  • [33] Marshall C. Pease, Robert E. Shostak, and Leslie Lamport. Reaching agreement in the presence of faults. J. ACM, 27(2):228–234, 1980. doi:10.1145/322186.322188.
  • [34] Michael O. Rabin. Transaction protection by beacons. Journal of Computer and System Sciences, 1983.
  • [35] Mayank Raikwar and Danilo Gligoroski. SoK: Decentralized randomness beacon protocols. In Australasian Conference on Information Security and Privacy, 2022.
  • [36] Peter Robinson, Christian Scheideler, and Alexander Setzer. Breaking the Ω~(n) barrier: Fast consensus under a late adversary. In SPAA. ACM, 2018.
  • [37] Ewa Syta, Philipp Jovanovic, Eleftherios Kokoris Kogias, Nicolas Gailly, Linus Gasser, Ismail Khoffi, Michael J Fischer, and Bryan Ford. Scalable bias-resistant distributed randomness. In IEEE Security & Privacy, 2017.