A fraud proof lets anyone catch and reverse a bad transaction after it’s already been assumed correct. A validity proof checks the math before anything is assumed at all. Both exist to answer the same question for a very different reason: how does Ethereum know that a Layer-2 rollup, which processes transactions off-chain to keep fees low, is telling the truth about its results?
That question sits at the center of every rollup built on Ethereum today. Optimistic rollups like Arbitrum and Base rely on fraud proofs. Zero-knowledge rollups like zkSync Era and Starknet rely on validity proofs. Neither approach is a placeholder for the other — they’re two different bets on how to prove correctness without forcing every Ethereum node to re-run every transaction.
This guide walks through what each proof actually does, why rollups need one at all, and who’s currently using which. It ends with where the two approaches are starting to blur together, because in 2026 the line isn’t as clean as most explainers suggest.
How Do Optimistic Rollups Catch Bad Transactions?
An optimistic rollup starts from a simple assumption: trust the operator’s claimed result by default, then give everyone else a window to prove it wrong. That window is where the fraud proof lives.
Fraud proof: cryptographic evidence, submitted on-chain during a fixed challenge period, that a rollup’s claimed state transition was computed incorrectly — triggering a re-execution that reverts the bad result and penalizes whoever submitted it. See ethereum.org’s optimistic rollup documentation.
Here’s how the check actually plays out. The rollup operator posts a batch of transactions and a claimed new state root to Ethereum. Anyone running a full node can re-execute that batch locally, and if the result doesn’t match, they can open a dispute.
Disputes don’t replay the whole batch on Ethereum — that would defeat the point of a rollup. Instead, the two sides narrow their disagreement through a bisection process, splitting the batch into smaller chunks until they’re arguing about a single instruction. Only that one instruction actually gets re-executed and checked on Ethereum, which keeps a dispute cheap even when the underlying batch holds thousands of transactions.
This is critical: the whole system rests on what ethereum.org describes as the requirement that “the validity of the chain relies on the existence of one honest node.” No challenge during the window means the batch is accepted as final — not because it was proven correct, but because nobody proved it wrong.
How Does a Zero-Knowledge Rollup Prove Its Math?
A ZK-rollup skips the waiting entirely. Instead of assuming correctness and leaving a window for someone to object, it generates a cryptographic proof that the new state is correct and submits that proof alongside the batch.
Validity proof: a cryptographic proof — typically a zk-SNARK or zk-STARK — generated off-chain that mathematically demonstrates a rollup’s batch of transactions was executed correctly, verified by a smart contract on Ethereum in a single step. See ethereum.org’s ZK-rollup documentation.
A specialized prover, not a regular node, does the heavy lifting. It takes the batch of transactions, runs them through a zero-knowledge proving system, and outputs a proof that’s small and fast enough for an Ethereum smart contract to check directly. Once that verification passes on L1, the new state is final, and there’s no challenge period because there’s nothing left to challenge — the proof already did the checking.
The “zero-knowledge” name is a little misleading in this context. It doesn’t mean the rollup hides transaction data; most ZK-rollups still publish full transaction data to Ethereum for anyone to read. What’s zero-knowledge is the proof itself: it can confirm the computation was done right without re-running it.
Why Do Rollups Need Any Proof System at All?
Rollups exist because Ethereum’s base layer can only process so much. Pushing more transactions through by simply demanding bigger blocks would price out smaller node operators, which is exactly the trade-off described by the blockchain trilemma: more throughput, less decentralization, unless something else changes.
Rollups change something else. They move execution off-chain, batch thousands of transactions together, and post only a compressed summary back to Ethereum. That’s what keeps fees low — but it also creates a trust gap. Ethereum still has to know that summary is accurate, without re-executing every transaction that produced it.
Fraud proofs and validity proofs are the two answers to that gap. One trusts the operator by default and verifies only when challenged; the other verifies everything upfront, with math. Both let Ethereum’s base layer stay light while still inheriting its security — a batch is only as good as the proof backing it, and that proof is what a rollup actually pays for.
Who Relies on These Two Verification Models?
The split between the two camps is stark, and it’s visible in the numbers. According to L2Beat, the largest Ethereum rollups by value locked are still overwhelmingly optimistic.
| Rollup | Approx. TVL | Stage | Proof type |
|---|---|---|---|
| Base | $12.8B | Stage 1 | Optimistic (fraud proof) |
| Arbitrum One | $11.3B | Stage 1 | Optimistic (BoLD) |
| OP Mainnet | $1.7B | Stage 1 | Optimistic (fraud proof) |
| Mantle | $1.4B | Stage 0 | ZK (validity proof) |
| Linea | $431M | Stage 0 | ZK (validity proof) |
| Starknet | $391M | Stage 1 | ZK (validity proof) |
Figures from L2Beat’s scaling summary, pulled August 2026 — TVL moves daily, so treat this as a snapshot, not a fixed ranking.
Developers building consumer apps, DeFi protocols, or anything needing full EVM compatibility have historically gravitated toward Arbitrum, Optimism, and Base, since fraud-proof rollups run the same virtual machine as Ethereum itself with little adaptation needed. Teams chasing fast, cryptographically final withdrawals tend to look toward zkSync Era, Starknet, or Linea instead.
Whichever side a team builds on, they still need a way to actually reach that network — read balances, submit transactions, subscribe to new blocks. That’s ordinary node infrastructure, and it isn’t exclusive to one proof model: NOWNodes, for instance, offers RPC access to both the optimistic side (Arbitrum, Optimism, Base) and the ZK side (zkSync, Starknet, Linea) through the same API, since an application’s choice of proof system doesn’t change what it needs from a node provider.
Optimistic vs. Zero-Knowledge: Comparing the Two Security Models
Put side by side, the two models trade off in predictable ways. Neither is strictly better — each is optimized for a different constraint.
| Factor | Fraud-proof (optimistic) rollups | Validity-proof (ZK) rollups |
|---|---|---|
| Trust model | Assume valid, allow challenges | Prove valid before accepting |
| Typical withdrawal delay | ~7 days (challenge period) | Minutes to hours, once the proof verifies |
| Who can catch an error | Any honest, active challenger | Nobody needs to — the math checks itself |
| Compute cost | Low; cost sits in data publishing | High; proof generation is compute-heavy |
| EVM compatibility | Near-native (Arbitrum, Optimism, Base) | Improving, historically harder (zkEVMs) |
| 2026 examples | Arbitrum, Optimism, Base | zkSync Era, Starknet, Linea |
How Long Does It Take to Withdraw Funds?
This is the difference users actually feel. Arbitrum’s current dispute protocol, BoLD, sets each challenge period at roughly 6.4 days — worst case, a dispute plus the security council’s two-day grace window can stretch considerably longer, according to Arbitrum’s own documentation. Optimism’s fault-proof system runs on a similar seven-day window.
A validity-proof rollup skips that wait. Once the cryptographic proof for a batch verifies on Ethereum — typically minutes to a few hours after the batch closes, depending on the prover — the state is final and funds can move immediately. Third-party liquidity bridges can front funds faster on optimistic rollups too, for a fee, but the underlying protocol still needs its full window to reach trustless finality.
Whose Word Do You Have to Trust?
Fraud-proof security depends on liveness: someone has to be watching and willing to submit a proof if a batch is wrong. In practice, that watching hasn’t had much to do. No fraud-proof dispute was ever submitted on Arbitrum’s mainnet in the more than three years between its August 2021 launch and its move to permissionless validation, per reporting on the network’s dispute history — the deterrent worked without ever being tested.
Validity-proof security depends on the proving system’s math holding up, plus, for some SNARK constructions, a trusted setup ceremony that generated the system’s public parameters honestly. Get either one wrong and the guarantee weakens. Neither model is trust-free; they just move the trust to a different place — a watchful challenger on one side, cryptography and setup integrity on the other.
Where the Two Approaches Are Starting to Merge
The line between the two camps is blurrier than the table above suggests. OP Stack chains, including Base, have started layering zero-knowledge proofs on top of their existing fault-proof system through a project called OP Succinct, using it to generate a validity proof of the fraud-proof program’s own execution rather than replacing the fraud proof outright, according to Succinct’s own writeup. That shortens dispute resolution without abandoning the optimistic model’s cost advantage.
Ethereum co-founder Vitalik Buterin has been open about which side he expects to win eventually. “My opinion is that in the longer term, ZK-Rollups are eventually going to beat Optimistic Rollups because they have these fundamental advantages like you don’t need to have a seven-day withdrawal period,” he said at ETHSeoul in August 2022, as reported by The Block. That prediction is years old now, and it’s worth reading as one influential builder’s bet rather than settled fact — the L2Beat numbers above still show optimistic rollups holding the most value locked in 2026, so speed alone hasn’t decided the race yet.
Conclusion
Fraud proofs and validity proofs solve the same underlying problem — proving a rollup told Ethereum the truth — from opposite directions. One assumes good behavior and polices it after the fact; the other demands proof before it accepts anything. Neither is a strictly better engineering choice, which is why both are still securing tens of billions of dollars in value in 2026.
For anyone building on or bridging out of a rollup, the practical question isn’t which model is “better” in the abstract — it’s what that specific network’s proof system means for withdrawal time, cost, and who has to trust whom in the meantime. That answer is different for Arbitrum than it is for Starknet, and it’s worth checking before funds are on the line.
None of this is financial or technical advice. Challenge periods, prover performance, and TVL all shift as these systems mature, so verify current figures before relying on them for production decisions.
FAQ
How Often Do Rollups Actually Trigger a Dispute?
Rarely. Arbitrum’s mainnet ran for more than three years without a single fraud-proof dispute being submitted, from its August 2021 launch until it moved to permissionless validation under BoLD. The mechanism works mainly as a deterrent — validators stand to lose their entire bond if a challenge against them succeeds, which keeps most operators honest without a fight ever happening.
Do Zero-Knowledge Rollups Hide Transaction Data?
No, not by default. Most ZK-rollups, including zkSync Era and Starknet, still publish full transaction data to Ethereum so anyone can reconstruct account balances independently. “Zero-knowledge” describes the proving technique — confirming a computation was correct without re-running it — not data privacy for users.
Can a Zero-Knowledge Proof Ever Be Wrong?
The math itself is sound if the underlying cryptography is, but the systems around it can still have weak points. Some zk-SNARK constructions depend on a trusted setup ceremony to generate public parameters, and if that ceremony were compromised, the proof system’s guarantees would weaken. zk-STARKs avoid a trusted setup entirely, which is one reason some newer rollups favor them.
Is Ethereum’s Base Layer Secured by Either of These?
No. Fraud proofs and validity proofs are rollup-specific mechanisms for proving Layer-2 state to Layer-1 — Ethereum’s own consensus runs on proof of stake and validator attestations, an entirely separate system. The two proof types only come into play once a rollup needs to convince Ethereum its off-chain results are correct.
Which Model Costs Less to Run?
It depends what’s being measured. Optimistic rollups skip expensive proof generation but publish more raw data to Ethereum, which is itself a metered cost. ZK-rollups pay upfront for proving compute — historically the pricier side — but that cost keeps falling as proving hardware and recursive proof techniques improve, which is part of why more Stage-0 ZK-rollups gain ground each year.
