Chop Chop: Byzantine Atomic Broadcast to the Network Limit

TL;DR

Chop Chop tackles the long-standing throughput gap in Byzantine Atomic Broadcast by introducing a distillation-based batching mechanism that compresses per-message authentication and sequencing information. It relies on an authenticated mempool and trusted-broker interactions to produce distilled batches that servers can verify in bulk, dramatically reducing CPU and network overhead. The authors prove safety and liveness under Byzantine faults, implement the system in Rust, and demonstrate near line-rate throughput (tens of millions of ops/s) with a mean end-to-end latency in the low seconds range across geo-distributed deployments, outperforming strong baselines by up to two orders of magnitude. They further validate three practical applications (Payment, Auction, Pixel War) achieving multi-million op/s throughput, underscoring Chop Chop’s potential for Internet-scale, Byzantine fault-tolerant state machine replication.

Abstract

At the heart of state machine replication, the celebrated technique enabling decentralized and secure universal computation, lies Atomic Broadcast, a fundamental communication primitive that orders, authenticates, and deduplicates messages. This paper presents Chop Chop, a Byzantine Atomic Broadcast system that uses a novel authenticated memory pool to amortize the cost of ordering, authenticating and deduplicating messages, achieving "line rate" (i.e., closely matching the complexity of a protocol that does not ensure any ordering, authentication or Byzantine resilience) even when processing messages as small as 8 bytes. Chop Chop attains this performance by means of a new form of batching we call distillation. A distilled batch is a set of messages that are fast to authenticate, deduplicate, and order. Batches are distilled using a novel interactive protocol involving brokers, an untrusted layer of facilitating processes between clients and servers. In a geo-distributed deployment of 64 medium-sized servers, Chop Chop processes 43,600,000 messages per second with an average latency of 3.6 seconds. Under the same conditions, state-of-the-art alternatives offer two orders of magnitude less throughput for the same latency. We showcase three simple Chop Chop applications: a Payment system, an Auction house and a "Pixel war" game, respectively achieving 32, 2.3 and 35 million operations per second.

Figures (11)

• Figure 1: Throughput of Internet-scale services.
• Figure 2: Full distillation in action. With classic authentication and sequencing, each payload $q_i$ contains a public key $pk_i$, a sequence number $sn_i$, a message $msg_i$ and a signature $sig_i$. In the fully distilled case, each $q_i$ reduces to just $id_i$ and $msg_i$: one header $H$, composed of one aggregate sequence number $SN$ and one aggregate signature $SIG$, is sufficient for the entire batch. Bars are to scale if small messages are broadcast using Ed25519 for signatures and BLS12-381 for uncompressed multi-signatures: $sn_i$ and $SN$ are 8 B, $msg_i$ is 8 B, $pk_i$ is 32 B, $sig_i$ is 64 B, $SIG$ is 192 B.
• Figure 3: Full distillation of a batch of 65,536 payloads (sizes to scale). The aggregate signature and aggregate sequence number do not appear as a result of their small size.
• Figure 4: Chop Chop architecture.
• Figure 5: Overview of the Chop Chop protocol between two clients ($\chi_1$, $\chi_2$), a broker ($\beta$) and four servers ($\sigma_1$--$\sigma_4$). The protocol is comprised of 19 steps (#1--#19) and of an underlying instance of Atomic Broadcast such as BFT-SMaRt or HotStuff.

Theorems & Definitions (176)

• Lemma 1
• proof
• Lemma 2
• proof
• Lemma 3
• proof
• Lemma 4
• proof
• Theorem 1: No duplication
• proof