Validity Proof

A validity proof is a zero-knowledge proof (ZKP) or validity rollup proof that cryptographically attests to the correctness of state transitions. It proves that executing a batch of transactions, given a specific starting state, results in a specific new state, without revealing the transaction details. This creates a trust-minimized bridge to a Layer 1, as the L1 only needs to verify the proof, not re-execute the transactions.

For a validity proof to be meaningful, the underlying transaction data must be available. Systems using validity proofs, like ZK-rollups, typically post this data as calldata on the Layer 1. This allows anyone to reconstruct the state and verify the proof's claim independently, ensuring censorship resistance and enabling permissionless exits. The separation of proof verification from data availability is a key architectural principle.

Once a validity proof is submitted and verified on the Layer 1 blockchain (e.g., Ethereum), the state change it represents is considered final. This provides strong safety guarantees equivalent to the security of the underlying L1. Unlike fraud proofs, there is no challenge period where assets are locked, enabling near-instant withdrawals from Layer 2 to Layer 1 after proof verification.

Validity proofs enable massive computational offloading. The expensive work of executing transactions and generating the proof is performed off-chain by a prover. The Layer 1 only performs the relatively cheap work of proof verification. This decoupling allows for significant scalability, as the L1's capacity is no longer the bottleneck for transaction execution, only for data and verification.

While not all validity proof systems implement privacy, the underlying cryptographic primitives (like zk-SNARKs or zk-STARKs) are inherently privacy-preserving. They can prove the correctness of computations using encrypted or hidden inputs. This enables use cases like private transactions or confidential business logic, where the state transition is verified without revealing sensitive data.

A critical consideration is prover centralization. Typically, a single, powerful prover generates the validity proof, creating a temporary trust assumption. The system's security relies on at least one honest actor being able to generate a proof if the primary prover fails or acts maliciously. Ongoing research focuses on decentralized prover networks and proof-of-stake models for provers to mitigate this.

A ZK-Rollup is a Layer 2 scaling solution that executes transactions off-chain and then posts validity proofs (ZK-SNARKs or ZK-STARKs) to the underlying Layer 1 (e.g., Ethereum). This architecture provides:

• Data availability: Transaction data is posted on-chain.
• Validity guarantee: The proof cryptographically ensures all state transitions are correct.
• Capital efficiency: Users can withdraw funds without a delay, as security inherits from L1 finality.

These are hybrid models that use validity proofs but differ in data availability.

• Validium: Uses ZK proofs but keeps data off-chain with a committee, offering higher throughput but different security assumptions.
• Volition: Gives users a per-transaction choice between ZK-Rollup (data on-chain) and Validium (data off-chain) modes, balancing cost and security.

Validity proofs offer cryptographic security, where safety is guaranteed as long as the underlying cryptography is sound. This contrasts with fraud proofs (optimistic rollups), which rely on economic incentives and a challenge period where any participant can dispute invalid state transitions.

• Validity Proofs: Provide immediate finality and active security.
• Fraud Proofs: Provide eventual finality and passive security, dependent on watchdogs.

Validity-proof systems minimize trust assumptions but are not trustless. Key considerations include:

• Trusted Setup: Some proof systems (ZK-SNARKs) require a one-time trusted setup ceremony, creating a toxic waste problem if compromised.
• Prover Centralization: The high cost of proof generation can lead to centralization of the prover role, creating a single point of failure for liveness.
• Upgrade Keys: The ability to upgrade the verifier contract or proof system is often held by a multi-sig, representing a governance risk.

Validity proofs are the foundation for ZK-Rollups, a leading Layer 2 scaling solution.

• zkSync Era: Uses a ZK-SNARK-based proof system with a ZKporter for data availability options.
• Starknet: Uses ZK-STARKs, which are post-quantum secure and do not require a trusted setup.
• Polygon zkEVM: A ZK-Rollup that is bytecode-compatible with the Ethereum Virtual Machine (EVM).
• Scroll: Another EVM-equivalent ZK-Rollup focusing on developer experience.

Adopting validity proofs involves significant engineering trade-offs:

• Proving Time: Generating a ZK proof is computationally intensive, creating latency before a batch is finalized.
• Verification Cost: While cheap relative to execution, on-chain verification still incurs gas costs on the parent chain.
• EVM Compatibility: Creating ZK circuits for a complex, non-deterministic VM like the EVM is extremely difficult, often requiring custom compilers or limited opcode support.
• Hardware Acceleration: Specialized hardware (e.g., FPGAs, GPUs) is often required for practical prover performance.

The two primary families of zero-knowledge proof systems used to generate validity proofs.

• zk-SNARKs (Succinct Non-Interactive Argument of Knowledge): Smaller proof sizes, faster verification, but requires a trusted setup ceremony and is not post-quantum secure.
• zk-STARKs (Scalable Transparent Argument of Knowledge): No trusted setup, post-quantum secure, but generates larger proofs and can have slower verification. The choice involves trade-offs between trust assumptions, proof size, and computational overhead.