# What are ZK Proofs and why are Layer 2s migrating to them?

> What is a ZK Proof? That is a question many people ask. Here we explain how it works and who is developing them.
> By José Maldonado · Ethereum · 2026-10-17

Every time a rollup sends transactions to Ethereum, someone has to convince the layer one that the result is correct. Whether a withdrawal reaches its destination depends on it. During the early years of scaling, that guarantee was delegated to vigilance: if no one objected in time, the batch was taken as good.

Validity proofs invert the logic. Instead of trusting and waiting for a challenge, they produce a cryptographic certificate that Ethereum checks before accepting anything, without re-executing. Withdrawals no longer drag a dispute period behind them, and that period is the bottleneck of fraud proofs: Ethereum's documentation puts the wait for an optimistic rollup at around seven days.

Interest in switching systems is no longer theoretical. Scroll closed on September 22, 2026 the migration of its proving stack to OpenVM v2.0.0 with SWIRL, and Base has maintained since May 2026 a design that combines two proofs for the same state, a hardware attestation and a ZK proof generated with SP1. The question is no longer whether the cryptography works, but how much it costs to produce a proof and how much it costs to verify it on layer one.

## What is a ZK Proof or validity proof?

Every batch that leaves a layer two network arrives at Ethereum with a certificate attesting that the result is correct. That document answers a specific question: is the state the operator announces the one that results from applying those transactions to the previous state? The proof does not describe the result or summarize it, it demonstrates it.

The division of labor is fixed. An external prover, working on machines with graphics cards, generates the proof and bears the electricity cost. A contract deployed on Ethereum verifies it, and it barely takes a few lines. Producing is expensive and checking is cheap.

The most widely used formats are zk-SNARK and zk-STARK. The difference with the most consequences is not in size or latency, but in setup. Some SNARK constructions, such as Groth16, require a trusted setup ceremony with secret parameters, and if those parameters are tampered with, the guarantee weakens.

STARKs do not go through that, which is why the Ethereum Foundation's criteria require that layer one proofs not depend on trusted setups. Verifying also has a price: a Nethermind measurement puts the cost of verifying a Groth16 proof over the BN254 curve at 194,396 gas.

Most of that expense is curve pairings, with a price set by [EIP-1108](https://eips.ethereum.org/EIPS/eip-1108) at 34,000 gas per unit plus 45,000 base. STARKs take up considerably more and can exceed one million gas, so in practice they are wrapped in a smaller SNARK before being published.

![Infographic on how a ZK Proof works](https://content.observatorioblockchain.com/wp-content/uploads/2026/10/como-funciona-un-zk-proof-v2.webp)

## The fraud proof, the bet on vigilance

The opposite model starts from a different premise: take the batch as good and trust that someone will review it. An optimistic rollup publishes its data and its state root on Ethereum and opens a window during which any observer can compare the announced result with the one they get by executing the data on their own.

*   The batch is published and the dispute window starts.
*   Whoever detects a discrepancy submits a fraud proof.
*   The two parties narrow the disagreement down to a single instruction.
*   Only that instruction is re-executed on Ethereum.

That window explains the user's wait. Ethereum's [documentation on optimistic rollups](https://ethereum.org/developers/docs/scaling/optimistic-rollups/) puts the period separating an exit from the network from its final confirmation at around seven days, and that period exists so the watcher has time to act. The window is not spent resolving the dispute, which takes minutes, but ensuring the defender is not cut off.

The dispute mechanism is cheaper than it looks, although the security assumption holding it up is awkward to say out loud: the system works as long as at least one honest node is willing to watch and has funds to stake. The absence of disputes in practice does not reduce that dependence.

It is worth noting that vigilance has almost never been exercised. On Arbitrum no fraud dispute was submitted on mainnet during the more than three years from its launch in August 2021 to opening the system to permissionless validators in February 2025. The mechanism deters through its existence, not its use.

## What is a zkVM and how does it differ from a custom circuit?

The piece that changes the cost of the setup is not the proof format, but how the circuit is built. A custom circuit is designed for the exact program to be proven: every change in logic forces constraints to be reviewed, and the audit is not inherited from one program to the next.

A zkVM inverts the approach. Instead of building a circuit per program, it builds a circuit that represents a complete virtual machine, almost always over the RISC-V instruction set, and the program is supplied as input.

The RISC-V base set has around forty instructions, a small and auditable surface. That is why SP1, OpenVM or RISC Zero share the same conceptual architecture, and development is done in Rust instead of in a constraint language.

The price of that convenience is performance. A custom circuit can execute less work per proof than a zkVM, although in practice the advantage fades because the shared platform receives all the engineering investment.

Uma Roy, co-founder of Succinct, argues that optimizing a GPU prover for SP1 pays off because each improvement benefits dozens of teams at once. A specific circuit forces that same effort to be justified for a single use case.

The estimate cited in the analysis [The zkVM Wars](https://www.symbolic.capital/writing/the-zkvm-wars) points in the same direction: bringing a custom-circuit project to market can cost on the order of two years and one hundred million dollars between engineering and auditing.

The boundary has blurred. The Ethereum Foundation started its zkEVM with custom circuits, and the Privacy and Scaling Explorations team ended up moving to a general-purpose zkVM for auditability.

Modern zkVMs incorporate specialized circuits for expensive operations, and the [production version of OpenVM 2.0.0](https://blog.openvm.dev/2.0-production) added deferrals, a mechanism that lets a guest program verify arbitrary circuits within the same proof.

## What each option costs

The prices of producing a proof have collapsed over the last two years. Axiom published in its OpenVM 2.0 Beta benchmark an average cost of 0.01 dollars per Ethereum block proven on a cluster of sixteen RTX 5090 cards, with 7.9 seconds at the 99th percentile.

Criterion

Fraud proof

Validity proof with zkVM

Validity proof with custom circuit

Purpose of the withdrawal

About seven days of window

Minutes or hours

Minutes or hours

Where the expense is

Publishing data on layer one

Generating the proof on GPU

Generating the proof and maintaining the circuit

Cost of generating

Not applicable in the normal case

Around 0.01 dollars per block

More work per constraint

Cost of verifying

One re-executed instruction

About 194,000 gas wrapped in Groth16

Circuit's own verification

Development

Low, the system already exists

Weeks of code in Rust

On the order of two years and one hundred million

Security assumption

One honest watcher

The soundness of the proof system

The soundness of the circuit and its audit

Main risk

Censorship by the watcher

Soundness failure of the system

Error in an unaudited constraint

The production version of OpenVM 2.0.0 proves Ethereum blocks in real time with eight cards, with a 99th percentile of 9.8 seconds, and wraps the resulting proof in a SNARK verifiable on the EVM in 8.1 seconds with a single card. That figure explains why the comparison is often made on the gas cost of verification.

The honest comparison has to include development, because the cost of producing proofs does not decide a migration. Writing the program in Rust on a zkVM is a matter of weeks, and designing a custom circuit is a years-long project with independent audits.

There is a third cost that does not appear in spreadsheets, and that is uncertainty. The Ethereum Foundation set in July 2025 the bar for real-time proving at ten seconds for the 99th percentile of blocks, 100,000 dollars of hardware, 10 kilowatts of consumption, open source, 300 kilobytes of proof at most and no trusted setup, according to its [published definition](https://blog.ethereum.org/2025/07/10/realtime-proving).

## The limits the proof does not fix

Adding cryptography to a network does not make it decentralized. L2BEAT's stages framework measures that decentralization separately and warns that a project can be at the most advanced stage and still have an experimental or unaudited proof system.

*   Control over who can propose blocks and in what order.
*   Contract upgrades without an exit window.
*   Censorship of a specific transaction.

Base exemplifies that limit. The network remains at stage 1 because it keeps a single sequencer, upgradeable contracts without an exit window and a multisig that controls the list of authorized provers. The ZK proof does not correct any of those points and works as a fallback mechanism.

Nor does it guarantee that data is available or that the operator includes transactions. A validity proof demonstrates that the state transition is correct, and nothing more: if the sequencer ignores an order, the user needs another route to force its inclusion on layer one. That route arrives late.

The risk specific to this model is a soundness failure. An error that allows an invalid state to be proven does not resemble a performance failure, because an attacker could mint assets or rewrite the state. The Ethereum Foundation warned about it in December 2025 and shifted the sector's focus: speed was no longer the obstacle, demonstrable security was, according to its [second installment on the zkEVM](https://blog.ethereum.org/2025/12/18/zkevm-security-foundations).

## Security takes over from speed

The Ethereum Foundation stated in December 2025 that real-time proving had ceased to be the problem. Latency per block fell from sixteen minutes to sixteen seconds, costs dropped 45-fold and 99% of blocks were proven under ten seconds on reference hardware. From that came three goals measured with the same yardstick.

*   Measure the security of each zkVM with a common tool, called soundcalc.
*   Reach 100 bits of demonstrable security with proofs of up to 600 kilobytes.
*   Reach 128 bits, proofs of 300 kilobytes at most and a formal argument on recursion before the end of 2026.

Even so, the statement admitted that the hard part remained. The first two goals are measured with the tool the Foundation itself maintains, while the third requires mathematically proving that the system's recursion is sound. That point is no longer engineering, it is formalization over a system that is still changing.

External auditing is part of the same shift. OpenVM 2.0.0 passed a zkSecurity review covering SWIRL, the aggregation and continuation circuits, the deferrals and the Halo2 verifier, and its Keccak and SHA-2 extensions entered formal verification. The race is no longer decided by who proves first, but by who can demonstrate that their proof does not break.

One nuance remains that the Foundation itself acknowledges. The latency and cost figures come from benchmarks with reference hardware, and the security level is estimated with models that still depend on cryptographic conjectures. Meeting the bar today does not guarantee meeting it in three years.

## What decides the next proof migration?

The economic argument has become hard to refute. Producing a block proof costs cents, verifying it costs less than 200,000 gas and the work of integrating it comes down to choosing a virtual machine and auditing the result. When cryptography stops being the bottleneck, a layer two network's decision looks more like an infrastructure purchase.

The biggest prize is not in the layer twos. The Ethereum Foundation's [roadmap for integrating a zkEVM into layer one](https://zkevm.ethereum.foundation/track) aims for validators to verify a proof instead of re-executing the block, which would allow raising the gas limit without demanding more hardware from those staking from home.

That scenario is still a testbed. Real-time proving is measured today off-chain, and its adoption depends on demonstrable security reaching the level the plan itself requires.

The tension that remains is the usual one in cryptography. The faster a system changes, the harder it is to prove it is correct, and the more money depends on it, the more expensive a soundness error becomes. The next migrations will not be decided by who announces them, but by who sustains for years that their proof never broke.
