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?
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 goes narrower than a general rollup explainer: it’s about how each proof mechanism actually resolves a dispute or a calculation, not about rollups as a category. That means less time on what a rollup is, and more on what happens when a batch gets challenged, how long that takes, and whose word you’re actually trusting.
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 in stages, using Arbitrum’s BoLD protocol as a concrete example:
- Block-level challenge — the dispute starts as a disagreement over an entire claimed assertion about the chain’s state.
- Big-step challenge — the disputed range narrows to a chunk of roughly 2^20 (about a million) execution steps.
- One-step challenge — the range narrows again until only a single instruction is actually in dispute.
Only that one instruction actually gets re-executed and checked on Ethereum. That keeps a dispute cheap even when the underlying batch holds thousands of transactions, since nobody has to re-run the whole thing to resolve one disagreement.
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: cryptographic output from a prover, typically a zk-SNARK or zk-STARK, that lets an Ethereum smart contract confirm a batch of transactions executed correctly without re-running any of them. See ethereum.org’s ZK-rollup documentation.
Once that proof verifies on Ethereum, the new state is final — there’s no challenge period, because there’s nothing left to challenge. What Are ZK-Rollups? walks through the full sequencer-to-prover pipeline in more detail; what matters here is simply that verification happens once, upfront, instead of being left open to dispute.
The “zero-knowledge” name is a little misleading here: it doesn’t mean the rollup hides transaction data. Most ZK-rollups still publish full transaction data to Ethereum for anyone to read — the zero-knowledge part is the proof itself, which confirms a computation was correct 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 Actually Has to Trust Whom?
Every proof system needs someone, or something, to do the actual work of catching an error or generating a proof. The two models assign that job very differently.
A fraud-proof rollup depends on independent challengers: anyone running a full node with enough at stake in getting it right to re-execute a batch and open a dispute if something’s wrong. Arbitrum’s BoLD protocol made this role permissionless in February 2025, so it’s no longer limited to the small, allowlisted set of validators the network relied on for its first three-plus years.
A validity-proof rollup depends on a prover instead — specialized, often expensive hardware that generates the cryptographic proof itself. Nobody needs to be watching for fraud, because the math either checks out on-chain or the batch never finalizes. That shifts the real bottleneck from social coordination — finding a challenger who’s actually paying attention — to computational throughput: how fast the prover can turn a batch into a proof.
For current TVL, decentralization-stage rankings, and which specific networks lead on each side, NOWNodes’ full breakdown of ZK-rollups and its Arbitrum vs. Optimism comparison track the numbers by network. What matters for this piece is simpler: whichever side a team builds on, they still need ordinary RPC access to read balances, submit transactions, and subscribe to new blocks. NOWNodes, for instance, offers that access to both the optimistic side (Arbitrum, Optimism, Base) and the ZK side (zkSync, Starknet, Linea) through the same API, since the choice of proof system doesn’t change what an application 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 does the work | Independent challengers, only if needed | A dedicated prover, on every batch |
| Compute cost | Low; cost sits mainly in data publishing | High; proof generation is compute-heavy |
| EVM compatibility | Near-native | Improving, historically harder (zkEVMs) |
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.
Validity proofs aren’t confined to full rollups, either. Validium networks use the same cryptographic proof to confirm a batch is correct while keeping the underlying transaction data off Ethereum entirely, trading some data-availability guarantees for lower publishing costs — a reminder that a validity proof is a verification technique, not one fixed architecture.
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 — optimistic rollups still hold 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 a compromised ceremony would weaken the proof system’s guarantees. zk-STARKs sidestep that specific risk by skipping a trusted setup entirely, using hash-based cryptography instead.
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.
Do Other Blockchains Use This Same Term Differently?
Yes. On Ethereum-style rollups, a validity proof always refers to the rollup-batch verification described above. But the same term shows up in a different context on Solana, where the ZK Compression system exposes a getValidityProof RPC method that proves a compressed account’s state is correct — a related idea, a cryptographic proof of correctness, applied to a different problem, state compression rather than rollup batches.
