
Took an afternoon poking at a major wallet to find a high-risk vulnerability. Follow for more tips to subsidize your mountain bike in web3

refining intelligence @veritylab

Took an afternoon poking at a major wallet to find a high-risk vulnerability. Follow for more tips to subsidize your mountain bike in web3

Thoughts on pqai, Hegota, and FOCIL tldr: Let’s accelerate pqai without rushing or stopping everything else. We can parallelise workstreams to keep shipping EIPs that are ready while the cryptography, designs, and specs for PQ are being worked on and finalised. We need to accelerate Ethereum’s transition to post-quantum, post-AI cryptography. Let’s take this as a given. There are two ways to think about what we need to do to enable this acceleration. 1) We deprioritise everything that is not pqai critical. That means all the features we were planning to ship have to wait until after we switch to hash-based cryptography across all layers of the protocol. To me, the downside of this approach is that we put all our eggs in one basket: if we end up taking 3 years to ship pqai, then Ethereum doesn’t move, at all, for 3 years. That’s “full sequential” mode, and it doesn’t account for important parameters, including how ready features are and what skillsets we have among researchers and client teams (e.g., not everyone is a PQ expert). The only case in which this is inevitable is if we find out that there is an actual break in our cryptography. In that case, I would argue we should be ready to make choices that go far beyond pq2027 ones, and have a concrete plan for what we need to do if we have to ship a minimal, ugly, emergency fork in a couple of weeks. 2) We parallelise. We keep working on the core, minimal features that were already SFI’d by core devs and the community, while accelerating our transition to pqai. To me, this second approach makes sense when you look at where the forks are: - Glamsterdam is delayed: most of the work is reaching out and making sure smart contracts don’t break because of repricing EIPs. - Hegota is in its devnet phase and can keep progressing with FOCIL and Frames in the meantime. Some core devs in all client teams have already worked on these features, they are specced, and now it comes down to “making it work” on the implementation side. - Importantly, the major PQ/AI upgrades are not yet ready: the specs and the cryptography are not frozen (x.com/soispoke/status/212091…). On the CL side, we don’t even know exactly what we mean by “PQ consensus” yet. Is it PQ Gasper? PQ Decoupled Consensus? With or without aggregation (and leanVM)? We need a lot more eyes on it, but it’s not realistic to think that all core devs across all teams would be able to chime in and accelerate progress there. Process-wise, I think it’s also important not to DFI features before we even know what we are going for. For example, we will realistically need more time to ship PQ DC than PQ Gasper, and we should ideally settle on which option to go for before making decisions about Hegota. In other words, the scenario I want to avoid is people DFI’ing features like FOCIL (and others) to get a false sense of security (“we deleted features, so surely we can go faster”), when the reality is more complex and nuanced. I also think these decisions hurt ACD’s credibility, and that we need a strong ACD the ecosystem can rely on, especially during times of uncertainty. Zooming in - On the EL, my opinion is that we need Frames for PQ (the only nuances are about how “light” Frames should be). In practice, we could also take the ugly/sequential approach there and ship another transaction type. But given the readiness of Frames, what they would unlock in Hegota and in the future (plus the fact that they’re already SFI’d, of course), there is no reason to settle for a hacky alternative. - On the CL, we can apply the same type of thinking. For FOCIL, I think the most reasonable path is to derisk it as much as possible so we ensure it is (1) forward compatible with PQ, and (2) minimal enough that it doesn’t delay Hegota and/or take up too many resources from nodes (bandwidth/compute) at a time when we need those for PQ. FOCIL in Hegota The good news is that FOCIL is well suited for this, because of two core properties: - Extensibility: We can fine-tune FOCIL to determine its transaction coverage. I think of it in terms of tiers: if we just want to cover regular/legacy transactions, we get FOCIL in its minimal form (lowest complexity, lowest node resource consumption). On the other hand, if we want FOCIL to cover all types of Frame transactions now and in the future, FOCIL becomes more complex and consumes more resources. In between, FOCIL can cover a limited set of Frame transactions. - Boundedness: Inclusion lists are amongst the easiest objects to deal with in the protocol. They’re bounded in terms of both size (8 kB) and gas limit (MAX_VERIFY_GAS_PER_IL). We can also cap the gas and size per IL transaction. Inclusion lists are also ephemeral and only useful for the duration of 1 slot, after which they can be forgotten about. And they never go onchain, so they don’t grow Ethereum’s state, which is one of our scarcest resources. For Hegota, I think FOCIL should sit in between and support a limited set of Frames with clear bounds on inclusion lists. A good approach for shipping FOCIL and Frames in general on devnets is to start with minimal FOCIL, make sure it’s ready, and then extend its transaction coverage gradually. This is a good way to guarantee we can ship FOCIL and Frames as soon as Frames are ready to go. PQ FOCIL “PQ FOCIL” can mean two different things, and we should differentiate them. The first is inclusion lists being able to cover PQ transactions. Here, the simple answer is that FOCIL, without any changes, would be able to include PQ transactions using leanSPHINCS signatures. But it would be able to include a lot fewer: a leanSPHINCS signature is around 5-7 kB and an IL is capped at 8 kB, so probably just 1 PQ transaction per IL, which means up to 16 PQ txns per block (because there are 16 includers, each of them building 1 IL per block). I think that’s fine and good enough for Hegota. Later, we will probably want FOCIL to cover PQ proofs as well, and for that we will need changes to FOCIL so each IL can include an 8288 proof (around 300 kB). The good news is that by then, we will need the machinery to handle these big recursive proofs being propagated on the network anyway. These are I*/J* considerations, but we should plan ahead and make sure the CL has the capacity to handle bigger ILs down the road. The second is inclusion lists being PQ/AI resistant. This one is easy: just replace IL BLS signatures with leanXMSS signatures, which would increase their size by 2.4 kB (each IL becoming 10.4 kB instead of 8 kB). But it also raises an interesting question: how important is it for ILs to be signed with PQ sigs? What is the worst attack that could happen if an adversary forged an IL signature? The worst an adversary can do with forged IL signatures is make every includer look like an equivocator. Nodes ignore ILs from an includer who signed two different lists, so forging a second IL for each of the 16 includers switches FOCIL off for that slot. So the worst thing that can happen is that FOCIL gets neutralised, which is of course far from ideal but a lot less concerning than consensus breaking or funds being stolen. Keep in mind that the adversary would also have to spend significant resources to break the keys of all 16 includers, who are only known a few minutes in advance. An adversary could also publish ILs on behalf of offline includers, but an IL can only force in transactions that are valid and fit in the block, which is what any includer can already do. And the extra load is bounded, because nodes forward at most two ILs per includer. So even though I think we should generally switch to PQ sigs across all layers of the protocol, this one is definitely not the most urgent or worrying. ILs could potentially keep BLS signatures in Hegota and move to PQ signatures with the rest of the CL. Closing thoughts I agree we should accelerate pqai, and prioritise every upgrade that is ready (PQ registration, leanSPHINCS). But DFI’ing everything else won’t make the parts that aren’t ready arrive any sooner. It only guarantees that Ethereum ships no user-facing features while we wait. PS: I want to be clear that I’m incredibly excited about the future of Ethereum. Thinking about PQ and ZK made me realise that we could completely rethink Ethereum as a cryptographic world computer, and accelerating towards this vision is very bullish. We just need to be careful not to sacrifice its other properties along the way (e.g., credible neutrality, privacy), and we have a very bright future ahead of us.
I agree there are some nuances but I still think the pqai2027 timeline doesn't make a lot of sense for points that could be more grounded, we need to think about: - what to settle on from the cryptography side (specific signature schemes for leanSPHINCS and XMSS on the EL and the CL, leanVM specifics and what it means to FV a project of that size and complexity, choosing the hash function) - how easy we want to be able to switch to something else in case the hash we chose ends up breaking as well - we also need to differentiate PQ Casper and DC versions with or without aggregation because these involved widely different tradeoffs - 8288 is not just signature aggregation, it also currently includes leanSPHINCS and leanSTARK (now leaning towards leanPCS, which gives users the possibility to prove any statement and thus the flexibility to chose any signature scheme they like)

guess not anymore, I have formally proved that a validator will take at most 604497386198401696480443941423039233672056843956262611240144118453974882764353409596694785910843529629961798654508 or roughly 6 × 10^113 RISC-V steps to verify any Ethereum block. this is an extremely conservative bound, more steps than there are atoms in the observable universe (~10^80). but ... it's finite, and it holds for every block with a gas limit up to 200M, no matter what's in it. until now the only answer we had was ∞. the proof covers the whole stateless validator: - input decoding - every possible transaction - every EVM call frame - every precompile - computing the state root the bound is carried from the source program through every compiler pass down to RISC-V steps. it took ~423k lines of Lean, written by a swarm of @claudeai agents: Opus 5.5 orchestrating, Sonnet 5.5 agents building proof packages in parallel. every step is checked by Lean's kernel, and the official evm.fast verifier Built on @yukonresearch in collaboration with @zksecurityXYZ, @Veritylab, @ethereumfndn which then rebuilt and re-checked all of it with an independent kernel replay taking 13 hours of verification. now the fun part, making the number smaller ... full submission: github.com/Layr-Labs/evm.fas…
What's the most work that could possibly be required to verify an Ethereum block? Today, we can't prove an answer. All we know is the validator always finishes. evm.fast is an open challenge to change that: contributors compete on a leaderboard to find mathematically guaranteed bounds for verifying Ethereum, no matter what's in a block. Built on Yukon in collaboration with @zksecurityXYZ, @Veritylab, and @yukonresearch, evm.fast seeks provable limits that keep verification cheap, predictable, and possible on modest hardware. Try it yourself: evm.fast

AI keeps beating me, yet I've never been more excited to work. I think @martinmonperrus nailed the explanation: as the tasks where humans outperform AI become rarer, their value increases because they can leverage everything else. We may be losing relevance in most tasks, but we've never been more valuable at the frontier. Interestingly this could last for a while, even if AI outperforms us on everything we are doing today within a few months!

Bring your ideas to life with Zeus, a new type of GPU: - Expandable memory: 32/64/128 GB soldered + 2x/4x SO-DIMM slots for up to 384 GB memory! - Massive improvements to path tracing performance! - 400 GbE QSFP-DD port! - Built-in high-performance RISC-V CPU cores capable of running Linux! - DevKits 2026, Mass Production 2027 And we used the good old 8-pin PCIe power connector that is known to not melt!

Sharing here my pet project: Proving the pet rock chain with Stwo, in Zig With a single ZK proof, you can verify that the Bitcoin chain is valid at a certain height. That includes almost all consensus rules, as well as the full UTXO set Potential applications:

I have a major result to share. I’ve found conclusive forensic evidence that the top 4 Chinese AI labs—DeepSeek, Moonshot, MiniMax and Ant Group—have built their newest models on NVIDIA’s most advanced Blackwell chips, which are barred from export to China. This sounds insane, but I discovered that almost every AI model carries a hidden signature of the GPU that trained it. When a model is first set up, the starting values of its weights are laid out in a pattern that depends on the exact GPU. Each combination of GPU and seed number produces a unique pattern—a sort of fingerprint of the hardware used to create the model. Traces of that pattern survive training into the published model. Again, this evidence isn’t based on any insider information or leaking. It’s based on a forensic analysis of the model weights released by the companies themselves. I searched more than six trillion combinations of chip layout and seed number and matched them to open-weights models. In doing so, I found conclusive evidence that six Chinese AI models—including DeepSeek-V4-Pro, Kimi K3, and MiniMax-M3—were initialized on NVIDIA Blackwell systems. Four of the models match Grace Blackwell, the GB200 and GB300 parts in NVIDIA’s flagship liquid-cooled rack-scale systems. I then verified these results on real hardware. Running unmodified PyTorch with the seeds I’d recovered, a Blackwell B300 reproduced DeepSeek-V4-Flash’s untouched starting weights bit for bit, and a rented GB200 reproduced Kimi K3’s to a correlation of 0.999995. A Hopper H100 reproduced none of DeepSeek-V4-Flash’s, and changing the seed by one broke the match. (DeepSeek’s seed is 953049583 by the way.) The method also was verified to match 24 known open-weights models to the hardware that developers said they used. It is exceedingly unlikely that these results are a coincidence. Across six trillion combinations, the best accidental match should reach only about 8 sigma (i.e., eight standard deviations above what random chance would produce). The real matches range from 49 to 1,385 sigma, and even the weakest single test hits 20. These were data-center-scale training runs. With some analysis of release schedules and model details, I estimate that the largest, Kimi K3 and DeepSeek-V4-Pro, used 2,000 to 3,000 Blackwell GPUs each. Clusters of this size cost on the order of $150 to $200 million each to buy, and across these labs alone would add up to more than half a billion dollars of export-controlled GPUs, not counting experimental compute or otherwise. It’s quite likely that we see multi-billion dollar expenditure on export-controlled GPUs. I am highly confident in this result, and it has been independently verified by senior researchers at OpenAI and Anthropic. You can read the full report at unemploymentlabs.com/checkpo…. There is much more I’ve identified about these models through other forms of checkpoint forensics like this, and will have more to share soon.



EthLib has evolved incredibly fast over the past few weeks, with formally verified components spanning execution, consensus, networking and cryptography! Lots of open issues to help complete the stack. Contributions are very welcome! github.com/ethereum/EthLib


I think the promise of nix a few years ago is that it would be harder to do something once, but you would never do it twice. Turns out there is nothing hard anymore but it's easier to get stuck in fixing the same thing over and over. NixOS has never been so valuable
NixOS has actually been my best Linux experience to date. I'm not sure if it's just because LLMs have made Linux super easy to customise.

We've come a long way in a short time for formal verification—one of our strongest tools for putting the S in CROPS—to become a new normal. Here, verity formally verified EIP-8282 and in doing so found real discrepancies for researchers to address. Thanks for the work @Veritylab
We formally verified EIP-8282 for the @ethereumfndn. Proved directly on the bytecode, checked by Lean. veritylabs.dev/our-work/eip-…

Announcing a major milestone achieved by my team @GoogleDeepMind: we have proven key security properties of the machine code underlying the Signal messaging protocol. This is the first time the actual production code of a widely deployed protocol has been formally verified – by any method, with or without AI – and at this depth. More than a research breakthrough, it’s a prime example of how frontier AI can be a force multiplier to counter the speed and scale of modern cyber threats. Formal verification offers a higher standard of security; however, it’s extremely complex and time consuming, which is why in many cases it’s considered to be impractical. Similar efforts could take teams decades of combined effort. We did it in a month’s time. Using AlphaProof Code, Google DeepMind's new agentic framework for formal verification that runs on LLMs including Gemini Carbon, we verified the Signal protocol down to the actual code running on devices. This milestone lays the groundwork for a future in which vital systems, from medical device firmware to power grid software, ship with mathematical proof that their protections work. Reaching that future will take continued research from our community. In that spirit, we're open-sourcing our formal specifications and verification artifacts so others can build on this work. On a personal note, this moment is of deep significance to me. I started my own research journey more than two decades ago as an intern working on checking the consistency of complex software systems. Seeing this grand challenge made practical with modern AI is extraordinary. I'm extremely proud of my team members: Swarat Chaudhuri, Andrew Ferraiuolo, Anton Kovsharov, Tej Chajed, Sam Schlesinger, Karn Seth, Jonathan Katz, and Charles Sutton for taking on this grand challenge and delivering, and grateful to the Signal team for their partnership. deepmind.google/blog/formal-…

We formally verified EIP-8282 for the @ethereumfndn. Proved directly on the bytecode, checked by Lean. veritylabs.dev/our-work/eip-…
