Brendan K. Chou

On the Internet, nobody knows you're a dog.
Eng @commonwarexyz

[patrickogrady.xyz @_patrickogrady]

70k tps
400ms finalization
browser light client
native passkey wallet

… now available (for free)

[Brendan K. Chou @B_Chou]

This is not only a huge win in performance, it is also IMO a particularly mathematically beautiful result

[patrickogrady.xyz @_patrickogrady]

It turns out, this trade wasn't necessary.

@roberto_bayardo designed a new tree structure that bounds proof size for active state to only **2 hashes** above the optimal structure (a balanced binary Merkle tree):

[Guru Vamsi Policharla @guruvamsip]

Excited to share that I’ve joined @commonwarexyz! Looking forward to working with the amazing team to bring advanced cryptography onchain.

First order of business is scaling SNARK verification onchain: we managed to verify over 500K proofs in 0.75s without recursion or external preprocessing!

More details below 👇

[vitalik.eth @VitalikButerin]

One important technical item that I forgot to mention is the proposed switch from Casper FFG to Minimmit as the finality gadget.

To summarize, Casper FFG provides two-round finality: it requires each attester to sign once to "justify" the block, and then again to "finalize" it. Minimmit only requires one round. In exchange, Minimmit's fault tolerance (in our parametrization) drops to 17%, compared to Casper FFG's 33%.

Within Ethereum consensus discussions, I have always been the security assumptions hawk: I've insisted on getting to the theoretical bound of 49% fault tolerance under synchrony, kept pushing for 51% attack recovery gadgets, came up with DAS to make data availability checks dishonest-majority-resistant, etc. But I am fine with Minimmit's properties, in fact even enthusiastic in some respects. In this post, I will explain why.

Let's lay out the exact security properties of both 3SF (not the current beacon chain, which is needlessly weak in many ways, but the ideal 3SF) and Minimmit.

"Synchronous network" means "network latency less than 1/4 slot or so", "asynchronous network" means "potentially very high latency, even some nodes go offline for hours at a time". The percentages ("attacker has <33%") refer to percentages of active staked ETH.

## Properties of 3SF

Synchronous network case:

* Attacker has p < 33%: nothing bad happens
* 33% < p < 50%: attacker can stop finality (at the cost of losing massive funds via inactivity leak), but the chain keeps progressing normally
* 50% < p < 67%: attacker can censor or revert the chain, but cannot revert finality. If an attacker censors, good guys can self-organize, they can stop contributing to a censoring chain, and do a "minority soft fork"
* p > 67%: attacker can finalize things at will, much harder for good guys to do minority soft fork

Asynchronous network case:

* Attacker has p < 33%: cannot revert finality
* p > 33%: can revert finality, at the cost of losing massive funds via slashing

## Properties of Minimmit

Synchronous network case:

* Attacker has p < 17%: nothing bad happens
* 17% < p < 50%: attacker can stop finality (at the cost of losing massive funds via inactivity leak), but the chain keeps progressing normally
* 50% < p < 83%: attacker can censor or revert the chain, but cannot revert finality. If an attacker censors, good guys can self-organize, they can stop contributing to a censoring chain, and do a "minority soft fork"
* p > 83%: attacker can finalize things at will, much harder for good guys to do minority soft fork

Asynchronous network case:

* Attacker has p < 17%: cannot revert finality
* p > 17%: can revert finality, at the cost of losing massive funds via slashing

I actually think that the latter is a better tradeoff. Here's my reasoning why:

* The worst kind of attack is actually not finality reversion, it's censorship. The reason is that finality reversion creates massive publicly available evidence that can be used to immediately cost the attacker millions of ETH (ie. billions of dollars), whereas censorship requires social coordination to get around
* In both of the above, a censorship attack requires 50%
* A censorship attack becomes *much harder* to coordinate around when the censoring attacker can unilaterally finalize (ie. >67% in 3SF, >83% in Minimmit). If they can't, then if the good guys counter-coordinate, you get two non-finalizing chains dueling for a few days, and users can pick on. If they can, then there's no natural schelling point to coordinate soft-forking
* In the case of a client bug, the worst thing that can happen is finalizing something bugged. In 3SF, you only need 67% of clients to share a bug for it to finalize, in Minimmit, you need 83%.

Basicallly, Minimmit maximizes the set of situations that "default to two chains dueling each other", and that is actually a much healthier and much more recoverable outcome than "the wrong thing finalizing".

We want finality to mean final. So in situations of uncertainty (whether attacks or software bugs), we should be more okay with having periods of hours or days where the chain does not finalize, and instead progresses based on the fork choice rule. This gives us time to think and make sure which chain is correct.

Also, I think the "33% slashed to revert finality" of 3SF is overkill. If there is even eg. 15 million ETH staking, then that's 5M ($10B) slashed to revert the chain once. If you had $10B, and you are willing to commit mayhem of a type that violates many countries' computer hacking laws, there are FAR BETTER ways to spend it than to attack a chain. Even if your goal is breaking Ethereum, there are far better attack vectors.

And so if we have the baseline guarantee of >= 17% slashed to revert finality (which Minimmit provides), we should judge the two systems from there based on their other properties - where, for the reasons I described above, I think Minimmit performs better.

[patrickogrady.xyz @_patrickogrady]

Today, we're excited to share that a large number of @commonwarexyz primitives are now "stable" (with 93% test coverage and Long-Term Support guarantees):

https://t.co/7uLr0avPFn

[Brendan K. Chou @B_Chou]

@just__a___guy @illsaywutiwant @SandyofCthulhu Well well well

https://t.co/SNcbxCNbcA

[patrickogrady.xyz @_patrickogrady]

Today, I’m excited to (finally) welcome Minimmit to the @commonwarexyz Library.

Implemented independently by both @GTE_XYZ and @vex_0x, Minimmit clobbers our benchmarks:

[USA]: 51ms blocks (-40%) | 87ms final p75 (-35%)
[Global]: 142ms blocks (-30%) | 269ms final p75 (-15%)

[Dankrad Feist @dankrad]

I wrote an article explaining Minimmit consensus:

https://t.co/6tBJemHZAv

[Brendan K. Chou @B_Chou]

I can't currently think of a way to efficiently serve the full "implied orderbook" but at least the touch-price can be served extremely efficiently with minimal overhead. The touch-amount could be served if a min-heap (over order size at the touch) is maintained, though this is less efficient than O(1) per order (could be O(log n))

[Brendan K. Chou @B_Chou]

On prediction markets with N outcomes, I heard they run a separate YES/NO orderbook for each outcome, and rely on arbitrageurs to "balance" such markets. If this is the case, why? Why are exchanges not doing the implied matching atomically to increase liquidity?

[Brendan K. Chou @B_Chou]

Lastly, this doesn't seem particularly computationally complex for the matching engine. For a single prediction market, it can simply maintain the current sum of the best bids and the current sum of the best asks for each of the N outcomes. This is an O(1) operation on order placement. If the sum of the best bids would go over 1, or the sum of the best asks would go over N-1, then match orders across all outcomes into an implied trade. This is O(N) but you are matching N orders.

[Brendan K. Chou @B_Chou]

@simonsarris @TheStalwart This is what I thought too, but I think it's wrong to assume an average of 1 left of each. It would be an equal amount percentage-wise, not absolute-wise. So on average maybe 10 mediums 5 larges and 2 XLs

[Brendan K. Chou @B_Chou]

@moonshiesty @danrobinson ADL actually *frees up* margin by decreasing your position size while leaving the value of your account unchanged

[patrickogrady.xyz @_patrickogrady]

Over the past few months, we've been prototyping infrastructure components to extend @commonwarexyz (making it faster and cheaper to interact with high-throughput blockchains).

We are now looking for our first dedicated eng (0.25-1% equity) to create production-ready APIs 👀

[patrickogrady.xyz @_patrickogrady]

Thrilled to share @commonwarexyz's first paper "Minimmit: Fast Finality with Even Faster Blocks" has been accepted at Financial Cryptography 2026!

State-of-the-Art Performance ✅
Peer-Reviewed ✅
Deployed ⚒️

https://t.co/q7KUMvODp3

[Brendan K. Chou @B_Chou]

@fuckwordman @happysmash27 @Feliciamtang @khandotdev Hint: You're right that each of the 5 sections maps to each of the 5 underscores. Each symbol is a letter. Each symbol is a number.

[Andrew Lewis-Pye @AndrewLewisPye]

Excited to announce I’ll be working with the great folks @commonwarexyz! Looking forward to bridging theory and practice in distributed systems…

[Tempo @tempo]

Tempo is adopting the Commonware Library and leading a $25M strategic investment in @commonwarexyz. Together, we will accelerate our shared vision: high-performance, reliable infrastructure for every builder.

[patrickogrady.xyz @_patrickogrady]

Welcome, @tempo

Today, we're thrilled to share that Tempo is building with the @commonwarexyz Library, supporting our growth as a new core contributor, and accelerating our research and engineering with a strategic investment.

https://t.co/9oUc7mMZQV