←
ZKM3,947 posts
ZKM avatar

ZKM

@ProjectZKM

Ziren: General-Purpose zkVM & Proving Infrastructure

◷ Joined June 2023▧ 935 Photos and videos
ZKM avatar
ZKM@ProjectZKM·1h

"We are changing the digital locks before the burglar shows up at the door." - @natalia_ameline We asked four of the people behind the @MetisL2 Hybrid Rollup what it is, what it means for Metis, and what the hardest problem was to solve. Now live on devnet.

1:51
ZKM avatar
ZKM@ProjectZKM·3h

Teams preparing for quantum shouldn’t each have to work out how to get elliptic curves out of their proofs. For teams proving with Ziren, the work is happening in Ziren itself. The memory digest has a hash-based replacement on a branch. A draft Keccak-based verifier for Ethereum would replace the BN254 wrapper: zkm.io/blog/the-last-two-cur… And our new paper measures a hash-based verifier for Bitcoin bridges: eprint.iacr.org/2026/2877

Post attachmentPost attachment
ZKM avatar
ZKM@ProjectZKM·21h

A plain-language read of our new paper, Toward Efficient Post-Quantum Bitcoin Bridges. Paper: eprint.iacr.org/2026/2877

GOAT Network @GOATNetwork 21h Article Toward a Post-Quantum Bitcoin Bridge A bridge that holds bitcoin has to stay secure for as long as the bitcoin is in it. That can be years. The cryptography it relies on has to last the same time, and one part of today's bridge designs

Stephen Duan avatar
⟳ ZKM retweeted
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

ZKM avatar
ZKM@ProjectZKM·Nov 16

New paper from researchers at ZKM and @GOATNetwork: "Toward Efficient Post-Quantum Bitcoin Bridges" has been published on the IACR Cryptology ePrint Archive: eprint.iacr.org/2026/2877 BitVM-style bridges check a proof on Bitcoin by garbling its verifier off-chain. Existing designs garble an elliptic-curve verifier, which a quantum adversary breaks. This paper garbles a hash-based one: Ziren’s complete recursive verifier for WHIR-based STARK proofs, compiled to a Boolean circuit over binary-tower arithmetic and Blake3, with no pairing wrapper. For the proof of Ethereum block 26,206,588, the circuit has about 175M non-free gates and about half a million input bits, which comes to about 2.8 GB of garbled tables. Publishing that input in a dispute with hash-based one-time keys takes just under 4 MvB, in about 40 standard transactions. The rest of the dispute protocol, including the complete transaction graph, is not built yet, and a bridge built this way would still depend on Bitcoin’s own signatures.

Post attachment
Kevin.GOAT🌿 avatar
⟳ ZKM retweeted
Kevin.GOAT🌿@kevinliu·Nov 11

The Metis Hybrid Rollup is now running on devnet. Having led the decentralized sequencer work at Metis, I’m glad to see DSeq adding post-quantum signatures while Ziren proves the chain. The same sequencer upgrade is under way on @GOATNetwork.

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.

ZKM avatar
ZKM@ProjectZKM·Nov 11

None of this makes anything post-quantum secure today, and the paper says so: the security levels it computes are classical, and it claims post-quantum security for no configuration. Fiat-Shamir proofs like Ziren's stay sound against quantum adversaries in the quantum random-oracle model, but with weaker concrete bounds: a quantum collision search on the 248-bit digest of the measured instantiation costs about 2^83 evaluations rather than 2^124. A hash-based verifier also protects the proof check, not the keys around it. In the bridge design's own words, it "does not make blob KZG, signatures, consensus or governance post-quantum safe". @Ethereum's blob commitments and every account's ECDSA key move with Ethereum's own upgrades.

ZKM avatar
ZKM@ProjectZKM·Nov 11

We took a proof Ziren produced on @eth_proofs for Ethereum block 26,240,087, re-shrunk it with the Keccak suite, and submitted it to the verifier on a local Ethereum node that enforces the 16,777,216-gas cap on a single transaction. It verified in one transaction: 13,668,039 gas in total, of which 2,834,640 is the 182 KB proof packet's calldata. Deploying every verifier module costs 141.6 million gas, once. Tampered public values were rejected. 13.7 million gas is far more than a Groth16 check, so this suits a rollup that verifies on demand rather than one that verifies every batch. The verifier lives in github.com/ProjectZKM/OPSucc…, next to a proposed bridge design that can wait to finalize until a withdrawal needs it, so that one proof covers every batch since the last. #568 is a draft. Its release gates include full proving on the current version, a review of its security parameters, and gas and deployment measurements under the transaction cap for every approved build.

Post attachment
ZKM avatar
ZKM@ProjectZKM·Nov 11

PR #568 adds a different last step: github.com/ProjectZKM/Ziren/… The compact shrinker proves the verification of Ziren's compressed proof once more, but commits the result, and runs its transcript, with Keccak-256, a hash the EVM computes natively, in place of Poseidon2. A generated Solidity verifier then checks that proof directly in the EVM: Merkle paths, WHIR openings, sumchecks and field arithmetic over KoalaBear, recomputing the Poseidon2 root digest itself. No pairings, no trusted setup.

ZKM avatar
ZKM@ProjectZKM·Nov 11

The second curve sits at the end of the release pipeline. A STARK proof is too large to verify cheaply onchain, so Ziren, like most zkVMs, wraps it in a Groth16 or PLONK proof over the BN254 curve: 260 bytes for Groth16, checked with a handful of precompile calls. That wrapper rests on pairings, and its setup holds a trapdoor that anyone able to compute discrete logarithms can recover from the public parameters - and with it, prove false statements. For a validity bridge, whoever holds that trapdoor can forge the proof that releases the escrow.

ZKM avatar
ZKM@ProjectZKM·Nov 11

The overhead grows with GPUs because the block's single execution, about three to four seconds of the global commit pass (8.2, 5.0 and 4.9 seconds on one, two and four GPUs), does not shrink as cards are added. The proving pass itself is as fast as before or faster: the block needs about nine fewer shards and no global chip.

Post attachment
ZKM avatar
ZKM@ProjectZKM·Nov 11

On RTX 5090s, for a 420-million-cycle Reth block, run back to back against the elliptic-curve digest (time to the compressed proof, warm, before the recursion-key map was regenerated), the hash chain adds 5.4% on one GPU and 17.6% on four. The paper's first measurement of this approach was 29 to 42%. The implementation on the branch measures the figures in the table.

Post attachment
ZKM avatar
ZKM@ProjectZKM·Nov 11

The replacement, tracked since August 2025 as issue #276 and now in issue #570, is a global challenge built on a hash chain: github.com/ProjectZKM/Ziren/… Every shard first commits the rows that carry its cross-shard lookups, in a round of their own. A hash chain runs over those commitments, shard after shard, and the prover grinds 22 bits of proof of work on the chain's end. Only then is one challenge pair drawn for every cross-shard lookup in the execution, and each shard's lookup argument reports its share of the cross-shard sum. Recursion checks that the chain is unbroken and that the shares sum to zero. The chain constrains the order of the work: no shard can be proved until every shard has committed its global round, so the prover executes the block once before it proves it. The hash chain is implemented on the feat/pq-global-challenge branch, with tests that forge cross-shard lookups against it, and the septic-curve code is gone from the Lean, Picus and C++ sources.

ZKM avatar
ZKM@ProjectZKM·Nov 11

The first curve sits inside the proof. Ziren proves a long execution in shards, and memory has to stay consistent across them: the value one shard reads must be the value an earlier shard wrote. Inside a shard, the lookup argument balances every read against its write, under challenges drawn after the shard's trace is committed. Across shards it cannot, because the two sides of a lookup sit in different shards, proved under different challenges. Ziren 2.0 bridges them with a multiset hash on an elliptic curve over a degree-seven extension field. Each shard adds up its cross-shard accesses as curve points, and the sums cancel only if the accesses balance. That rests on a discrete-log-type assumption with no known numerical bound, which a quantum adversary breaks.

ZKM avatar
ZKM@ProjectZKM·Nov 11

A hash-based proof system rests on the security of its hash, and quantum algorithms weaken a good hash's concrete bounds but are not known to break it. An elliptic curve is different: on a large enough quantum computer, Shor's algorithm computes discrete logarithms, and every assumption built on them falls at once. In September we argued that hash-based is not the same as post-quantum: read the security theorem, not the primitive list. By that test, Ziren's path to Ethereum has two exceptions - the memory check inside each proof, and the BN254 wrapper on its release path. This is the work to remove them. zkm.io/blog/hash-based-is-no…