a non-profit R&D lab for Ethereum and ETH
Joined June 2026
- Tweets277
- Following9
- Followers18.9K
- Likes357
Ethlabs retweeted
"We've also been funding ecosystem spin-offs... we have more conviction today on ETH as a story than we did a year ago."
With investments in @ethereuminsti @ethlabs_org and @eth_systems we'll continue to make Ethereum stronger.
CEO @joechalom with @gazza_jenks on The Starting Block.
Ethlabs retweeted
Maggie Parsons on why @Lighter_xyz built on Ethereum:
"Building an exchange and building trust with users, that's a secure-layer question first. Where you build determines what users can actually trust."
"We look at Ethereum as the settlement layer for the future of finance. Lighter is committed to building on Ethereum."
"DeFi and assets are on Ethereum. Composability with all of that, leveraging assets on one platform as collateral on Lighter, that's a huge value proposition."
Ethlabs retweeted
Here is an even better view of who's stepping in, who's stepping out, and who's consolidating in the validator set.
This is not the mass exodus that some accounts are wrongly portraying. Great to see all these consolidations!
Source: @beaconcha_in beaconcha.in/validators/queu…
This is incorrect! On the QT’d chart, consolidations (good!) are counted as exits (bad!)
@beaconcha_in made the point here: xitter.cf/beaconcha_in/status/21…
Ethlabs retweeted
I made a visualization of EIP-8288 aka "recursive mempool aggregation," my new favorite EIP of all time because it perfectly encapsulates the thesis of the "cryptographic world computer" -- a system whose scalability *increases*, not decreases, with the level of decentralization.
In a previous tweet I explained how EIP-8288 achieved this seemingly impossible feat, but one gif is worth a thousand words.
Essentially, EIP-8288 leverages Ethereum's decentralized mempool as a parallel ZK proving cluster. Clients send signatures and proofs to the mempool, which over multiple rounds progressively aggregate them into fewer and fewer proofs, until the block builder finally aggregates them into one SINGLE proof.
This design accomplishes five things at once:
- The more nodes we add to the decentralized mempool, the more signatures/proofs Ethereum can process as a whole. This is obvious if you look at the animation and imagine more nodes in the mempool ring, which would "fan out" to more signatures/proofs.
- By aggregating over multiple rounds (aka "recursive aggregation"), the bandwidth consumed by proofs remains constant for each node even as the network processes more proofs. As a result, the network stays decentralized even as capacity increases.
- By aggregating proofs before one final aggregation by the builder, as opposed to requiring the builder to aggregate everything, the network can process more proofs without increasing hardware requirements for the builder.
- By aggregating everything to a single block-level proof, validators can verify thousands of signatures/proofs by checking just one aggregated proof. Hardware requirements for validators can therefore stay low, keeping the network decentralized.
- By aggregating not just native signatures but also STARKs, Ethereum can support any signature scheme by wrapping them in STARKs.
So once again, this is how Ethereum will:
- scale to process tens of thousands of PQ and private transactions per second
- charge a tiny amount of gas to validate each txn, even though the original signature/proof may be huge (up to hundreds of KBs in size)
- all while decentralizing even MORE.
You are not bullish enough.
Ultimately, precompiles and EVM are both the wrong place to put most cryptography support into Ethereum. The reason is that precompiles and EVM both operate on data that has to be included into the ethereum chain somehow, which realistically means included in a block as calldata. That space is limited - even with PeerDAS and blocks-in-blobs, there's a practical cap of ~8 MB/s before it starts getting uncomfortable.
Remember: it's not a blockchain. It's a cryptographic world computer. Any data/computation that does not need to be in the "main thread" of data/execution should not be put into the main thread.
Instead, the correct solution is... EIP-8288 maximalism.
If you have any heavy computation that's self-contained, compute it and STARK it client-side (this is quickly getting faster and faster, even on phones), and push the STARK through the EIP-8288 recursive aggregation mechanism. The chain sees the fact that the computation was done and what the result is; it never needs to see the actual data and computation.
This way everyone can use whatever cryptography they want, the Ethereum chain can be lean, and we never need to add more precompiles again.
Ethlabs retweeted
News: JPM Coin (JPMD), @jpmorgan's USD deposit token, is now live on @ethereum.
JPMD extends from Base to Ethereum L1, giving institutional clients native onchain cash that sits alongside the assets, collateral and counterparties they transact with already.
J.P. Morgan has now added a cash leg to the products it already live on Ethereum mainnet, with tokenized money market funds MONY and JLTXX both already on the network.
Ethereum is the home of onchain finance.
Ethlabs retweeted
Ethereum has always had a great culture of working in public, but admittedly this has often failed to translate into good, clear communication, or even into something as basic as celebrating wins. At @ethlabs_org we really want to be part of the solution here, elevating constant, proactive communication to
a first class citizen of our org and our work. @barnabemonnot is especially obsessed with this and leading the way.
Decisions should be the culmination of a process of collective understanding, not the beginning of one, even more so for a decentralized network and community. Once a major decision is taken, it should feel entirely unsurprising, the natural consequence of what led up to it.
Great to see many others contributing to narrating the Ethereum story as it evolves!
Ethlabs retweeted
feel the acceleration yet?
AI is making Ethereum more ambitious.
You might have heard about the challenges that blockchains face in a post-AI world, and while security assumptions will surely be stress-tested in the coming months and years, there is another side to it. I believe AI will let us speedrun towards a world that's both more secure and feature-rich.
As we look towards Ethereum's first post-AI upgrade, Hegotá, the R&D community is asking itself what increasingly powerful tools could help us do differently:
> How far can we push both security and iteration speed?
> How much of the design space can we examine before committing to one?
> How easily can we test the interactions between complex features?
My recent formal verification work @ethlabs_org has given me some reasons to be optimistic about these, as work that would have previously not even been attempted is now being done by agents in days. In September, I posted about using formal verification as part of designing a new consensus protocol. This time, I want to tell you about formally verifying something already fully specified and in production: Ethereum's Fast Confirmation Rule (FCR).
If you are not familiar with FCR, it lets applications confirm Ethereum blocks in seconds, roughly 30x faster than waiting for finality, under additional assumptions (from waiting 13 minutes to 24 seconds!). It also further solidifies Ethereum L1's case as an asset hub and center of gravity for the onchain economy. FCR now has a safety proof in Lean, closely modeling the rule in the consensus specs, which is the source of truth for Ethereum's consensus clients.
Some takeaways:
> FCR is safe! Under its assumptions, confirmed blocks remain canonical. On top of the manual proofs from the paper, we now have Lean proofs of this for the actual spec, additional evidence for applications considering FCR!
> The bulk of the formal verification work took just a 4-5 days (check out the animation!), with agents working mostly unsupervised. We should be very ambitious about using this as a tool at scale.
> After verifying the current rule, it was easy to adapt the model to the upcoming Gloas changes. Immediately, this surfaced a subtle bug caused by changes to fork choice. The problem was in the spec itself and not a gap in the model. The safety proof would not go through, and the agents could precisely pinpoint what was causing it to fail. The bug is now fixed, and formal verification of the corrected protocol goes through.
Iteration is never quite over, even for "finished" features like FCR, because the protocol keeps evolving around them. A formal model lets us ensure that key properties keep holding throughout the evolution of the protocol. With these capabilities, Ethereum can and should keep upgrading faster, tightening fork timelines and exploring more ambitious features, while still raising the security bar.
This picture has been getting much clearer over the past few months, and the past week confirmed it for me, as @drakefjustin and @corcoranwill brought together 100+ Ethereum researchers, cryptographers and formal verification experts in Cambridge for six days of workshops on post-quantum cryptography, formal verification and fast finality. Beyond its own workshop, formal verification was the omnipresent star of the week: everyone is using Lean and doing amazing things with it! Piece by piece, Ethereum's technological core is being rebuilt for the post-AI age.
The excitement was palpable, the sense of optimism was pervasive, and every talk and conversation carried a level of ambition I'd never seen before. The Ethereum R&D machine is upgrading itself, and we will see the outcome of that on the network sooner than you think.
Ethlabs retweeted
Great summary of how AI-powered formal verification is contributing to the betterment of Ethereum on a scale we've never seen before!
Appreciate highlighting our work here, especially as we reflect on the last decade of bringing formal methods to Ethereum, starting with KEVM.
AI is making Ethereum more ambitious.
You might have heard about the challenges that blockchains face in a post-AI world, and while security assumptions will surely be stress-tested in the coming months and years, there is another side to it. I believe AI will let us speedrun towards a world that's both more secure and feature-rich.
As we look towards Ethereum's first post-AI upgrade, Hegotá, the R&D community is asking itself what increasingly powerful tools could help us do differently:
> How far can we push both security and iteration speed?
> How much of the design space can we examine before committing to one?
> How easily can we test the interactions between complex features?
My recent formal verification work @ethlabs_org has given me some reasons to be optimistic about these, as work that would have previously not even been attempted is now being done by agents in days. In September, I posted about using formal verification as part of designing a new consensus protocol. This time, I want to tell you about formally verifying something already fully specified and in production: Ethereum's Fast Confirmation Rule (FCR).
If you are not familiar with FCR, it lets applications confirm Ethereum blocks in seconds, roughly 30x faster than waiting for finality, under additional assumptions (from waiting 13 minutes to 24 seconds!). It also further solidifies Ethereum L1's case as an asset hub and center of gravity for the onchain economy. FCR now has a safety proof in Lean, closely modeling the rule in the consensus specs, which is the source of truth for Ethereum's consensus clients.
Some takeaways:
> FCR is safe! Under its assumptions, confirmed blocks remain canonical. On top of the manual proofs from the paper, we now have Lean proofs of this for the actual spec, additional evidence for applications considering FCR!
> The bulk of the formal verification work took just a 4-5 days (check out the animation!), with agents working mostly unsupervised. We should be very ambitious about using this as a tool at scale.
> After verifying the current rule, it was easy to adapt the model to the upcoming Gloas changes. Immediately, this surfaced a subtle bug caused by changes to fork choice. The problem was in the spec itself and not a gap in the model. The safety proof would not go through, and the agents could precisely pinpoint what was causing it to fail. The bug is now fixed, and formal verification of the corrected protocol goes through.
Iteration is never quite over, even for "finished" features like FCR, because the protocol keeps evolving around them. A formal model lets us ensure that key properties keep holding throughout the evolution of the protocol. With these capabilities, Ethereum can and should keep upgrading faster, tightening fork timelines and exploring more ambitious features, while still raising the security bar.
This picture has been getting much clearer over the past few months, and the past week confirmed it for me, as @drakefjustin and @corcoranwill brought together 100+ Ethereum researchers, cryptographers and formal verification experts in Cambridge for six days of workshops on post-quantum cryptography, formal verification and fast finality. Beyond its own workshop, formal verification was the omnipresent star of the week: everyone is using Lean and doing amazing things with it! Piece by piece, Ethereum's technological core is being rebuilt for the post-AI age.
The excitement was palpable, the sense of optimism was pervasive, and every talk and conversation carried a level of ambition I'd never seen before. The Ethereum R&D machine is upgrading itself, and we will see the outcome of that on the network sooner than you think.
Ethlabs retweeted
Historically, ethereum moved slower relative to peers in part bc we refused to compromise on:
⭐️ security, 100% uptime
⭐️ best-in-class client diversity
⭐️ censorship resistance
I don't think the industry is prepared for us to double down on these and still accelerate 👀
AI is making Ethereum more ambitious.
You might have heard about the challenges that blockchains face in a post-AI world, and while security assumptions will surely be stress-tested in the coming months and years, there is another side to it. I believe AI will let us speedrun towards a world that's both more secure and feature-rich.
As we look towards Ethereum's first post-AI upgrade, Hegotá, the R&D community is asking itself what increasingly powerful tools could help us do differently:
> How far can we push both security and iteration speed?
> How much of the design space can we examine before committing to one?
> How easily can we test the interactions between complex features?
My recent formal verification work @ethlabs_org has given me some reasons to be optimistic about these, as work that would have previously not even been attempted is now being done by agents in days. In September, I posted about using formal verification as part of designing a new consensus protocol. This time, I want to tell you about formally verifying something already fully specified and in production: Ethereum's Fast Confirmation Rule (FCR).
If you are not familiar with FCR, it lets applications confirm Ethereum blocks in seconds, roughly 30x faster than waiting for finality, under additional assumptions (from waiting 13 minutes to 24 seconds!). It also further solidifies Ethereum L1's case as an asset hub and center of gravity for the onchain economy. FCR now has a safety proof in Lean, closely modeling the rule in the consensus specs, which is the source of truth for Ethereum's consensus clients.
Some takeaways:
> FCR is safe! Under its assumptions, confirmed blocks remain canonical. On top of the manual proofs from the paper, we now have Lean proofs of this for the actual spec, additional evidence for applications considering FCR!
> The bulk of the formal verification work took just a 4-5 days (check out the animation!), with agents working mostly unsupervised. We should be very ambitious about using this as a tool at scale.
> After verifying the current rule, it was easy to adapt the model to the upcoming Gloas changes. Immediately, this surfaced a subtle bug caused by changes to fork choice. The problem was in the spec itself and not a gap in the model. The safety proof would not go through, and the agents could precisely pinpoint what was causing it to fail. The bug is now fixed, and formal verification of the corrected protocol goes through.
Iteration is never quite over, even for "finished" features like FCR, because the protocol keeps evolving around them. A formal model lets us ensure that key properties keep holding throughout the evolution of the protocol. With these capabilities, Ethereum can and should keep upgrading faster, tightening fork timelines and exploring more ambitious features, while still raising the security bar.
This picture has been getting much clearer over the past few months, and the past week confirmed it for me, as @drakefjustin and @corcoranwill brought together 100+ Ethereum researchers, cryptographers and formal verification experts in Cambridge for six days of workshops on post-quantum cryptography, formal verification and fast finality. Beyond its own workshop, formal verification was the omnipresent star of the week: everyone is using Lean and doing amazing things with it! Piece by piece, Ethereum's technological core is being rebuilt for the post-AI age.
The excitement was palpable, the sense of optimism was pervasive, and every talk and conversation carried a level of ambition I'd never seen before. The Ethereum R&D machine is upgrading itself, and we will see the outcome of that on the network sooner than you think.
Ethlabs retweeted
ai/acc
AI is making Ethereum more ambitious.
You might have heard about the challenges that blockchains face in a post-AI world, and while security assumptions will surely be stress-tested in the coming months and years, there is another side to it. I believe AI will let us speedrun towards a world that's both more secure and feature-rich.
As we look towards Ethereum's first post-AI upgrade, Hegotá, the R&D community is asking itself what increasingly powerful tools could help us do differently:
> How far can we push both security and iteration speed?
> How much of the design space can we examine before committing to one?
> How easily can we test the interactions between complex features?
My recent formal verification work @ethlabs_org has given me some reasons to be optimistic about these, as work that would have previously not even been attempted is now being done by agents in days. In September, I posted about using formal verification as part of designing a new consensus protocol. This time, I want to tell you about formally verifying something already fully specified and in production: Ethereum's Fast Confirmation Rule (FCR).
If you are not familiar with FCR, it lets applications confirm Ethereum blocks in seconds, roughly 30x faster than waiting for finality, under additional assumptions (from waiting 13 minutes to 24 seconds!). It also further solidifies Ethereum L1's case as an asset hub and center of gravity for the onchain economy. FCR now has a safety proof in Lean, closely modeling the rule in the consensus specs, which is the source of truth for Ethereum's consensus clients.
Some takeaways:
> FCR is safe! Under its assumptions, confirmed blocks remain canonical. On top of the manual proofs from the paper, we now have Lean proofs of this for the actual spec, additional evidence for applications considering FCR!
> The bulk of the formal verification work took just a 4-5 days (check out the animation!), with agents working mostly unsupervised. We should be very ambitious about using this as a tool at scale.
> After verifying the current rule, it was easy to adapt the model to the upcoming Gloas changes. Immediately, this surfaced a subtle bug caused by changes to fork choice. The problem was in the spec itself and not a gap in the model. The safety proof would not go through, and the agents could precisely pinpoint what was causing it to fail. The bug is now fixed, and formal verification of the corrected protocol goes through.
Iteration is never quite over, even for "finished" features like FCR, because the protocol keeps evolving around them. A formal model lets us ensure that key properties keep holding throughout the evolution of the protocol. With these capabilities, Ethereum can and should keep upgrading faster, tightening fork timelines and exploring more ambitious features, while still raising the security bar.
This picture has been getting much clearer over the past few months, and the past week confirmed it for me, as @drakefjustin and @corcoranwill brought together 100+ Ethereum researchers, cryptographers and formal verification experts in Cambridge for six days of workshops on post-quantum cryptography, formal verification and fast finality. Beyond its own workshop, formal verification was the omnipresent star of the week: everyone is using Lean and doing amazing things with it! Piece by piece, Ethereum's technological core is being rebuilt for the post-AI age.
The excitement was palpable, the sense of optimism was pervasive, and every talk and conversation carried a level of ambition I'd never seen before. The Ethereum R&D machine is upgrading itself, and we will see the outcome of that on the network sooner than you think.
Ethlabs retweeted
AI is making Ethereum more ambitious
AI is making Ethereum more ambitious.
You might have heard about the challenges that blockchains face in a post-AI world, and while security assumptions will surely be stress-tested in the coming months and years, there is another side to it. I believe AI will let us speedrun towards a world that's both more secure and feature-rich.
As we look towards Ethereum's first post-AI upgrade, Hegotá, the R&D community is asking itself what increasingly powerful tools could help us do differently:
> How far can we push both security and iteration speed?
> How much of the design space can we examine before committing to one?
> How easily can we test the interactions between complex features?
My recent formal verification work @ethlabs_org has given me some reasons to be optimistic about these, as work that would have previously not even been attempted is now being done by agents in days. In September, I posted about using formal verification as part of designing a new consensus protocol. This time, I want to tell you about formally verifying something already fully specified and in production: Ethereum's Fast Confirmation Rule (FCR).
If you are not familiar with FCR, it lets applications confirm Ethereum blocks in seconds, roughly 30x faster than waiting for finality, under additional assumptions (from waiting 13 minutes to 24 seconds!). It also further solidifies Ethereum L1's case as an asset hub and center of gravity for the onchain economy. FCR now has a safety proof in Lean, closely modeling the rule in the consensus specs, which is the source of truth for Ethereum's consensus clients.
Some takeaways:
> FCR is safe! Under its assumptions, confirmed blocks remain canonical. On top of the manual proofs from the paper, we now have Lean proofs of this for the actual spec, additional evidence for applications considering FCR!
> The bulk of the formal verification work took just a 4-5 days (check out the animation!), with agents working mostly unsupervised. We should be very ambitious about using this as a tool at scale.
> After verifying the current rule, it was easy to adapt the model to the upcoming Gloas changes. Immediately, this surfaced a subtle bug caused by changes to fork choice. The problem was in the spec itself and not a gap in the model. The safety proof would not go through, and the agents could precisely pinpoint what was causing it to fail. The bug is now fixed, and formal verification of the corrected protocol goes through.
Iteration is never quite over, even for "finished" features like FCR, because the protocol keeps evolving around them. A formal model lets us ensure that key properties keep holding throughout the evolution of the protocol. With these capabilities, Ethereum can and should keep upgrading faster, tightening fork timelines and exploring more ambitious features, while still raising the security bar.
This picture has been getting much clearer over the past few months, and the past week confirmed it for me, as @drakefjustin and @corcoranwill brought together 100+ Ethereum researchers, cryptographers and formal verification experts in Cambridge for six days of workshops on post-quantum cryptography, formal verification and fast finality. Beyond its own workshop, formal verification was the omnipresent star of the week: everyone is using Lean and doing amazing things with it! Piece by piece, Ethereum's technological core is being rebuilt for the post-AI age.
The excitement was palpable, the sense of optimism was pervasive, and every talk and conversation carried a level of ambition I'd never seen before. The Ethereum R&D machine is upgrading itself, and we will see the outcome of that on the network sooner than you think.
Ethlabs retweeted
Once upon a time, the community was upset at how slow Ethereum would ship upgrades, but it faced an impossible conundrum: moving fast while being safe and decentralized.
Then one day, AI started helping out and nothing was the same again.
We’re moving like never before.
AI is making Ethereum more ambitious.
You might have heard about the challenges that blockchains face in a post-AI world, and while security assumptions will surely be stress-tested in the coming months and years, there is another side to it. I believe AI will let us speedrun towards a world that's both more secure and feature-rich.
As we look towards Ethereum's first post-AI upgrade, Hegotá, the R&D community is asking itself what increasingly powerful tools could help us do differently:
> How far can we push both security and iteration speed?
> How much of the design space can we examine before committing to one?
> How easily can we test the interactions between complex features?
My recent formal verification work @ethlabs_org has given me some reasons to be optimistic about these, as work that would have previously not even been attempted is now being done by agents in days. In September, I posted about using formal verification as part of designing a new consensus protocol. This time, I want to tell you about formally verifying something already fully specified and in production: Ethereum's Fast Confirmation Rule (FCR).
If you are not familiar with FCR, it lets applications confirm Ethereum blocks in seconds, roughly 30x faster than waiting for finality, under additional assumptions (from waiting 13 minutes to 24 seconds!). It also further solidifies Ethereum L1's case as an asset hub and center of gravity for the onchain economy. FCR now has a safety proof in Lean, closely modeling the rule in the consensus specs, which is the source of truth for Ethereum's consensus clients.
Some takeaways:
> FCR is safe! Under its assumptions, confirmed blocks remain canonical. On top of the manual proofs from the paper, we now have Lean proofs of this for the actual spec, additional evidence for applications considering FCR!
> The bulk of the formal verification work took just a 4-5 days (check out the animation!), with agents working mostly unsupervised. We should be very ambitious about using this as a tool at scale.
> After verifying the current rule, it was easy to adapt the model to the upcoming Gloas changes. Immediately, this surfaced a subtle bug caused by changes to fork choice. The problem was in the spec itself and not a gap in the model. The safety proof would not go through, and the agents could precisely pinpoint what was causing it to fail. The bug is now fixed, and formal verification of the corrected protocol goes through.
Iteration is never quite over, even for "finished" features like FCR, because the protocol keeps evolving around them. A formal model lets us ensure that key properties keep holding throughout the evolution of the protocol. With these capabilities, Ethereum can and should keep upgrading faster, tightening fork timelines and exploring more ambitious features, while still raising the security bar.
This picture has been getting much clearer over the past few months, and the past week confirmed it for me, as @drakefjustin and @corcoranwill brought together 100+ Ethereum researchers, cryptographers and formal verification experts in Cambridge for six days of workshops on post-quantum cryptography, formal verification and fast finality. Beyond its own workshop, formal verification was the omnipresent star of the week: everyone is using Lean and doing amazing things with it! Piece by piece, Ethereum's technological core is being rebuilt for the post-AI age.
The excitement was palpable, the sense of optimism was pervasive, and every talk and conversation carried a level of ambition I'd never seen before. The Ethereum R&D machine is upgrading itself, and we will see the outcome of that on the network sooner than you think.
Official writeups are coming soon.
And of course, a special thank you to organizers @corcoranwill & @drakefjustin for making this all a reality. The world of frontier cryptography, and Ethereum, is better because of it.
xitter.cf/corcoranwill/status/21…
The excitement does not stop! This thread may last forever.
xitter.cf/yannvon/status/2111142…
It’s a wrap! It was an honor to help organize the Fast Finality workshop in Cambridge.
There have already been some great recaps, but here’s my quick overview of the main topics we covered:
1. Deep-diving DC: Decoupled Consensus is a super ambitious upgrade we hope to ship in I* (h/t @benjaminion_xyz). @robsaltini gave a great overview, and @fradamt unveiled his impressive recent breakthroughs, e.g. achieving short-term async resilience through local locks.
2. Shipping DC: Sessions on critical research and engineering, including networking benchmarks & devnets (@sukunrt & Csaba), rewards & incentives (@weboftrees), and specs & testing (@mkalinin2, @jtraglia, @tcoratger).
3. Securing DC: Formal verification meets fast finality. We explored exciting new AI-enabled opportunities (@fradamt & @robsaltini), building on years of great FV work (@alexanderlhicks).
4. Future of Fast Finality: Aligning DC with future needs. This covered PQ networking (@kamil_abiy & @kevaundray), finality in tens of seconds with PQ validators (@barnabemonnot), lean clients & prototyping (@pablodeymo, Mega, Mihir, Locky, @adust09, @ladislaus0x), and one-round finality & other future research (shoutout @alranpe, @jneu_net, @ittai & Neil).
Huge thanks to everyone who made this workshop a success! Special thanks to @benjaminion_xyz for all the help and guidance, and of course to @justindrake and @willcorcoran for making it possible!
The next Ethereum upgrades look exciting and many topics will be even more accelerated by the time we are all at @EFDevcon.
xitter.cf/kamil_abiy/status/2111…
Leaving Cambridge after a few days of PQ and fast finality workshops.
Decoupled consensus looks to be in a good shape and should be ready by the I*.
The next big thing is PQ aggregation for XMSS attestations, which is the biggest unknown for many people. A few questions we discussed in Cambridge:
* Should aggregators be incentivized?
* Should anyone be able to aggregate, or should it be a specialized role?
* Should we assume sophisticated entities will want to aggregate, or rely only on existing validators?
It feels like people are leaning towards no specialized role.
My take: the network has enough entities interested in fast finality. It should let them join and aggregate with whatever hardware they have to produce the global aggregation by the next slot.
But the network must keep running if those entities disappear.
That's the direction the networking should be optimizing for. We'll bring this topic for the devcon to further elaborate assumptions we are working on
Love for Ethereum is looking good here.
xitter.cf/adust09/status/2111033…
Our own @fradamt left feeling inspired by the progress and potential that he saw. In this post, he highlighted how he believes that AI is helping accelerate all of it.
The future may be closer than we think.
xitter.cf/fradamt/status/2111125…
AI is making Ethereum more ambitious.
You might have heard about the challenges that blockchains face in a post-AI world, and while security assumptions will surely be stress-tested in the coming months and years, there is another side to it. I believe AI will let us speedrun towards a world that's both more secure and feature-rich.
As we look towards Ethereum's first post-AI upgrade, Hegotá, the R&D community is asking itself what increasingly powerful tools could help us do differently:
> How far can we push both security and iteration speed?
> How much of the design space can we examine before committing to one?
> How easily can we test the interactions between complex features?
My recent formal verification work @ethlabs_org has given me some reasons to be optimistic about these, as work that would have previously not even been attempted is now being done by agents in days. In September, I posted about using formal verification as part of designing a new consensus protocol. This time, I want to tell you about formally verifying something already fully specified and in production: Ethereum's Fast Confirmation Rule (FCR).
If you are not familiar with FCR, it lets applications confirm Ethereum blocks in seconds, roughly 30x faster than waiting for finality, under additional assumptions (from waiting 13 minutes to 24 seconds!). It also further solidifies Ethereum L1's case as an asset hub and center of gravity for the onchain economy. FCR now has a safety proof in Lean, closely modeling the rule in the consensus specs, which is the source of truth for Ethereum's consensus clients.
Some takeaways:
> FCR is safe! Under its assumptions, confirmed blocks remain canonical. On top of the manual proofs from the paper, we now have Lean proofs of this for the actual spec, additional evidence for applications considering FCR!
> The bulk of the formal verification work took just a 4-5 days (check out the animation!), with agents working mostly unsupervised. We should be very ambitious about using this as a tool at scale.
> After verifying the current rule, it was easy to adapt the model to the upcoming Gloas changes. Immediately, this surfaced a subtle bug caused by changes to fork choice. The problem was in the spec itself and not a gap in the model. The safety proof would not go through, and the agents could precisely pinpoint what was causing it to fail. The bug is now fixed, and formal verification of the corrected protocol goes through.
Iteration is never quite over, even for "finished" features like FCR, because the protocol keeps evolving around them. A formal model lets us ensure that key properties keep holding throughout the evolution of the protocol. With these capabilities, Ethereum can and should keep upgrading faster, tightening fork timelines and exploring more ambitious features, while still raising the security bar.
This picture has been getting much clearer over the past few months, and the past week confirmed it for me, as @drakefjustin and @corcoranwill brought together 100+ Ethereum researchers, cryptographers and formal verification experts in Cambridge for six days of workshops on post-quantum cryptography, formal verification and fast finality. Beyond its own workshop, formal verification was the omnipresent star of the week: everyone is using Lean and doing amazing things with it! Piece by piece, Ethereum's technological core is being rebuilt for the post-AI age.
The excitement was palpable, the sense of optimism was pervasive, and every talk and conversation carried a level of ambition I'd never seen before. The Ethereum R&D machine is upgrading itself, and we will see the outcome of that on the network sooner than you think.
And we are not done yet, the excitement is clear everywhere.
xitter.cf/tcoratger/status/21110…
