Eugenio Reggianini retweeted
Today the authoritarian EU sanctioned me, no recourse to defend myself, no hearing, no evidence.
They want to bully me into silence, they want to deny you your God-given right to hear dissenting opinions, they want to kill freedom of speech.
Their allegations against me are utterly baseless, their insinuations are false, they are terrified of the Truth
I will fight this assault on our right to dissent with every fibre of my being, I will not be silenced, I will not take the knee for the enemies of free thought, reason and Democracy
Eugenio Reggianini retweeted
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…
Eugenio Reggianini retweeted
The biggest breakthroughs in Ethereum aren’t just about improving what we can already do. They’re about unlocking entirely new possibilities.
Today, @tw_tter and I will introduce something that could fundamentally change how we think about L2s
Trust me, you won’t leave this talk thinking about L2s the same way
The devs did something.
Many things, as it turns out.
Not one, but THREE firsts for synchronous composability between a rollup and Ethereum mainnet. @tw_tter and @eduadiez will demo them live on Lotus Stage 1 at Devcon, 13:00 IST.
We even had the devs make their own launch video.
Cast, in order of appearance: @SCBuergel , @antonimarber, @chetnamiittal, @debjitbw, @JesusLigero3, @jbaylina , @turingtestrun, @eduadiez, @filoozom, @epochzer0, @tw_tter , and @0xKenk .
One @ethereum .
Details of the news and the demos in thread. 🧵
Eugenio Reggianini retweeted
The devs did something.
Many things, as it turns out.
Not one, but THREE firsts for synchronous composability between a rollup and Ethereum mainnet. @tw_tter and @eduadiez will demo them live on Lotus Stage 1 at Devcon, 13:00 IST.
We even had the devs make their own launch video.
Cast, in order of appearance: @SCBuergel , @antonimarber, @chetnamiittal, @debjitbw, @JesusLigero3, @jbaylina , @turingtestrun, @eduadiez, @filoozom, @epochzer0, @tw_tter , and @0xKenk .
One @ethereum .
Details of the news and the demos in thread. 🧵
Eugenio Reggianini retweeted
Anthropic @AnthropicAI ❤️ zkSTARKs:
In collaboration with @StarkWareLtd co-founder Prof. Alessandro Chiesa and other brilliant researchers, Anthropic just open sourced a zk STARK system for proving the integrity of LLM inferencing, bringing us closer to verifiable AI.
As we said long ago (since 2018), zkSTARKs are the end-game: highest scale, best security (post-quantum). Now, also AI agile and supporting AI integrity.
anthropic.com/research/prova…
Eugenio Reggianini retweeted
1/8 🚨 There's a fundamental problem with how we distribute security updates today.
The moment a software patch is released, it can also become a roadmap for attackers.
We need to rethink how security updates are delivered. 🧵
UPDATE: Specific mitigation guidance for the recently identified PHP critical vulnerabilities is now available. Secure your servers today. Guidance and technical steps here: nsa.gov/Press-Room/Press-Rel…
Effective Immediately, all organizations using PHP for their systems are advised to be prepared for an update addressing two critical vulnerabilities. PHP is widely used for web applications. These vulnerabilities often provide a direct path to the server's file system or database. If an immediate update is not feasible, it is recommend that organizations take the system offline until it can be fully mitigated. NSA will follow up shortly with more specific guidance.
Eugenio Reggianini retweeted
Not many people know @VitalikButerin wrote the first cheque for Privacy Pools.
Since then, @ameensol and I have worked to make compliant privacy in a simple UX accessible to everyone.
Now it’s here 🎉
Huge thanks to Vitalik and everyone who backed us!
Eugenio Reggianini retweeted
Ethereum executes what you authorize. But does what you authorize correspond to what you expect? Not always.
Today there is no generalized way for onchain code to check what a txn changed and revert it. Native transaction assertions could close this gap.
blog.ethereum.org/2026/10/05…
Eugenio Reggianini retweeted
It's an underappreciated triumph of Ethereum client developers that PeerDAS has now been running for nearly a year with basically no problems.
PeerDAS was a complex task: it's the first large-scale instance of a blockchain that achieves consensus on the availability of data without needing any single node to download the entire block. Decentralized consensus without replication.
And yet, it worked.
Eugenio Reggianini retweeted
custom RPC + tor gateway support now live for v2
more customization, more control, more privacy
in @0xprivacypools v2 not only can you:
- connect without a wallet to withdraw
- use your own custom RPCs for extra privacy
but now you can also connect to your TOR gateway, right from the browser 😎
1-click privacy ftw
Eugenio Reggianini retweeted
Arithmetic-friendly hashes have long been one of the weakest pieces of prover cryptography.
With ZisK v1.3.0, we removed Poseidon entirely and moved to BLAKE3.
What surprised us is that we got the same performance — or even better.
After many optimizations elsewhere in the prover, hashing had become one of the most time-consuming parts of proof generation. BLAKE3 is more than an order of magnitude faster, making this cost almost disappear and largely compensating for the increased complexity of the recursion circuit.
Getting there required a lot of re-engineering: circuit sizes, prover scheduling, and architecture all had to be reconsidered around the new trade-offs that BLAKE3 gives us. The final result surprised even us.
There is a lot of focus today on binary-field proving. Binary fields attack the hash-proving bottleneck from a different direction, but introduce different trade-offs when proving regular arithmetic. There is a huge amount of research happening here, and at ZisK we are following it very closely.
I'm genuinely curious to see whether binary-field architectures will outperform what we can achieve with the current approach — and how long it will take.
So I like to think of v1.3.0 as setting a new target. 🎯
To everyone working on binary fields — and to all of us trying to make provers faster: let's see if we can beat it :)
And we still have a few optimizations in the basket.
ZisK v1.3.0-alpha release 🚀
ZisK is moving beyond arithmetic hashes with BLAKE3 strengthening security while outperforming our prior Poseidon1 version:
⚡ 7.43s p999 on 4×5090
⚡ 5.14s p999 on 8×5090
🛡️ 128-bit provable security
🔐 Post-quantum secure
This is a major step toward faster and safer proving.
Release notes: github.com/0xPolygonHermez/z…
Eugenio Reggianini retweeted
EIP-7906 will make it impossible to exploit transaction simulations, allowing transaction to enforce the results of the simulation with post-transaction assertions.
Eugenio Reggianini retweeted
Meet our next ETHSpain 2026 speaker: @Reggia91 👀
An Independent Business & Product Development Manager, Eugenio will join the Ethereum community in Barcelona on September 17.
Builders, ideas & conversations shaping the future of Ethereum.
See you at ETHSpain 🙌
Eugenio Reggianini retweeted
One positive consequence of all the recent detailed thinking about transaction formats - not just 8141, also "future of state" discussions eg. UTXOs, PBT, keyed nonces, and also recursive STARK mempool - is that we have a much more explicit understanding of how transactions have "actions" and "dependencies", and we can engineer around optimizing the two separately.
An action is an effect that a transaction has.
A dependency is a fact about the transaction and/or the state that must be true for the transaction to be valid.
eg. a signature is a dependency, a Merkle proof of a UTXO is a dependency, a ZK-SNARK (or STARK) is a dependency, a call that sends ETH is an action
Dependencies can be processed in parallel. Dependencies that involve state can be reasoned about by a mempool, especially if the specific state accessed is statically declared. Dependencies that are pure (no state calling allowed) can be processed once at the mempool layer and never need to be processed again - and potentially even replaced with a STARK verifying them, allowing not just execution but also data to be elided.
In principle, dependencies and actions can all be expressed as calls (if needed, calls to precompiles). This would make the transaction format itself very bare-bones and minimalist (a list of calls, flags for the type of each call eg. dependencies would be static or pure calls, and origin, nonce, etc) and allows maximum cross-compatibility even if different EVM chains have different features.
In 2015-era Ethereum, thinking explicitly about these differences was not very important: execution was execution, there were few enough transactions that we could process them all serially, and single-key ECDSA accounts were good enough for everyone.
Ethereum's current scaling strategy, however, requires moving beyond that paradigm. Ethereum is beloved by many developers because the execution and state model is so dynamic and flexible. But dynamic and flexible is not friendly to scaling. Fortunately, >90% of Ethereum's activity by volume does not require anything dynamic and flexible. So, we require contracts, accounts and transactions to more explicitly specify what is dynamic and flexible and what is more statically-analyzable but more restrictive, and more statically-analyzable things get the lowest gas cost and thus scale the most. Effectively, learning from the best of both the 2015-era Ethereum model and a more Bitcoin-like model (reminder: Bitcoin has had what I call account abstraction since the beginning), and making a mixture of both (really, the full spectrum between both) available, with gas costs appropriate for the level of scale involved.
New state types, the recursive STARK mempool, keyed nonces, etc all go in this direction.
This all relates to transaction types, because a general-purpose transaction type is a very natural interface layer on top of which all of this can be implemented, and the current thinking around the EIP-8141 transaction type is going in this exact direction that is friendly to these kinds of future generalizations.
So in that sense, 8141 done well is not just a culmination of 10 years of account abstraction work, it's also preparation for the next few years of responsible decentralization-friendly hyper-scaling.
Eugenio Reggianini retweeted
Frames are all you need.
lightclient.io/blog/frames-a…
Eugenio Reggianini retweeted
It's funny watching CT singing praises of L2s after years of bashing the rollup-centric roadmap, but to me the very framing of L2s being a result of the rollup-centric roadmap is misleading.
L2s exist not because of any top-down roadmap -- they emerged naturally due to a combination of 1) Ethereum's core technical properties, and 2) market demand. In other words, short of ceasing to be itself, Ethereum could not have stopped L2s from existing even if it wanted to. Credits must go to the EF for accelerating the success of rollups by pursuing the rollup-centric roadmap, but we must not get the cause and effect wrong -- the rollup-centric roadmap was a reaction to the emergence of rollups, not the cause of it.
(note that I will be using the terms "rollup" and "L2" interchangeably for readability, even though they are not technically the same thing)
At its core, a rollup is an off-chain program that posts its input data and commits its state to the L1, alongside a smart contract "verifier" that can verify the state transitions. If you examine this definition, you can derive the core technical properties that a L1 must have for L2s to exist:
- L1 must allow for posting data, so that input data and state commitments can be posted.
- L1 must support a general programming environment, so that verifiers can be implemented.
But most L1s, including alt L1s like Solana and Sui, have these technical properties, so it's worth asking why we don't see rollups flourishing in those ecosystems.
This is because Ethereum also has a set of other properties that no other L1s have:
- Ethereum is maximally decentralized, which makes its block space 1) credibly persistent (i.e. you can believe that Ethereum will last forever), and 2) widely accessible. This enables rollups built on Ethereum to inherit its persistence and accessibility, giving credence to the idea that rollup users can enjoy high-performance execution without giving up the benefits of decentralization.
- To achieve maximal decentralization, Ethereum runs a very large validator set, which makes Ethereum blocks expensive and slow to produce. The high gas price and latency of Ethereum blocks therefore lead to market demand for cheap and fast block space, a void that rollups are perfectly positioned to fill.
- As a direct result of the decentralization, Ethereum has become the best home for on-chain liquidity, simply because people want their liquidity to sit where it can 1) last forever, and 2) be maximally accessible. Therefore, L2s building on Ethereum do not have to bootstrap their liquidity from scratch, but rather can funnel Ethereum's liquidity into the rollup via trustless canonical bridges.
- As another consequence of decentralization, Ethereum is capture-and-censorship-resistant. But sometimes, capture and censorship are actually desired features, in which case they are known as regulation and compliance. So market also demands L2s because they can be regulated, since Ethereum itself cannot be.
In short, for as long as Ethereum keeps embracing decentralization, it will be the best home for L2s. As Ethereum builders, our job is to preserve and enforce Ethereum's core decentralization properties, while creating and improving technologies such as blobs and interop to facilitate the growth of highly scalable L2s.
Ethereum and L2s will help each other win. Let's build towards it.



























