A validity proof is a cryptographic proof (ZK-SNARK or ZK-STARK) that mathematically guarantees a batch of transactions was computed correctly. Unlike fraud proofs (which assume honesty and check on complaint), validity proofs prove correctness upfront before L1 accepts the state update. They are what make ZK rollups possible: one proof verifies thousands of transactions in one cheap L1 check.
What Is a Validity Proof?
3 min read
The short version
A validity proof is like submitting your math homework with a certified answer key attached. The teacher (Ethereum L1) does not need to redo your entire problem set. They check the answer key (verify the proof), and if it checks out, they know every answer is correct without working through each problem individually. This verification is fast and cheap even though generating the proof was computationally expensive.
How It Works
How it works: (1) The ZK rollup prover executes a batch of transactions and produces a validity proof asserting "given starting state S1, after applying these transactions, the resulting state is S2." (2) The proof is submitted to a verifier contract on L1. (3) The verifier performs a quick mathematical check (a few hundred thousand gas) that confirms the proof is valid. (4) If valid, L1 updates the accepted state root to S2. No waiting period needed. Types: ZK-SNARKs (Succinct Non-interactive Argument of Knowledge): small proofs (~200 bytes), fast to verify, require a trusted setup ceremony. Used by zkSync, Polygon zkEVM, Scroll. ZK-STARKs (Scalable Transparent Argument of Knowledge): larger proofs (~100KB+), no trusted setup, quantum-resistant. Used by StarkNet. Both achieve the same goal: cheap verification of expensive computation.
Verifying 10,000 transactions with one proof
A ZK rollup batch contains 10,000 token transfers. Without the rollup: verifying all 10,000 on L1 would cost approximately 210,000 gas x 10,000 = 2.1 billion gas (impossible in one block). With the rollup: the prover generates a ZK-SNARK proof (takes 10-30 minutes on specialized hardware). The proof plus compressed state diff is submitted to L1. The verifier contract checks the proof in ~500,000 gas (one transaction, ~$15 at moderate gas prices). That $15 verification cost is shared across 10,000 transactions = $0.0015 per transaction for L1 security. The math checks that every single one of those 10,000 transfers had valid signatures, sufficient balances, and correct state updates. No trust required, pure mathematics.
What People Get Wrong
Validity proofs are the same as zero-knowledge proofs for privacy
The term "zero-knowledge" refers to the mathematical property that the verifier learns nothing beyond the statement being true. In ZK rollups, this property is used for compression (verifying correctness without re-executing), not for hiding transaction data. Most ZK rollups publish transaction data publicly. Privacy is a separate application of the same math.
Validity proofs are instantaneous
Verification on L1 is fast (one transaction). But proof generation takes time (minutes to hours per batch depending on complexity and hardware). The total cycle from transaction submission to L1 finality is typically 15-60 minutes, not instant.
Any computation can be easily proven
Converting arbitrary computation into provable circuits is a major engineering challenge. Some operations that are cheap in the EVM are expensive in ZK circuits (hash functions, certain memory access patterns). This is why ZK-EVM compatibility exists on a spectrum and why full type-1 equivalence is the hardest to achieve.
Keep Reading
Sources & Further Reading
- StarkWare: STARK Proofs
StarkWare official site covering STARK proof technology and StarkNet
Questions People Also Ask
- What is a trusted setup?
- Some ZK-SNARK systems require a one-time ceremony to generate public parameters. If the secret randomness from the ceremony is not properly destroyed, fake proofs could be generated. Modern ceremonies involve thousands of participants (if ANY one of them is honest and destroys their share, the system is secure). STARKs avoid this requirement entirely.
- Are validity proofs expensive to generate?
- Yes, computationally. Proof generation requires specialized hardware (GPUs, FPGAs, or custom ASICs) and significant electricity. This cost is amortized across all transactions in the batch. As hardware improves and proof systems are optimized, generation becomes faster and cheaper over time.
- Can a validity proof be faked?
- If the underlying cryptographic assumptions hold (which they are expected to for the foreseeable future with current systems), forging a valid proof for an incorrect computation is computationally infeasible. This is the core security guarantee: valid proof = correct execution, period.