←
Stephen Duan1,345 posts
Stephen Duan avatar

Stephen Duan

@sd_eigen

zkVM, Rollup, Post-Quantum Cryptography CTO @ProjectZKM / @GOATNetwork Creator @AppliedPQC

◷ Joined July 2016▧ 22 Photos and videos
Stephen Duan avatar
Stephen Duan@sd_eigen·Oct 6

Happy to share our latest work on Ziren @ProjectZKM @GOATNetwork. Feedback welcome! A summary: 1. A new proof system based on Jaggled reduction and WHIR(including recursion proof over binary field and Blake3). Acknowledgements to SP1 team and Plonky3 contributors. 2. 4x proving efficiency, 10x emulation efficiency improvement over previous v1.2. Speedup is happening every day with AI assistant. 3. >100-bit proven security 4. A fully Lean 4 assisted constraint determinism proof, covering 104 chips. 5. A complete end-to-end zkVM design reference.

[New] Ziren: Succinct Arguments for MIPS32 Execution (Stephen Duan) ia.cr/2026/2330

Stephen Duan avatar
Stephen Duan@sd_eigen·Nov 17

Excited to share our latest work for Bitcoin PQ Bridge protocol. The idea is very straightforward, in a classical BitVM protocol, we garble the STARK verifier into a Boolean circuit. The challenging is also very obvious, how to reduce the input labels' commitment on Bitcoin? it is over a thousand times BitVM3's Assert of about 2.4 kvB. In our work, for an Ethereum block proved (actually for any programs) through four recursion levels, the final recursive WHIR-proof verifier has 175.4M non-free gates and 520,832 input bits, corresponding to 2.81 GB of garbled tables, and publishing that input with translated Winternitz keys takes 3.93 million virtual bytes (MvB), in 41 standard transactions. This is the SOTA afaik. Welcome to discussion: > Discussion: delvingbitcoin.org/t/toward-… > Code: github.com/GOATNetwork/bitco…

The GOAT BitVM3 bridge is what will let activity on GOAT Network settle on Bitcoin, so it has to stay secure for as long as Bitcoin does. In bridge designs today, a disputed withdrawal is settled by a proof that is first compressed with elliptic curves, and that step is the one a quantum computer would break. This paper removes the step: the full hash-based proof from Ziren, the prover behind the bridge, is checked instead. A withdrawal nobody disputes publishes none of the extra data. A disputed one would put about four Bitcoin blocks of it onchain. A bridge is only post-quantum once the signatures that authorize its Bitcoin transactions are replaced too, and that work sits outside this paper. → eprint.iacr.org/2026/2877

Stephen Duan avatar
Stephen Duan@sd_eigen·Nov 11

Go Metis! By utilizing Ziren as its proving infrastructure and integrating post-quantum security, Metis has made substantial progress.

The Metis Hybrid Rollup is live on Devnet. ZK validity proofs verify execution on-chain, aiming to cut withdrawal delays. Faster settlement is only part of it. The work also builds a post-quantum path for scaling Ethereum.

Stephen Duan avatar
Stephen Duan@sd_eigen·Nov 9

Never forget why we started. 不忘初心.

ZKM @ProjectZKM Nov 9 Article Completing the Hybrid Rollup for post-quantum security Most activity on Ethereum happens on rollups: networks that run transactions on their own chain and post the results back to Ethereum. The largest of them are optimistic - the posted results are

Kevin.GOAT🌿 avatar
⟳ Stephen Duan retweeted
Kevin.GOAT🌿@kevinliu·Nov 4

Our team has taken the hard path on every decision for many years. Build a zkVM from scratch on MIPS. A working decentralized sequencer set. A truly trust-minimized Bitcoin bridge. Post-quantum security in progress across the stack. And now real-time proving on Ethereum. Ziren is already the heart of GOAT Network, and work is now underway to bring it to Metis.

ZKM @ProjectZKM Nov 3 Article Ziren 2.0 Ziren 2.0 is here, replacing the proving core of our zkVM with a new proof system, jagged-over-WHIR, rebuilt across 1,690 commits and documented in the design paper on the IACR Cryptology ePrint

Stephen Duan avatar
Stephen Duan@sd_eigen·Nov 3

Excited to release Ziren v2.0! Main updates: 1. Proof system upgraded to WHIR, > 100-bit proven security, compressed proof < 300KiB, and >4x speedup over Ziren v1.x 2. Chip constraint determinism formally verified by Lean 4 3. On @eth_proofs, RTP on Reth is launched, Geth keeper proving is ready to go 4. More use cases delivered internally!

ZKM @ProjectZKM Nov 3 Article Ziren 2.0 Ziren 2.0 is here, replacing the proving core of our zkVM with a new proof system, jagged-over-WHIR, rebuilt across 1,690 commits and documented in the design paper on the IACR Cryptology ePrint

Stephen Duan avatar
Stephen Duan@sd_eigen·Nov 3

FlashProve proves inference for a 400B model on a single H100, reaching up to 110 tokens/s. But the MOST interesting part to me is its DAG Fiat–Shamir construction. It uses round-by-round soundness and a ROM security reduction to handle adaptive branch scheduling and shared challenges, with formal verification in Lean. The real innovation may be in the soundness composition, not just the proving performance.

Post attachment

anthropic’s flashprove uses zkSNARKs, the proofs that scale Starknet, to prove a 400B-parameter model wrote a response without revealing its weights ~110 tokens/sec on one H100, 19 MB proofs that check in seconds on a cpu verifiable AI is closer than we think.

Post attachmentPost attachment
Stephen Duan avatar
Stephen Duan@sd_eigen·Oct 31

This is an inspiring work. We have been auditing Ziren Linux ABI by Lean4 for a while, the basic syscall has been done, but not covering all.

V12@v12secOct 30

x86 formal verification is coming! The (first?) published machine-checked proof of a security property for the end-to-end execution of a Linux process running an x86 binary statically linked against glibc. And we believe it scales! A joint research project with @zellic_io 🧵👇

Post attachment
Eli Ben-Sasson | Starknet.io avatar
⟳ Stephen Duan retweeted
Eli Ben-Sasson | Starknet.io@EliBenSasson·Oct 26

This is a spectacular result, saying the NP complete problem over n variables can be solved in much less than 2^n time. I love it, always thought that SAT shouldn’t be as hard as 2^n. It doesn’t mean P=NP, though.

Here's a direct link to OpenAI's PDF claiming a refutation of ETH. In particular, it's claimed that 3SAT on n variables is in about exp(n/(log n)^{1/2+o(1)}) time github.com/openai/math/blob/…

Stephen Duan avatar
Stephen Duan@sd_eigen·Oct 22

Make zkVM and Bitcoin Rollup technology for daily life!

When an AI agent spends money for someone, everything rests on what the system’s guarantees are built on. We build on Bitcoin because nothing else is as neutral or as proven. A KOSDAQ-listed company exploring consumer payments on this foundation is the thesis in practice.

Stephen Duan avatar
Stephen Duan@sd_eigen·Oct 21

Good thread. One data point on depth, from our Ziren paper (eprint.iacr.org/2026/2330): Our recursion is not open-ended (unlimited depth). A block proof is one leaf per shard, a compose tree of arity ≤ 3, and a single root: depth 2 + ⌈log₃ N⌉, about 7 levels for our largest test block. The recursion keys are not inputs either. Every leaf and compose key must sit in a fixed allowlist committed under one root, and the verifier fixes the schedule rather than reading it from the proof. That's a bounded, closed set of verifier circuits, a different risk profile from unlimited-depth recursion with the aggregated vk passed in as input. We also state the recursion assumption as an open hypothesis rather than a belief. Our composition theorem works in the ROM, where Fiat–Shamir costs log(Q) bits for Q oracle queries: a 150-proof tree has 93.51 interactive bits, 53.5 at Q = 2^40. It holds under hypotheses including that "each node's extractor succeeds on the transcripts its parent's extractor produces".

A few reflections on the lattice vs. hash-only debate that our recent Aerie post sparked: 1. Cryptographic ossification for blockchains was never safe. Until the day we know with certainty that P ≠ NP, that finding short vectors in lattices is intractable, that Keccak effectively behaves like a random oracle in deployed SNARKs, and that every single bug has been eliminated from our codebases, blockchains cannot ossify. That is simply not how safe systems are built. Issues will arise, and the system will have to respond. It’s a double standard to reject lattices because blockchains are hard to upgrade if lattices break, while counting on upgrades if AI breaks your hash function or finds a critical zkVM bug. The best counterargument is that hash-only designs are more agile: if your hash function breaks, just swap out the hash. But we must aspire to a higher level of agility than this. Indeed, as I cover next, if SNARK recursion itself turns out to degrade security, the proposed hash-only blockchain designs would need to be rethought from the ground up. 2. The real security debate is not lattices vs. hashes — it is lattices vs. building everything on SNARK recursion. That’s because “hash-only” is not really hash-only: it rests on hashes plus the soundness of deep SNARK recursion. Ethereum’s roadmap relies on exactly that: hash-based aggregation needs recursion to keep up with a slot’s worth of signatures, and EIP-8288 would send other signature schemes and users’ own proofs through the same recursive pipeline. In contrast, Aerie proves a slot’s worth of signatures on one laptop without any recursion. All deployed post-quantum SNARKs rely on the Random Oracle Methodology (via Fiat–Shamir) to establish their security. This is an idealization we know fails in the real world: we have explicit counterexamples where “SNARKs” coming out of this methodology are totally insecure when instantiated with any concrete hash function. We generally ignore these counterexamples in part because they only arise when proving contrived, self-referential statements about the very hash function used by the SNARK verifier. But proving statements about the verifier’s own hash function is the exact thing you do in SNARK recursion. That’s why the security of recursive SNARKs can’t be established even in the random oracle model. On top of that, the standard security proofs for recursion (in other models) suffer an “extractor runtime” blowup that is exponential in the recursion depth, suggesting that security may degrade as more recursion is applied. Yet Ethereum’s own EIP-8288 enables unlimited-depth recursion, even as it lists soundness of recursive SNARKs as a trust assumption. Proofs in more idealized models avoid the blowup, but they mainly tell us that an attack on SNARK recursion would have to exploit the concrete hash function, which is exactly what the Fiat–Shamir attacks above do. To be clear, we don’t know of any outright attacks on SNARK recursion, and I very much hope it is secure. But some of us who have studied the question have a lingering sense that an attack may be possible in some settings. And if AI is going to supercharge cryptanalysis, there is no reason to expect it to spare Fiat–Shamir for SNARKs, let alone SNARK recursion, both of which have had far less scrutiny than lattices. So, I do not concede that a “recursion everywhere” hash-only approach is clearly more conservative than one built on standard lattice assumptions. 3. “Just wrap everything in a hash-based SNARK” (like EIP-8288) faces challenges. Aggregating signatures and proofs off-chain into a single block-level proof is a powerful design independent of the hash-only vs. lattice debate, and I am not telling people to avoid it. But claiming, as Vitalik Buterin did this week, that users can run whatever cryptography they want locally and wrap it in a client-side leanVM proof glosses over major hurdles. For example, leanVM today is a minimal VM designed almost entirely to prove hash-based signatures and recursion, not general-purpose computation. And binary-field SNARKs like leanVM remain slow at proving the integer multiplications that lattice cryptography does en masse. I am optimistic that many of these zkVM challenges can be met (including via my own work, binary-field Twist and Shout, which are now implemented in Magnetar). But regardless, if lattices can make aggregation simpler and faster, then they should be leveraged. We need to be agile no matter what. 4. For chains whose reason for existence is privacy, I truly struggle to understand the pushback. Public-key encryption (and fast single-server PIR) cannot be built from hashes alone, at least not in any black-box way. If lattices break, it is going to be very, very hard for these chains to provide acceptable levels of privacy and functionality. For a project whose entire reason for existence is privacy, a loss of confidentiality is an existential failure. Next to that, a second signature upgrade (after the first one, from elliptic curves alone to, hopefully, a hybrid lattice scheme) is easy. Summary: We don’t know for sure what is secure and what isn’t. We are all weighing unquantifiable risks against each other, and we do not need to agree on a total order on them. But hash-only solutions face many open engineering challenges, and they are not more “conservative” in the way some have argued. Some of those challenges are entirely prosaic and have nothing to do with bugs or cryptography, like hardware support for custom schemes whose hash function is still undecided. I hope we can overcome those challenges within the appropriate timelines, but they must be acknowledged and portrayed realistically. Overall, cryptographic agility and defense in depth (e.g., hybrid signatures) are the answer, which is why we are building both lattice-Jolt and hash-Jolt. In practice, the positions are less polarized than social media discourse suggests: for example, StarkWare is working to make Falcon verification cheap (falcon.provably.fast/), which is great to see. Here is the (apparently) controversial take I am sticking to: Conditioned on agility, whenever lattices make systems simpler or more functional, we should embrace them rather than default to “hash-only” designs. Lattices are what the rest of the world will depend on, with decades of study and hardening behind them, and at the system level, less functional often means less secure. Where hash-only designs are just as simple and functional, by all means use them.

Stephen Duan avatar
Stephen Duan@sd_eigen·Oct 11

And another ongoing part is our BitVM bridge. We have finished the phase 1 prototype, with recursion proofs of WHIR on binary field and Blake3, we have reduce the proof size to 69KiB, and make it pragmatic to verify a WHIR Proof on Bitcoin via BitVM+ Garbled circuit. On phase 2, we are trying different techniques to reduce the onchain materials(proofs, OTS, and verification scripts). Those two are the most important things to make @GOATNetwork become quantum resistant.

Nobody knows exactly when today’s cryptography gets broken by a quantum computer. What matters is that the quantum-resistant replacements are running before it does. On GOAT Network, validator consensus keys are moving from secp256k1, the signature curve most chains use today, to ML-DSA-65, one of the NIST post-quantum standards. The full post-quantum picture can be found at goat.network/news/a-post-qua…

Stephen Duan avatar
Stephen Duan@sd_eigen·Oct 11

Share some numbers about multi-client proving for Ethereum with Ziren V2.0 @ProjectZKM, which can prove 75.8MHz with 8X5090, and 12MHz with 1X5090. And the instruction efficiency of Geth/Reth is around 7x, which seems larger than 5 months ago, because we did more guest side optimizations on Reth: > Witness and trie: arena nodes, compact digest references, borrowed input slices, faster RLP decoding, and fewer allocations and clones. > Memory and hashing: word-wise comparisons, a cheaper hash-map hasher, and Keccak input buffers built directly, using the stack for short inputs. > 256-bit arithmetic: multiplication and modular multiplication use zkVM precompiles; division uses hints checked inside the guest. > Cryptography: syscall-backed BN254 and BLS operations, cached KZG preparation, and accelerated modular exponentiation. > EVM interpreter: MIPS32 fast paths for gas accounting, stack swaps, and memory loads/stores. PS. the number in the picture will be updated in our next release of our paper. @go_ethereum @ethereumfndn

Post attachment

Happy to share our latest work on Ziren @ProjectZKM @GOATNetwork. Feedback welcome! A summary: 1. A new proof system based on Jaggled reduction and WHIR(including recursion proof over binary field and Blake3). Acknowledgements to SP1 team and Plonky3 contributors. 2. 4x proving efficiency, 10x emulation efficiency improvement over previous v1.2. Speedup is happening every day with AI assistant. 3. >100-bit proven security 4. A fully Lean 4 assisted constraint determinism proof, covering 104 chips. 5. A complete end-to-end zkVM design reference.