Fraud Proof

A fraud proof is a cryptographic proof that demonstrates an invalid state transition has occurred within a blockchain's execution layer, such as an Optimistic Rollup. This mechanism underpins the "optimistic" security model, where transactions are assumed to be valid unless proven otherwise. A single honest participant can submit a fraud proof to a parent chain (e.g., Ethereum) to challenge a proposed but incorrect block, ensuring the system's integrity without requiring every node to process all data. This enables significant scalability by separating computation from consensus verification.

The process involves two key roles: an Asserter (or Proposer), who submits new state roots, and a Challenger, who monitors and disputes invalid assertions. When a challenger detects fraud, they construct a fraud proof by pinpointing the specific step in the transaction execution where the error occurred. This proof, which includes minimal necessary data like pre-state, transaction input, and the faulty computation step, is then submitted on-chain. The parent chain's smart contract verifies this compact proof, and if valid, it reverts the fraudulent state update and slashes the asserter's staked collateral.

Fraud proofs are distinct from validity proofs (like ZK-proofs), which cryptographically prove correctness in advance. The trade-off is a challenge period—typically 7 days—during which withdrawals are delayed to allow for potential disputes. This design prioritizes scalability for general-purpose smart contracts, as generating a fraud proof for complex, non-deterministic logic is simpler than constructing a zero-knowledge proof. However, it introduces latency for finality and relies on the presence of at least one honest and active participant to monitor the chain.

A fraud proof is a cryptographic proof submitted to a base layer blockchain (like Ethereum) to demonstrate that a state transition published by a rollup's sequencer is invalid. This mechanism is the core security guarantee of Optimistic Rollups, which operate on the principle that all transactions are assumed valid unless proven otherwise within a predefined challenge period. The system relies on a network of independent validators (or any participant) to monitor the rollup's state and submit a fraud proof if they detect a discrepancy, triggering a reversion of the fraudulent state update.

The process begins when a verifier downloads the rollup's published data, which includes the new state root and the transaction batches that allegedly produced it. By independently re-executing the transactions, the verifier can compute the correct state root. If their computed root differs from the one claimed by the sequencer, they construct a fraud proof. This proof is not a replay of all transactions but a compact, cryptographic attestation pinpointing the specific step in the transaction execution where the fraud occurred, often using interactive fraud proofs or fault proofs that involve a multi-round challenge game to minimize on-chain computation.

Upon receiving a valid fraud proof, the base layer's smart contract (the rollup contract) slashes the sequencer's staked bond and reverts the incorrect state root and any subsequent dependent states. This economic penalty disincentivizes malicious behavior. The architecture creates a 1-of-N honest minority assumption, meaning the system is secure as long as at least one honest participant is actively watching and can submit a proof within the challenge window, which typically lasts 7 days for protocols like Arbitrum and Optimism.

Key technical implementations vary: Arbitrum Nitro uses a multi-round, interactive challenge protocol that compresses disputes down to a single instruction step, while Optimism's Cannon fault proof system employs a bisection protocol to efficiently locate the point of disagreement in a long execution trace. These designs prioritize gas efficiency on Layer 1, as verifying a compact fraud proof is far cheaper than re-executing an entire batch of transactions, which is the alternative model used by ZK-Rollups.

A fraud proof is a cryptographic challenge mechanism that allows a verifier to prove that a state transition posted to a Layer 1 (L1) blockchain, like Ethereum, is incorrect. The process begins after a sequencer (or proposer) posts a batch of transactions and a new state root to the L1, asserting its validity. The system operates on optimistic execution, meaning the new state is accepted as valid unless challenged within a predefined challenge window, typically 7 days. During this period, any honest full node that has re-executed the transactions can detect a discrepancy.

To initiate a challenge, the verifier—often called a challenger—submits a fraud proof transaction to the L1 contract. This transaction specifies the exact point of disagreement, such as a specific transaction or a state transition within the batch. The core of the challenge is an interactive verification game, like a bisection protocol, which efficiently pinpoints the single step of execution where the sequencer's claim diverges from the correct result. This game forces both parties to repeatedly refine their claims until the dispute is isolated to a minimal, verifiable computation.

The final, isolated step is then executed on-chain by the L1's Ethereum Virtual Machine (EVM). This on-chain execution serves as the single source of truth. If the challenger is correct, the fraudulent state root is reverted, the sequencer's bond is slashed (partially burned and partially awarded to the challenger), and the correct state is restored. This process ensures data availability is the only security requirement for verifiers, as they can download the transaction data and locally compute the correct state to validate or challenge claims.