arguably my favorite panel lineup of all time @VitalikButerin @omw_to_the_moon @DistributedMarz

We are massively hiring to support our growth across several roles. If you are interested in joining the team, check out our open positions and apply directly via our careers page. 🔗 jobs.ashbyhq.com/consensys

Glamsterdam is a pretty big upgrade for Ethereum. It improves how blocks are built and processed, giving Ethereum more room to scale L1 without giving up decentralization. For users that should mean more capacity, less fee pressure and a smoother experience as activity grows. For builders it means more efficient block validation and a better base for higher gas limits and more complex apps. Scheduled for Q4 2026

It's an increasingly common take that AI hacking means cybersecurity is doomed. I disagree. I think cybersecurity is naturally defense-favoring once people get their shit together. And anyone who continues to hold cryptocurrency (including me, ~90% of my net worth) is implicitly making that bet. Here's why I am making that bet. First, the oversimplified punchy one-line statement: If AI can prove Navier-Stokes and FLT, then AI can prove the statement "this program is secure" as a mathematical theorem. Even if the program is very complicated. Now, the nuance: (See also: vitalik.eth.limo/general/202… ) The word "secure" is hiding all kinds of skeletons in the closet in terms of what it actually means. What does it mean for Signal (the encrypted messenger) to be "secure"? The most basic definition you might think of is: no one who doesn't hold the recipient's secret key can read the contents of the message. But: * Did you remember to include _other_ critical forms of security? Can the adversary forge messages? Can the attacker prevent messages from reaching the recipient? Can they cause your client to crash by sending malformed messages? * Have you made sure that your model of the adversary includes attackers that interfere with the protocol actively and not just passively? And attackers that interfere by replaying messages to you or the recipient that either of you sent over the wire at any point earlier? * What if the adversary hacked (or _is_) the Signal server? * How did you learn which public key belongs to the recipient in the first place? What if that process was tampered with? * What if your device gets hacked at some point in the past or future - is your message still safe then? * What if your key leaks because of a bug in your operating system? Or because you got a bugged version of the Signal client? Or what if the database is corrupted? * Or the libraries, interpreter or compiler of the programming language you wrote it in? * What if your key leaks because tiny perturbations in perceptible signals generated by the hardware leak mathematical relationships that can extract the key a few hundredths of a bit at a time? * Are you hiding the *size* of the payload? Does that matter? * You're definitely not hiding the identity of the sender and the recipient, and the exact time each message was sent (think: not just time-of-day, but also time deltas between one message and the next). Is that not enough to deduce a lot of important facts about what relationships you have, and what *kinds* of conversations you are having? So ... even definitions can be over a thousand lines of code, and need deep careful thought to figure them out. Working on making definitions more human-readable is of extreme importance - it's perhaps the only "high-level language" that matters right now. But even still, even despite all of the above, for security-critical components, the definition is a much smaller attack surface than the implementation. Verifying that the definition is adequate is a much more tractable task than scanning over the code directly - and can become even more tractable with better tooling. Definitions are also _additive_: if two groups have two different definitions A and B, then, well, you can just prove that the program satisfies both A and B. Code is not additive in this way: if a program is A + B, a bug in A _or_ B can sink the whole thing. Definitions are additive. And if you can't satisfy A and B at the same time, you've isolated the most important philosophical issue for your project to spend its next few weeks grappling with. Sometimes, definitions are not much smaller than the implementation - UI components might be one example. But for many of the most critical components - message-passing protocols, sandboxes, cryptography like SNARKs and FHE - the asymmetry is real. Historically, a large class of failures with this approach have come from people only verifying a small portion of their code, that they self-declared to be the security-critical portion, and ignoring the rest - and it turns out that something in the rest of the code is security-critical too. This was reasonable back when verification was difficult and scarce. The solution today: sorry, you have to verify over literally your entire program, including database, networking, any caching layers, everything. Modern AI can do it. So it's not about "the good guys find all the vulnerabilities before the bad guys do" - that could maybe work too, after all a finite program only has a finite number of vulns, but it's riskier - it's specifically an asymmetric strategy of making code that is much more resilient in the first place. This is the kind of direction that Ethereum is going in for the next few years. There is no future for blockchains - especially blockchains with scalability and privacy - without doing this. We need to make software actually secure. And we have already made a lot of progress.

Solidity compilation just got up to 5× faster! Today we’re releasing hardhat-slang-solx, a Hardhat plugin powered by Nomic Foundation’s new LLVM-based compiler backend: slang-solx. - 1.7× faster than solc in legacy mode - 5× faster than solc --via-ir 🧵

Meet Crumbs, built on Robinhood Chain. Shop at Costco, get $COST. Buy from Apple, get $AAPL. Turn eligible receipts into stock-token rewards from the companies you already shop with. Join us before launch: crumbs.family

Here's a guide @austingriffith wrote on how to do this, and links to the implementation from August 2018 medium.com/@austin_48503/eth…

Apparently us Londoners have strong opinions about London transport 🚇 So I vibe-coded a tier-list app to let everyone settle the debate. Or make it worse. Rank the lines here 👇 tube-tiers.vercel.app Elizabeth line, I'm rooting for you!

Precompiles continue to be a pain point for zkVMs: each one is a special case that needs its own hand-built proving logic, and they're among the slowest and most expensive parts of a block to prove. EIP-8200 aims at replacing precompiles with ordinary EVM bytecode. Same behavior, but a zkVM can prove it like any other contract. Plus it simplifies the protocol by removing a set of special cases every EL client has to implement and maintain separately. Precompiles today run natively inside EL clients as fast compiled code ('cheap gas'), while their replacements would run as interpreted EVM bytecode (slower, using more gas). Closing that gap is akin to gas-golfing: squeeze the bytecode until it's as cheap as possible. precompile.fast turns this into an open, verified challenge. Anyone with good prompts and sufficient token budget can compete —> AI accelerating L1 R&D (make sure to check out the other autoresearch challenges as well) EIP-8200 is PFI'd for Hegota and facilitates EIP-8025 (execution proofs on L1). This is the L1-zkEVM route to scaling; when validators verify proofs instead of re-executing every TX, so the gas limit can grow significantly: —> More premium blockspace, more onchain activity, more economic bandwidth on L1 itself

tl;dr - bridge quick; cex deposit quick; from ~15mins down to 12-25 seconds

Unified proposal en route!

Can a sufficiently powerful quantum computer forge the signatures used to authorize Bitcoin and Ethereum transactions? What would it take to upgrade both networks before that happens? In this new lecture, Stanford cryptographer @danboneh explores why blockchains may turn to signatures built from hash functions. He also presents new research on threshold signing. The talk ends with the questions Bitcoin still has to answer, including whether post-quantum signatures will require larger blocks, what happens to abandoned coins, and how someone such as Satoshi could prove ownership after Bitcoin’s current signatures have been retired. 00:00 Why blockchains need to prepare for quantum computers 03:05 Why Bitcoin may bet on hash-based signatures 06:25 The “big footgun” in stateful signatures 08:58 A quantum-safe signature that takes one billion hashes 14:13 Inside SLH-DSA’s virtual tree 20:30 How Bitcoin and Ethereum could make the switch 23:48 What happens when a wallet loses its state? 32:47 Can threshold signing survive the quantum transition? 36:39 How to hide lattice cryptography from the blockchain 38:49 Why threshold one-time signatures seem impossible 45:36 How context prevents forged signatures 49:37 The forgotten idea behind Winternitz signatures 54:50 Turning one-time signatures into threshold signatures 1:04:27 Will quantum-safe signatures require bigger Bitcoin blocks? 1:06:26 Abandoned bitcoin and Satoshi’s recovery problem

this wild defcon talk is finally out researchers created a fake defi startup, hired lazarus it workers, put them into a sandbox and recorded their tooling, workflows, and faces from inside the operation starts at 5:46:09 piped.video/live/_uYQr8hfpbI…