Glad to see core devs and researchers take any time that's needed to get glamsterdam ready. The next few years are going to be incredible for ethereum. We'll go postquantum, add native privacy for ETH, and massively increase L1 TPS and the blob target. All while L1+L2 hypergrow.
Ryan Berckmans ⟠ 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.
It's a renaissance of proactive public communication from core devs & researchers in Ethereum. Something special is happening
There's too much happening to list it all, but here are some highlights of the ongoing formal verification work, with special thanks to the people carrying it forward and getting Ethereum ready for the post-quantum and post-AI era.
@drakefjustin and the Ethereum Foundation @ethereumfndn had the foresight to make two big bets long before AI made them table stakes: formal verification and post-quantum security. @alexanderlhicks pioneered Verified zkEVM, bringing the EF's formal verification and cryptography teams and dozens of grantees together to verify the full zkEVM stack, while the EF cryptography team, the @leanEthereum effort and a dedicated PQ team have been laying the ground for a PQ Ethereum.
Now we reap the benefits, as AI makes security needs more urgent but also multiplies this strong foundation and accumulated expertise, propagating formal verification across the Ethereum stack and accelerating the PQ timelines.
The core Ethereum specs are already transforming, incorporating Lean for some of their critical components: the cryptography specs bring BLS and KZG into Lean, with proofs by Benedikt Wagner and @asanso, @tcoratger wrote the new SSZ specs, and @jtraglia integrated both into the consensus specs.
Meanwhile, the amount of forward-looking work is impossible to keep up with: @tcoratger added the post-quantum XMSS signature scheme to the cryptography specs; Benedikt proved the security of the proposed post-quantum data availability sampling scheme (code); and @asn_d6, Benedikt and @Khovr are proving that the pieces of a recursive zkVM proof fit together securely.
Industry teams are all in too: @JulekSU and the @Nethermind FV team formalized FRI in ArkLib, are now on STIR and WHIR, and built a Lean model of the EVM and Yul covering Cancun, while @rv_inc is connecting Rust cryptographic code to Lean proofs.
Another incredible trend at the intersection of AI and formal verification is autoresearch challenges, where agents compete in the open to improve a verifiable metric: better.codes (EF formal verification team, @yukonresearch, @zksecurityXYZ) on the coding theory behind SNARK security, sig.golf (@yukonresearch, @ethereumfndn) on smaller post-quantum signatures, zk.golf (@zksecurityXYZ) on cheaper ZK circuits, and snark.fast (@SuccinctLabs, @EspressoSys) on a faster post-quantum prover.
As for the FCR work, check it out here:
Lean formalization [github.com/fradamt/verified-…]
Gloas fix [github.com/ethereum/consensu…]
Lots of the threads that the R&D ecosystem has been working on for years are coming together, and Ethereum could hardly be better prepared for as transformative a moment as this one.
Ryan Berckmans ⟠ retweeted
I'm a Ethereum maxi, not a decentralization maxi. I believe the world needs only one fully decentralized / permissionless / trustless blockchain, and that is Ethereum. Every other chain -- whether they are stage 0/1/2, trusted, trustless, centralized, semi-centralized, etc. -- can and should be built on Ethereum.
In fact, the beauty of Ethereum is precisely that because it's itself maximally decentralized, other systems of various degrees of centralization can be built on top, and that they can interop with each other through Ethereum. As long as these systems provide real value to real people, they will strengthen the network effects of Ethereum and bring in more users and liquidity into the overall Ethereum ecosystem, which ultimately leads to a stronger L1 and stronger ETH.
Ethereum is the only credibly neutral, global settlement layer of the world. We are the hub. Let's celebrate the nodes that connect to us.
Ryan Berckmans ⟠ retweeted
I don't recommend anyone scramble to move their funds to new wallets today. But we should take the risks to cryptography from AI-accelerated math seriously, and minimize our exposure to not just quantum-vulnerable cryptography, but also potentially AI-vulnerable cryptography.
The core new area of risk from this viewpoint is, unfortunately, ML-DSA / FHE / lattices.
(and it's also another reason, along with quantum, why ECDSA might fall even faster than expected, hence the "fresh address" recommendation)
So far most people have been in the mode of thinking "elliptic curves broken, hashes safe, lattices safe". But there is a good chance that the concrete security of lattices will take serious hits from the next two years of AI math.
The basic threat model is: factoring is something that naively takes 2^(n/2) time, but over decades smart people have found and optimized number field sieves, and degraded that to 2^O(n^(1/3)), which is why RSA keys and signatures need to be ~400 bytes (and not 64 bytes). What if there are skeletons in the closet like that, both for elliptic curves and lattices, that we are simply not smart enough to discover - but bots soon will be?
This is a major part of the reason why for the past year ethereum's lean roadmap has been going in the "hash-only" direction: no lattices, no ML-DSA, no Falcon, no lattice-based commitments inside ZK proofs, etc. Signatures in lean ethereum are all hash-based, either WOTS or SPHINCS-.
For signatures and proofs, we already know how to go hash-only. The bigger challenge is for *public-key encryption* - and this goes far beyond blockchains. Secure communication, anonymizing protocols, lots of things need public-key encryption.
And unfortunately there are long-standing mathematical theorems showing why public-key encryption cannot be done with hashes alone. You have to have some kind of trapdoor object that has at least one form of usable "structure" - either group theory (incl. isogenies) or lattices or code-based or potentially in the future even more newfangled and spooky things (local mixing?). But for anything that has structure, you should assume that AI will make at least some progress in breaking that structure. Here, one reasonable inference is that if you want to make something plausibly long-term secure, multiply the key sizes by 10.
To me that's a very plausible world and something not at all extreme to predict. If AI will bring us 50 years of math in 2 years, then that 50 years of math may very plausibly include a "naive factoring -> GNFS" level of improvement to our ability to break lattices. In that world, lattices will still exist, but they will have to be significantly bigger to guarantee the same level of safety.
And at those new larger sizes, hash-based constructions will beat lattice-based constructions on concrete efficiency in every use case where hash-based constructions are possible at all.
Theoretically, of course it's possible that hashes are broken too (eg. P = NP would imply that). But I think P = NP is very unlikely. And intuitively, it's much more likely that a mathematical object has exactly no exploitable structure (like hashes are intended to), than that a mathematical object has exactly ~3 forms of exploitable structure (for elliptic curves: associativity, Schoof, pairings) and not some secret fourth form of structure we have not yet discovered that greatly degrades its security (for elliptic curves, ECDLP and pairing security). Similar for LWE, SVP, RLWE and the zoo of lattice problems.
For this reason, we do not yet see any reason to worry and start padding the byte size of hashes (if we start to worry more, we would pad the round count first before doing anything to the byte size).
Concrete TLDR, my own personal views:
* Hash-based > lattice-based, in those situations where hash-based is possible at all
* For anything lattice-based, be much more paranoid on param sizes. Remember that blockchains are only a small portion of the cryptography story; this point goes far beyond blockchains and applies to eg. access to websites, secure messaging, Tor / VPNs ...
* For privacy protocols, strongly favor NOT putting encrypted notes onchain. Instead, send them offchain through some third-party mechanism.
* If it's not difficult for you, keeping your funds in addresses which have not yet been used to make a transaction is a good idea. If it's easy for you, do it. **But be careful about migrations; I personally have lost more money in botched migrations than I have lost in all hacks combined**.
* For multisig wallets, doing confirmations offchain is better than onchain, because this way the signatures of signer wallets do not get exposed to the public, so if ECDSA falls to AI much faster than expected, at least the multisig "gracefully degrades" to a 1-of-1 where the 1 is whoever was gathering the signatures - a much better place to be than "anyone can take the money"
firefly.social/post/x/210783…
I'm publishing an idea that I think could help low/unskilled workers get better jobs (maybe much better & faster):
Idea: zeroshot job offers where agents conduct interviews and the candidate gets only firm offers to "start Monday". No interviews at all.
My prototype is called JobYes (jobyes.zqnm.chatgpt.site), you should copy it, I'm not pursuing this, it's a bad founder fit for me.
For a traditional job portal, such as Indeed, getting a job usually means the candidate doesn't really need to use the job portal anymore. It's largely not an ongoing service. It's sporadic & episodic when looking for work.
In contrast, JobYes is a permanent subscription/service for the candidate to get offered a stream of better and better jobs by having personal<>corp agents conduct automated interviews against the candidate's documented work history & preferences, and the employer's reputation/offer.
How it works:
- candidate makes a profile, including job prefs.
- candidate's agent and corp agent interview each other.
- when additional candidate info or work history/health evidence are needed (such a paystub from an existing employer's portal or a clear drug test) these requests are surfaced async to the candidate for them to provide the evidence, without showing (or bothering) the candidate with the specific employer or job req that triggered the request.
- for the candidate, each answered request builds their profile, making the platform increasingly valuable and automated to receive more & better job offers.
- after agent interviews, employers may extend a candidate an full offer to "start Monday", including the specific pay, benefits, costs, and any other terms, eg. free uniforms.
- the candidate that receive an offer can then ask questions of the employer's corp agents (or real HR staff, it's up to the corp)
- then candidate clicks "Accept Job", and then they show up on Monday. No interviews. No B.S.
- getting a job is not the end, it's the beginning: one-click upgrade your job: started last month for $12/hr at Burger King? No problem: you just received an offer to start a Chik-fil-A for $15/hr. The platform can even send a resignation letter to the current employer.
In short, agentic interviewing seems like a practical large scale opportunity to potentially dramatically improve quality of life and labor outcomes for unskilled and lowskilled workers-- the kinds of roles where agents really could fully conduct interviews backed by a portfolio of candidate evidence.
I hope to see quality founders pursue agentic laborforce improvements! It's a noble cause in any era, but especially in this era of inflation and automation.
Today we’re announcing Personal Agent Protocol — an open standard @Meta and @SierraPlatform are developing along with industry partners at @Genesys, @instinct, @RocketOTD, @Shopify, @stripe, and @Walmart. It will help define how personal agents interact with businesses and is open for anyone to implement. You can read more here - and if anyone is interested in joining let me know! sierra.ai/blog/introducing-p…
There's no need for any perceived/artificial hard fork deadlines, like shipping glam in 2026 or finalizing mainnet release cuts before devcon.
We're shipping a great fork on a reasonable timeline.
What's crucial is 100.0000% uptime forever. Respectfully, we must never forget it
Glamsterdam activates on Sepolia in 24hrs and only half the network is signaling ready 😆
enrscout.ethnodeops.xyz/fork…
New York Stock Exchange parent company-- the same one that invested huge in polymarket-- is working with SEC to launch tokenized stocks on an eth L2 run in partnership with OKX the major crypto exchange. Probably something
NYSE parent @ICE_Markets and @okx's 50/50 joint venture, OKXICE, has notified the SEC of plans to launch a tokenized securities venue under the agency's temporary Innovation Exemption.
The proposed venue would offer retail and institutional investors 24/7 secondary trading in tokenized US NMS stocks through @Uniswap v4 liquidity pools on @XLayerOfficial, an @ethereum L2.
Access is permissioned through KYC/KYB, sanctions screening, whitelisting and wallet-bound credentials, while the underlying chain remains public and permissionless.
The tokens are intended to represent one-for-one security entitlements to underlying shares held through a broker-dealer. The notice lists 64 proposed stocks, including NVIDIA, Tesla and Apple, paired with USDC, USDG or USDT.
Ethereum is the home of onchain finance.
Ryan Berckmans ⟠ retweeted
announcing nativerollups.fyi, a closed devnet based on frames-devnet-0 running a (half mocked) native rollup on top
a native rollup is an L2 that inherits L1's STF directly, greatly reducing complexity, governance and bug risks. here's how it works 🧵
Things to know about the new Ethereum Decentralization Index (EDI)
1. The D0 to D9 rating system was created entirely by a frontier model (Astra Max) studying 100s of live protocols, assets, and L2s. No human judgment but "start at D0 and work upward"
2. EDI launches this week
Eth L1 has 57% of all tokenized BTC and 95% of all tokenized gold. Imagine thinking this won't also reflect in stocks as the landscape matures
One of the reasons why I like to say "rollups are L1 apps"-- besides it being literally true-- is that there are major rollups where the ETH inside them is net more decentralized and lower risk than the ETH in certain L1 protocols. Launching an eth decentralization index soon
Ryan Berckmans ⟠ retweeted
Update: One step closer to a faster Ethereum L1.
Quick slots just moved to Considered for Inclusion (CFI) in today's All Core Devs call! This is a new milestone for our proposal to make Ethereum blocks faster 🎉
Btw.. Faster blocks =>
- Better UX
- Better markets
- Faster finality and fast confirmation rule
- And improved censorship-resistance too!
TLDR: More value for the network, its users, and ETH, without compromising on the core values and properties of Ethereum.
Hear this from 20 top Ethereum teams in our ecosystem survey: ethlabs.org/writings/quick-s…
---
Ok, what does CFI mean? This does not mean that the EIP is for sure included in Hegotá. This means that now it will be considered more seriously, including testing, towards inclusion in future devnets once headliners (FOCIL and frame transactions) are stable.
In particular, the call today revealed the appetite for a phased approach, installing the plumbing which allows us to reduce the slot time in Ethereum clients, and deciding to pull the trigger based on further testing.
Ultimately, this is how EIP-8198 is designed, so CFI'ing today allows us to move forward with more of the plumbing work, and start looking into testing towards an actual slot reduction from 12 to 10 seconds. This is a first reduction, as EIP-8198 opens the door for progressively lower slot times, as they get sufficiently safe to ship.
In parallel, as discussed on the call too, we are continuing our ecosystem survey and outreach of deployed smart contracts with a slot time dependency. We have reached out to more teams on this.
---
Faster slots are one important dimension of our Faster Ethereum body of work. A more responsive network helps cement its role as a liquidity hub and as the heartbeat of the network as a whole.
Along with our work on fast finality, fast confirmation rule and fast interop, it all combines for a seamless and secure flow of assets everywhere on the network.
Thank you to the many builders who are taking us there!
Rollups have been using ~5x to ~10x more ethereum L1 execution gas vs alt L1s. 16x vs nonrollup L2s
Rollups are L1 apps
























