Skip to content
Crypto.world

The Ledger

Researchers Cut a Depth-32 Privacy Proof to 28.6 Milliseconds

A Tornado Cash-like privacy pool prototype using Flock generated a depth-32 withdrawal proof in 28.6 milliseconds, 28 times faster than the authors’ monolithic circuit. The Ethereum Research post also proposes seed-derived notes and a recovery verifier for pools facing a future break of discrete-log cryptography.

Researchers Cut a Depth-32 Privacy Proof to 28.6 Milliseconds

A depth-32 privacy withdrawal proof took 28.6 milliseconds in a prototype described on Ethereum Research on October 19—28 times faster than the authors’ initial circuit. The post, by Pierre in collaboration with @winderica, ports a Tornado Cash-like pool to Flock, a transparent binary-field proof system the authors describe as plausibly post-quantum. It also proposes a recovery route for existing pools if a future quantum computer breaks the discrete-log assumptions behind their commitments and proofs.

“We port Tornado Cash to Flock, a post-quantum binary-field SNARK, proving a depth-32 withdrawal over SHA-256 in under 30 ms, and describe a simple recovery protocol, requiring only that wallets derive note secrets from a seed, that lets existing pools survive a discrete log break.”

Pierre, writing in collaboration with @winderica on Ethereum Research

One SHA-256 circuit replaces 34

A withdrawal from a depth-32 Merkle tree requires 34 SHA-256 compressions in the authors’ design: one for the commitment, one for the nullifier hash and 32 for the path to the tree root. Rather than place all 34 operations in one large circuit, they use a small circuit for a single compression and prove 34 instances of it. A sumcheck-based argument connects those instances, ensuring each output feeds the correct next input.

The authors report 28.6 milliseconds for the stepwise depth-32 proof, compared with 0.81 seconds for the monolithic version; the proof is 266 KiB. Their depth-8 and depth-20 tests took 31.7 milliseconds and 27.4 milliseconds, respectively. They attribute the relatively flat timings to the circuit design and to Flock’s shipped Ligerito commitment configuration, which requires a committed witness of at least 222 bits across the tested depths.

Aggregation keeps verification near 60 milliseconds

The post also tests recursive aggregation, splitting work between users and an aggregator. At depth 32, each user generates a withdrawal proof in 19.5 milliseconds; the proof is 203.6 KiB and does not grow with the number of withdrawals being combined. The aggregator checks those proofs and produces one final proof covering the withdrawal count and a digest of each withdrawal’s nullifier hash and Merkle root.

In the reported tests, folding 4 withdrawals took 1.7 seconds, while folding 128 took 87.6 seconds. The resulting proof remained 343.9 KiB in both cases, and verification took 46 milliseconds for four withdrawals and 64 milliseconds for 128. The trade-off is concentrated at the aggregator: the authors put its cost at about 0.68 seconds per withdrawal, even as final proof size and verification time stay roughly constant.

The recovery plan starts with a wallet change

The proposed recovery mechanism changes how a wallet creates a note. Instead of sampling commitment secrets independently, it derives them from a 256-bit seed using truncated SHA-512. If a cryptographically relevant quantum computer becomes public, the pool would freeze its existing withdrawal verifier and let users prove, with a post-quantum zkSNARK, that they know the seed for a deposited note.

The recovery verifier would keep the existing nullifier set, so a note withdrawn before the freeze could not be spent a second time through the recovery route. The proposal assumes the pool’s Merkle tree remains collision-resistant against a quantum attacker and treats the seed-derivation function as a random oracle. Those are assumptions in the authors’ security analysis, not results established by the benchmark.

A freeze must come before the cryptographic break

Timing is the central risk in the recovery design. The authors assume the old Groth16 verifier remains sound before the freeze and that, after a discrete-log break, an attacker can forge its proofs; the pool must therefore disable that verifier before the break or funds could be drained first. Notes created without seed-derived secrets would also be stranded by the proposed recovery route.

New pools could include the recovery verifier from launch, the authors write. An upgradeable pool would need governance approval to install one, while an immutable pool cannot add the mechanism and would depend on users moving funds to a pool that supports recovery. The post presents a working prototype and a design proposal; it does not establish that deployed privacy pools have adopted either one.

Sources

  1. Original source Ethereum Research ethresear.ch

Related stories

Explore

More articles