Data Rollup

The foundational guarantee that transaction data is published and accessible on the Layer 1 (L1) blockchain, such as Ethereum. This allows anyone to reconstruct the rollup's state and verify its integrity. Solutions include:

• On-chain data: Data posted directly to L1 calldata (e.g., Ethereum).
• Data Availability Committees (DACs): A trusted group signs off on data availability.
• Data Availability Layers: Dedicated networks like Celestia or EigenDA that provide scalable data availability with cryptographic guarantees.

The two primary mechanisms for ensuring state correctness.

Fraud Proofs (Optimistic Rollups): Assume transactions are valid but allow a challenge period (typically 7 days) where anyone can submit a fraud proof to dispute an invalid state transition. This enables lower gas costs but introduces a withdrawal delay.

Validity Proofs (ZK-Rollups): Use zero-knowledge proofs (like zk-SNARKs or zk-STARKs) to cryptographically prove the correctness of every state transition. Batches are finalized immediately upon proof verification on L1, offering instant finality and no withdrawal delays.

The node responsible for ordering transactions within the rollup. It is the primary proposer of blocks. Key roles include:

• Ordering: Determines the transaction sequence, preventing front-running.
• Batching: Compresses hundreds of transactions into a single batch.
• Posting: Submits the batch data and, for validity rollups, the proof to the L1. Sequencers can be permissioned (run by the rollup team) or decentralized (a permissionless set of nodes), impacting censorship resistance and liveness.

The technique of drastically reducing the amount of data needed to represent transactions on the L1, which is the primary source of scalability and cost savings. Methods include:

• Signature aggregation: A single proof validates all signatures in a batch.
• Data pruning: Only essential state differences (deltas) are published.
• Call data compression: Using efficient binary formats and compression algorithms. This allows a single L1 block to secure the equivalent of thousands of rollup transactions, reducing fees by 10-100x.

A design goal where a rollup's execution environment is fully compatible with the Ethereum Virtual Machine (EVM). This allows developers to deploy existing smart contracts and tools with minimal to no modifications.

• EVM-Compatible: Can run EVM code but may have minor differences in opcodes or gas costs.
• EVM-Equivalent: Is a perfect replica of the EVM, ensuring bytecode-for-bytecode compatibility. This feature is crucial for developer adoption and ecosystem portability, enabling projects like Arbitrum and Optimism to host forks of major Ethereum dApps.

The ability for rollups and the L1 to securely exchange messages and assets. This is enabled by bridges that leverage the shared security of the base layer.

• Native Bridges: The official, canonical bridge controlled by the rollup's smart contracts on L1.
• Third-Party Bridges: Alternative bridges that may offer faster or cheaper transfers.
• Interoperability Protocols: Systems like LayerZero or Chainlink CCIP that facilitate generalized message passing. Secure communication is essential for a multi-rollup ecosystem, allowing liquidity and state to flow between chains.

Data rollups are evaluated by their impact on the blockchain trilemma: Scalability, Security, and Decentralization.

• Throughput (TPS): Can process 100-4000+ TPS vs. Ethereum's ~15-30 TPS, by batching transactions.
• Cost Reduction: Transaction fees are typically 10-100x cheaper than Layer 1, primarily due to data compression and shared batch costs.
• Time to Finality:
  • Optimistic: ~1 week for full economic finality (challenge period), but offers instant 'soft' confirmation.
  • ZK-Rollup: ~10-30 minutes for full Layer 1 finality (proof generation + verification).
• Security: Inherits the full security of the underlying Data Availability layer (e.g., Ethereum).

By batching hundreds of transactions into a single compressed calldata post on the L1, data rollups dramatically increase throughput. The cost and block space of one L1 transaction are amortized across the entire batch, enabling transaction per second (TPS) rates orders of magnitude higher than the underlying chain. For example, a rollup can process thousands of TPS while only consuming the space of a single transaction's data on Ethereum.

Unlike sidechains, data rollups derive their security directly from the Layer 1 blockchain. The data availability of all transaction data on-chain allows any honest party to reconstruct the rollup's state and fraud proofs (in optimistic rollups) or validity proofs (in zk-rollups) to enforce correct execution. This means settlement and finality are anchored to the security of Ethereum or another robust L1.

The primary cost for users is the fee to post data to the L1, which is shared by all transactions in a batch. This leads to substantially lower gas fees compared to executing directly on the mainnet. While costs fluctuate with L1 congestion, rollup transactions are consistently cheaper, often by a factor of 10-100x, making micro-transactions and frequent interactions economically viable.

Many data rollups, particularly optimistic rollups like Arbitrum and Optimism, strive for EVM-equivalence. This means existing Ethereum smart contracts, developer tools (e.g., Hardhat, Foundry), and wallets can be deployed and used with minimal to no modifications. This preserves the robust ecosystem and reduces the barrier to entry for developers migrating from L1.

The core innovation that defines a data rollup is its commitment to posting all transaction data on-chain. This data availability is critical because it allows anyone to independently verify the rollup's state transitions or challenge invalid ones. It ensures the system remains trust-minimized and secure even if the rollup's operators are malicious or offline.

The architecture separates execution (off-chain, centralized sequencer) from verification and data availability (on-chain, decentralized). This allows projects to launch with a performant, centralized sequencer while the core security properties are enforced by the L1. Over time, key components like the sequencer and prover networks can be decentralized, following a clear roadmap.