←
Toni Wahrstätter ⟠2,572 posts
Toni Wahrstätter ⟠ avatar

Toni Wahrstätter ⟠

@nero_eth

serving ethereum at @ethereumfndn

◷ Joined December 2021▧ 331 Photos and videos
Toni Wahrstätter ⟠ avatar
Toni Wahrstätter ⟠@nero_eth·May 20

Ethereum is about to fundamentally change how blocks are executed. With the upcoming Glamsterdam hardfork, it's shipping EIP-7928: Block-level Access Lists, a proposal that brings parallelization to the EVM. Here's a short explainer of what it is, how it works, and why it's a big deal for scaling. Let's start from the top. Alongside EIP-7732 (ePBS), EIP-7928 is the execution-layer (EL) headliner for Glamsterdam. Like ePBS, the main focus has been scaling Ethereum, though both proposals come with a bunch of other, equally important properties on the side e.g. removing trust requirements from the PBS pipeline or improving sync. EIP-7928 adds a Block Access List (BAL) to every Ethereum block. A BAL is a list of accounts and storage slots that the block touches, but that's not all: it also contains post-transaction state diffs (this part is critical!). Post-transaction state diffs tell you what the state looks like after each transaction. Quick example: user A swaps 1 ETH for DAI on DEX B. The BAL tells you that user A's ETH balance decreased by 1 ETH + tx fees and their nonce went up by 1; that DEX B's ETH balance went up by 1 ETH; and that inside the DAI contract, user A's DAI balance increased while DEX B's decreased. In other words, all of that info becomes statically available, something that previously required tracing the transaction. Client software (Geth, Nethermind, Besu, Erigon, Reth, Ethrex, Nimbus) can use this to do a few very powerful things: 1. Parallelize transaction execution. Knowing the post-state of each tx resolves the dependencies between them. No transaction has to wait on the previous one anymore, so execution can be perfectly parallelized. Instead of large parts of block validation sitting idle waiting on sequential execution, clients can finally make much better use of modern hardware. 2. Batch prefetch. One of the most cumbersome jobs for a node has been fetching the state needed for execution from disk. Because state locations (e.g. the exact storage slot in the DAI contract where user A's balance lives) are only discovered along the way, while executing, state-fetching has been a real drag on scaling: it blocks execution, takes time, and eventually slows everything down. With BALs, everything a node needs for execution is known upfront and can be loaded into cache in one go, in parallel. This speeds things up even further. 3. Parallelize post-state root calculation. Another expensive task is walking the updated state tree to compute the post-state root, which is needed so that everyone agrees on what's on disk after executing the block. With the post-tx state already in the BAL, nodes can do this in parallel while executing. A heavy task that used to wait until all transactions had finished can now run alongside prefetching and execution. 4. Snap sync (v2). An often overlooked, less sexy aspect of blockchains is syncing. Nodes need to catch up with the chain, and they need to catch up faster than the chain progresses. Today, most nodes do snap sync: downloading blocks, headers, and state in parallel while chasing the tip, and then "healing" the database once they're close to the head. Healing means asking peers for trie nodes, receiving them, validating them, and updating the local DB. It's iterative, networking-heavy, can take a while, and especially higher throughput pushes that phase to its limits. BALs help here too: with snap v2, nodes can catch up to the tip and skip the healing phase entirely. Syncing at higher throughput becomes more robust and reliable. So, to summarize, a BAL contains two things: -> The state locations the block accesses -> The state changes after each tx (incl. the new values) We're already seeing big performance gains today: on 6-core machines, EL clients validate blocks up to 5x faster, making block gas limits of 300M a very realistic outcome. ePBS will add to that by decoupling the block from the payload, giving validators 2-4x more time for execution. To not overshoot (security stays priority #1), the fork will likely ship with a 200M gas limit, but we shouldn't be stuck there for long before pushing to 300M and beyond. That's a 10x in scaling since we started taking the topic seriously, without touching hardware requirements. None of this would have happened without people going all-in, heads down, shipping: so many hours spent in calls debating the right design, so many iterations refining the specs, and tons of test cases written (and still being worked on). The road from whiteboard to production-ready code has been a journey, and we're not at the finish line yet, but from what I can tell, things look super bullish for Ethereum. Glamsterdam will be a fork that shows what's possible when a distributed, decentralized community works on a shared goal, laser-focused on providing enough block space to onboard the next wave of users.

Pierre avatar
⟳ Toni Wahrstätter ⟠ retweeted
Pierre@xyz_pierre·4h

we are launching a stealth addresses working group, featuring the best engineering teams dedicated to solving stealth addresses’ toughest crypto and ux problems on Ethereum goals: pq security, new keystore designs, hardware wallets integration and broadening adoption let’s go! stealthaddresses.xyz/

Toni Wahrstätter ⟠ avatar
Toni Wahrstätter ⟠@nero_eth·6h

Quick take from my side after reading the recent posts from @potuz_eth, @ethlabs_org, @mikeneuder and @soispoke on PQAI. Definitely recommend reading all of them. Links below. Very short summary: Potuz and Ethlabs want to go all in on PQ and only ship what's really needed. Mike thinks rushing PQ is premature, but agrees that hardening the clients is super important. Thomas wants to parallelise and keep shipping non-PQ features like FOCIL. I think pqai will come with all kinds of threats, and AI getting better at finding bugs is the one we already experience. The PQ changes alone are already a lot of new code: new signatures, leanVM, much bigger messages on the p2p layer, new key handling. Every line of that needs to be understood by someone, tested and hardened. That's risky enough already, so I'd rather not add more features on top. For people hunting bugs, it makes a big difference whether a fork is Frames or Frames + FOCIL. More code means more to understand and test, more interactions, and that doesn't really parallelise. So I could see the PQ work being done as "slim" feature forks (Frames, leanVM, DC), with FOCIL coming back once we know what PQ consensus looks like. The only things I'd ship alongside are hardening and simplifications. I think in times where AI gets crazy good at breaking things, that kind of work will be very welcome. My comment: ethereum-magicians.org/t/tho… Potuz: potuz.net/posts/pq/ Ethlabs: ethereum-magicians.org/t/an-… Mike: hackmd.io/@mikeneuder/though… Thomas: ethereum-magicians.org/t/tho…

Toni Wahrstätter ⟠ avatar
Toni Wahrstätter ⟠@nero_eth·Nov 17

Discussions around light clients surface quite fundamental questions about the future of state exchange: With growing state, who'll be able to maintain it at an increasing cost, and what role do light clients play in the network. Today, every full node helps its peers during sync and delivers them state (key -> value pairs), and a proof (MPT proof against the state root in the block header). MPT proofs can be quite big but it's still quite efficient for downloading large chunks of state e.g. during initial sync where the proof size is less of a problem relative to the total amount of data downloaded. With Validity-Only-Partial-Statefulness (VOPS), Ethereum can recognize a low-hardware node that drops most of the EL state but keeps enough to still participate in the mempool, as a validator or an inclusion list builder. Such nodes are a great compromise for some use cases but have downstream effects: with today's state tree, those nodes cannot help others syncing anymore. Syncing requires nodes to deliver a proof against the state root, and nodes who drop even tiny pieces of state risk not being able to compute those proofs. They become useless peers during sync. It's an acceptable trade-off for some nodes, but the final design must ensure that it's incentive compatible (or at least maintains the status quo) to run a node that automatically contributes back to the network. For that to work efficiently, we need a new tree (eip-8297), allowing nodes to drop state while still being able to deliver proofs to peers that ask for state they have. This allows VOPS nodes to sync other VOPS nodes, but doesn't answer the more challenging question of what to do with the rest of the state, and who keeps it.

State proof size matters, but more fundamental problem is the incentive mechanism. Partial stateful nodes download the state and they also serve the requests, good. Light-clients download the state but do nothing more. We need to make sure the relationship of client/server is healthy.

soispoke.eth avatar
⟳ Toni Wahrstätter ⟠ retweeted
soispoke.eth@soispoke·Nov 16

leanPCS is a total bull I think the amount of use cases it will unlock is beyond what we can imagine today, and not having to go through the friction of convincing everyone we need to enshrine a new ISA is the best path forward. EIP coming soon, stay tuned!

Over the past few weeks I've gone from thinking leanPCS is total bull to being a total bull. So let me explain some of these buzzwords in more detail. At the core, 8288 is about hyper-scaling data and execution for any computation that needs to get performed on a piece of data once, the chain learns the answer, and then we never need to see that data again. This sounds very specific, but it includes most "heavy" things happening on Ethereum: * Signatures * STARKs * Merkle branches * FHE computation * ... Really the first two are the most important. Once we go quantum-safe, signatures get bigger (65 bytes ECDSA -> 1-6 kB WOTS/SPHINCS depending on params) and ZKPs get much bigger (200-1000 bytes with groth16, PLONK, etc -> 128 kB with STARKs). This is unsustainable to put on chain, and 8288 fixes this. 8288 works by aggregating STARKs in the mempool. First, you as a user generate the STARK or SPHINCS signature or PCS opening (more on that last one later), and publish it. Then, each node listens. Each tick, each node takes all of the new objects that it has seen, and generates a STARK containing a list of "claims": "pubkey P has signed message M" "program X run on data D has output Y" "p(X) = Y for some polynomial P whose hash is H" and a proof that it has seen a signature, STARK or PCS opening verifying those claims. So the only information getting re-broadcasted is: (i) hashes of inputs and outputs (~64-96 bytes per claim) (ii) a single STARK proof per tick These aggregate proofs themselves get re-aggregated, and eventually you get to a single "master proof" in the block, that verifies that all of those statements are true. And so the only other data that has to actually go on chain is the statements (the (P, M), (X, D, Y), (X, Y, H) tuples I described above), not the actual signatures or proofs. This gets put into a specialized frame type. Now, let's get into the leanSPHINCS vs leanSTARK vs leanPCS part. The core distinction is: *what is the underlying object that the user is creating?* In leanSPHINCS, it's a signature, and specifically this particular type of purely-hash-based signature: ethresear.ch/t/sphincs-minus… If we add leanSPHINCS, then users will be able to make quantum-safe accounts, and pay only a little bit of gas (4096 for the 64 bytes) for each signature. So we get scalable quantum-safety for regular accounts, multisigs, etc. But it's only one specific signature scheme, you can't do anything else. In leanSTARK, it's a STARK. This means it's fully general: the user runs whatever computation they want, and publish a STARK of it. So you can use it for: * Any signature scheme (including eg. lattice-based ones if you like those) * A multisig that hides its internal logic * Privacy protocols * Private account abstraction: authorization logic that depends on some value hidden elsewhere in the state, so you can have one key that controls all your accounts without publicly linking them to each other Basically, it's a free for all, in the same way the EVM is a free for all. But leanSTARK has a practical downside. The protocol would have to specify the language in which users write their programs (we call this the "ISA"). So we would have to agree on that language. This is a really big deal - it's the first big case of "Ethereum moving beyond the EVM" - and so it's likely to take time to agree on the details of it, especially since the ISA would be hard to upgrade. There are benefits to taking longer on this, figuring out the ideal ISA, and then even giving access to it inside regular contracts. LeanPCS is the third option. PCS stands for "polynomial commitment scheme": a proof that P(x) = y. The most important thing to know about PCSes is that they are by far the most important "hard" component of a STARK (see here: vitalik.eth.limo/general/202… ). If you have a "magic PCS oracle" (which from the EVM's point of view, 8288 is), you can verify a STARK in ~20-40k gas. The most important gain with PCS is that there is far less that we need to choose. Specifying a PCS only requires specifying a field, and there is a natural option: the 128 bit binary field (technically, we can go more general than that, and say the 2^k-bit binary recursive tower field, going up to 256) LeanPCS is less efficient than leanSTARK onchain, because you would have to put multiple claims to prove one thing. But it's arguably more efficient offchain, because you have much more flexibility to choose proof systems. But most importantly, leanPCS gives you the same generality as leanSTARK, in a way that could potentially be implemented very quickly. And once we figure out the ISA, we can add leanSTARK later. So there is a route to getting "the cryptographic proof singularity" much faster than any of us expected, and that route runs through 8288 with leanPCS. firefly.social/post/x/212092…

Toni Wahrstätter ⟠ avatar
Toni Wahrstätter ⟠@nero_eth·Nov 16

EIP-8288 is exciting, and one of the most exciting parts is the unlock for privacy protocols. Today, every privacy transaction comes with it's own zk proof, and all of them are verified independently. With leanSTARK/leanPCS, they can be aggregated in the mempool and batch-verified once (=less data, less compute). Using privacy protocols will become cheaper and more native to Ethereum.

Over the past few weeks I've gone from thinking leanPCS is total bull to being a total bull. So let me explain some of these buzzwords in more detail. At the core, 8288 is about hyper-scaling data and execution for any computation that needs to get performed on a piece of data once, the chain learns the answer, and then we never need to see that data again. This sounds very specific, but it includes most "heavy" things happening on Ethereum: * Signatures * STARKs * Merkle branches * FHE computation * ... Really the first two are the most important. Once we go quantum-safe, signatures get bigger (65 bytes ECDSA -> 1-6 kB WOTS/SPHINCS depending on params) and ZKPs get much bigger (200-1000 bytes with groth16, PLONK, etc -> 128 kB with STARKs). This is unsustainable to put on chain, and 8288 fixes this. 8288 works by aggregating STARKs in the mempool. First, you as a user generate the STARK or SPHINCS signature or PCS opening (more on that last one later), and publish it. Then, each node listens. Each tick, each node takes all of the new objects that it has seen, and generates a STARK containing a list of "claims": "pubkey P has signed message M" "program X run on data D has output Y" "p(X) = Y for some polynomial P whose hash is H" and a proof that it has seen a signature, STARK or PCS opening verifying those claims. So the only information getting re-broadcasted is: (i) hashes of inputs and outputs (~64-96 bytes per claim) (ii) a single STARK proof per tick These aggregate proofs themselves get re-aggregated, and eventually you get to a single "master proof" in the block, that verifies that all of those statements are true. And so the only other data that has to actually go on chain is the statements (the (P, M), (X, D, Y), (X, Y, H) tuples I described above), not the actual signatures or proofs. This gets put into a specialized frame type. Now, let's get into the leanSPHINCS vs leanSTARK vs leanPCS part. The core distinction is: *what is the underlying object that the user is creating?* In leanSPHINCS, it's a signature, and specifically this particular type of purely-hash-based signature: ethresear.ch/t/sphincs-minus… If we add leanSPHINCS, then users will be able to make quantum-safe accounts, and pay only a little bit of gas (4096 for the 64 bytes) for each signature. So we get scalable quantum-safety for regular accounts, multisigs, etc. But it's only one specific signature scheme, you can't do anything else. In leanSTARK, it's a STARK. This means it's fully general: the user runs whatever computation they want, and publish a STARK of it. So you can use it for: * Any signature scheme (including eg. lattice-based ones if you like those) * A multisig that hides its internal logic * Privacy protocols * Private account abstraction: authorization logic that depends on some value hidden elsewhere in the state, so you can have one key that controls all your accounts without publicly linking them to each other Basically, it's a free for all, in the same way the EVM is a free for all. But leanSTARK has a practical downside. The protocol would have to specify the language in which users write their programs (we call this the "ISA"). So we would have to agree on that language. This is a really big deal - it's the first big case of "Ethereum moving beyond the EVM" - and so it's likely to take time to agree on the details of it, especially since the ISA would be hard to upgrade. There are benefits to taking longer on this, figuring out the ideal ISA, and then even giving access to it inside regular contracts. LeanPCS is the third option. PCS stands for "polynomial commitment scheme": a proof that P(x) = y. The most important thing to know about PCSes is that they are by far the most important "hard" component of a STARK (see here: vitalik.eth.limo/general/202… ). If you have a "magic PCS oracle" (which from the EVM's point of view, 8288 is), you can verify a STARK in ~20-40k gas. The most important gain with PCS is that there is far less that we need to choose. Specifying a PCS only requires specifying a field, and there is a natural option: the 128 bit binary field (technically, we can go more general than that, and say the 2^k-bit binary recursive tower field, going up to 256) LeanPCS is less efficient than leanSTARK onchain, because you would have to put multiple claims to prove one thing. But it's arguably more efficient offchain, because you have much more flexibility to choose proof systems. But most importantly, leanPCS gives you the same generality as leanSTARK, in a way that could potentially be implemented very quickly. And once we figure out the ISA, we can add leanSTARK later. So there is a route to getting "the cryptographic proof singularity" much faster than any of us expected, and that route runs through 8288 with leanPCS. firefly.social/post/x/212092…

Toni Wahrstätter ⟠ avatar
Toni Wahrstätter ⟠@nero_eth·Nov 16

Managing state is one of the most difficult challenges, and until we have a sustainable solution, we face a trade-off: Scaling while allowing state to grow too large harms decentralization because fewer people can afford the required hardware. Scaling while repricing state growth impacts the application layer. Not scaling the chain goes against what many in the community want: affordable transactions and enough block space to support adoption. It also isn't a sustainable solution, as state would continue to grow anyway. Supporting PQ security and privacy will require more gas per transaction. Without increasing the gas limit, we'd effectively reduce throughput. For Glamsterdam, we're facing this trade-off with EIP-8037 and EIP-8038, which propose repricing state-related operations, including state access and growth. As gas limits increase, state grows disproportionately quickly, and without mitigating the negative impact through repricings, we'd have to increase hardware requirements. Interestingly, state is growing slower than originally anticipated in EIP-8037. Still, at a gas limit of 200M and without shipping EIPs that address this problem, we would add ~255 GiB of new state every year.

Post attachment

My views on EIP-8037: docs.fileverse.io/document/d…

Post attachmentPost attachment
Toni Wahrstätter ⟠ avatar
Toni Wahrstätter ⟠@nero_eth·Nov 15

In my devcon talk, I called state growth one of the biggest challenges for Ethereum's future. Affordable hardware scales slower than Ethereum would need, and while there are solutions for scaling compute or PQ, we're only making bady steps towards solving state. For decentralization, Ethereum must keep hardware requirements low and find other ways to limit state growth.

Scaling Ethereum is important. Here's my Devcon 2026 talk about the past, present and future of scaling: youtu.be/Jvc_mZM6SJY?si=ilqW…

Lion ⟠ dapplion .eth avatar
⟳ Toni Wahrstätter ⟠ retweeted
Lion ⟠ dapplion .eth@dapplion·Nov 13

i had a talk at devcon about speeding up coding with llms. so i put a phone on my slides playing a silent 19 min movie about a bored dev in my audience who lets claude run his life

2:14
Toni Wahrstätter ⟠ avatar
Toni Wahrstätter ⟠@nero_eth·Nov 13

In the next ~two weeks, core devs may revisit the Hegota scope and consider whether a narrower focus on PQ would help us move faster. Reconsidering headliner EIPs like FOCIL or features that help us scale or reduce slot times is a significant step. These features have value, and changing an agreed scope has costs too, so the question is how to balance those priorities with the goal of full PQ readiness in 2028. And this brings us to where we are today: Glamsterdam ships soon, and Hegota is actively being worked on. Frame transactions have been chosen as the EL headliner for the fork. That's a great first step toward the PQ transition on the EL and something that needs to start asap because users, hardware wallets, dapps, and wallets need clarity to build PQ-ready tools, as well as time for this complicated transition. On the CL side, Hegota is expected to include a new registration contract for validators to preregister PQ keys, but larger PQ changes aren't scheduled yet. FOCIL (= inclusion lists) has been chosen as the CL headliner, but one question now is whether its size and interactions with frame transactions could complicate delivery and potentially delay that first step toward PQ. Some say FOCIL is ready and that if the interactions with frame txs are the problem, we could initially exclude frame txs from ILs. That could be worth evaluating, especially if it allows us to keep an agreed headliner without affecting the timeline. Ofc, this would also mean leaving some work for later and since privacy txs will need frame txs, focil wouldn't be able to support those. At the same time, every feature/EIP adds some complexity to a fork, and while existing progress is great, there's usually a long way to go from "ready on devnets" to "production ready." Ideally, the decision should therefore reflect concrete estimates of the remaining work and the interactions with frames. CL core devs will need to begin focusing on a PQ-ready version of Decoupled Consensus soon, which is a rather big effort by itself, and while not every dev should focus only on the PQ transition, there's a lot of hardening work ahead of us too and it might be good to free up dev resources by slimming down forks in general. Personally, I lean toward keeping Hegota focused on initiating the PQ transition, even if that means deferring FOCIL, but that depends on how much work and timeline risk it actually adds. If we can ship both with confidence, that's a good outcome too.

Toni Wahrstätter ⟠ avatar
Toni Wahrstätter ⟠@nero_eth·Nov 12

Also, here's the cocktail that I'd recommend everyone involved, the Mumbai Aftermath. Tart, spicy, and just restorative enough to pretend last night went well. (h/t) @corcoranwill

Post attachment
Toni Wahrstätter ⟠ avatar
Toni Wahrstätter ⟠@nero_eth·Nov 12

My personal summary of the recent discussions: PQ has become the biggest focus for Ethereum. There's still disagreement, but it feels like people have mostly agreed on "how we're doing it" and the remaining debate is about "when" or "how fast". I see two camps: those pushing for two forks in 2027, including complicated features like Frame Transactions, Decoupled Consensus, and leanVM, and those who think these timelines are unrealistic and that we shouldn't rush the transition, even if it takes until 2028. Glamsterdam will be the largest fork since PoS, and it took a while (>1y; still not shipped). Complex features take time and 100% uptime is important. Thus, shipping the PQ transition much faster is somewhere between ambitious and impossible. Focusing on PQ might mean pulling FOCIL and other features from Hegota. That's a pretty big step, given that we've already agreed to ship it as a headliner. On the other hand, it seems reasonable to ship Hegota with only Frame Txs much faster than e.g. Glamsterdam, and DC could be nicely pipelined alongside, receiving significant focus from CL core devs. The truth is probably somewhere in between: Frame Txs can ship faster without having to deal with the FOCIL interactions, and (PQ-)DC could be more complex than some might think (for it to work efficiently, we need leanVM's aggregation too). One possible path would be Frame Transactions in Hegota, slimming the fork down with no big feature on the CL, and Decoupled Consensus in I*. Whether I* happens in 2027 or 2028 doesn't matter too much, imo. The main question is whether pulling FOCIL accelerates the PQ transition. I think it does, and we should have that discussion. Overall, people are aligned on where we want to go. Now it's mostly about figuring out how fast we can get there.

pqai27: Our view on post-quantum and post-AI timelines. We shared this on Ethereum Magicians as input into the Ethereum governance process. ethereum-magicians.org/t/pqa…

Post attachment
Toni Wahrstätter ⟠ avatar
Toni Wahrstätter ⟠@nero_eth·Nov 10

Join ACDT with questions/concerns and make them heard. Ethereum is special and so is its government process. App devs and core devs must be able to have a respectful discussion without letting emotions take over or falling back on stereotypes.

Glamsterdam + 8037/8 Update Thanks to everyone who has spoken up and submitted. Goal: audit reprorts before ACDT on Nov 16. No decision on spec changes or Hoodi yet, keep the input coming Nov 16 ACDT: findings, open Q&A. App devs welcome. More: blog.ethereum.org/2026/11/06…

Toni Wahrstätter ⟠ avatar
Toni Wahrstätter ⟠@nero_eth·Nov 7

Devcon in Mumbai was great! It's motivating to see so many young builders entering the ecosystem with great ambition and talent. Ethereum is in a unique position to win and the next year is going to be an important one. Looking forward to Lisbon and all the pastel de nata waiting for us there.

Devcon 9 is coming to Lisbon! 🇵🇹 October 11–13, 2027 Building on Mumbai, we're bringing Ethereum's builders together with more friends and allies working toward a freer, more open internet.

1:08