A blockchain rollup is a Layer 2 scaling system that processes transactions off Ethereum's main chain, bundles them into a compressed batch, and posts a summary plus proof data back to L1. Rollups inherit Ethereum's security while delivering transaction throughput that the base layer cannot match at current gas prices. Arbitrum and Optimism, two of the most widely used rollups, each settle millions of transactions per day at a fraction of Ethereum mainnet costs.
​

The core problem rollups address is arithmetic: Ethereum processes roughly 12–15 transactions per second onchain at full block capacity (ethereum.org scaling overview). During peak demand that constraint pushes average fees into tens of dollars. Rollups shift execution off L1 while keeping the base layer as a settlement and data availability anchor, which means users keep Ethereum's security guarantees without paying for each individual transaction as a full L1 inclusion.
​

A blockchain rollup is a Layer 2 protocol that executes transactions off Ethereum, compresses them into a batch, and anchors that batch to L1. The rollup inherits L1 security because anyone can verify the posted state. Two families exist: optimistic rollups, which allow a fraud-proof challenge window, and ZK rollups, which attach a cryptographic validity proof L1 verifies immediately.
​

The term "rollup" refers to rolling up many transactions into a single L1 commitment. A batch posted to Ethereum might represent thousands of swaps, transfers, or contract calls that occurred on the rollup. L1 verifies the batch root rather than each transaction individually, which is where the cost saving originates. Ethereum's Layer 2 documentation describes rollups as the primary scaling path the ecosystem has converged on.
​

Rollups differ from earlier scaling attempts like state channels and plasma chains because all transaction data (or a cryptographic commitment to it) is posted to L1. Any observer can reconstruct rollup state from L1 data alone, unlike systems that rely on off-chain data operators who can go offline or withhold data.
​

For context on where rollups fit in the broader chain hierarchy, see what is a Layer 2 blockchain. Some projects build atop existing rollups to create Layer 3 chains; see what is a Layer 3 blockchain for that extension.
​

Ethereum's base layer processes around 12–15 transactions per second, a ceiling set by block gas limits and 12-second block times. At high demand, users bid against one another for block space, pushing gas fees well above the cost of simple token transfers. Rollups exist to decouple execution throughput from L1 block space, allowing thousands of TPS while keeping L1 as the trust anchor.
​

During the DeFi peak in 2021, average Ethereum gas fees exceeded $50 per swap on Uniswap v2. Simple transfers routinely cost $20–$30. Those levels priced out retail users and most payment use cases. Rollups move execution to a cheaper environment, post proof of correctness to L1, and let users pay a fraction of the L1 cost.
​

The Ethereum community formally embraced a "rollup-centric roadmap" in 2020, prioritizing improvements to how rollups post data to L1 rather than attempting to raise the base layer's own throughput indefinitely. EIP-4844 (covered below) was a direct product of this roadmap, reducing rollup data costs by introducing a dedicated blob data format separate from calldata.
​

The sequencer is a central component in most deployed rollups. It receives user transactions, orders them, and posts batches to L1. Most current rollups run a centralized sequencer operated by the rollup team, which creates a liveness dependency: if the sequencer goes offline, the chain stops producing blocks. It does not, however, create a theft risk: users retain the ability to force-include transactions directly via L1 even if the sequencer is unresponsive, a mechanism sometimes called the "escape hatch." Arbitrum, Optimism, and Base all implement force-inclusion mechanisms for this reason.
​

L2Beat (l2beat.com) tracks total value locked across Layer 2 chains. As of Q1 2026, the combined TVL across tracked rollups exceeded $30 billion, reflecting widespread adoption by both DeFi applications and user-facing wallets.
​

Optimistic rollups execute transactions off L1, batch the results, and post the new state root to Ethereum. L1 accepts the posted state as valid by default. A 7-day challenge window follows each batch, during which any observer can submit a fraud proof showing a state transition was invalid. A successful proof rolls back the batch and rewards the challenger.
​

The fraud proof mechanism is the security backbone. A verifier re-executes the disputed transaction onchain using the posted calldata and compares the output to the sequencer's claimed result. If they diverge, L1 slashes the sequencer's bond and reverts the batch. The system is trustless in the sense that honest participants can always correct invalid state without relying on the sequencer to behave correctly.
​

This 1-of-N trust model is weaker than ZK's cryptographic guarantee but is sufficient for security in practice, provided at least one honest watcher monitors the chain. Projects like Arbitrum and Optimism both run their own watchers and also publish open-source monitoring tooling so third parties can participate. The fraud proof game is permissionless: anyone holding ETH for gas can challenge a fraudulent batch within the window.
​

The practical consequence of the 7-day window is withdrawal latency. Moving assets from an optimistic rollup back to Ethereum L1 requires waiting out the full challenge period to ensure no fraud proof invalidates the withdrawal batch. Most users bypass this via liquidity bridges that provide fast exits for a small fee, but the underlying protocol delay is a real constraint. Fault proofs in blockchain covers the mechanics of how these challenges are constructed and adjudicated.
​

Arbitrum One uses a multi-round interactive fraud proof system called the Arbitrum Virtual Machine (AVM). Arbitrum's architecture narrows the disputed computation through repeated bisection until a single instruction can be verified onchain. Optimism's OP Stack uses a single-round fault proof model introduced in 2024. Both approaches achieve the same security property: an honest party can always win a dispute if they monitor the chain and respond within the window. For OP Stack specifics, see what is an OP Stack.
​

ZK rollups generate a cryptographic validity proof (a SNARK or STARK) for every batch of transactions, then submit that proof to L1 alongside the compressed transaction data. Ethereum's L1 verifier contract checks the proof mathematically, rejecting any batch whose proof does not verify. Because validity is proven at submission time, ZK rollups achieve near-instant finality on L1 without a challenge window.
​

The proof systems used today split into two main families. SNARKs (Succinct Non-interactive Arguments of Knowledge), used by zkSync Era and Scroll, produce small proofs that are cheap to verify onchain but require a trusted setup ceremony during deployment. STARKs (Scalable Transparent Arguments of Knowledge), used by StarkNet and Polygon zkEVM in some configurations, are larger proofs that require no trusted setup and rely only on hash functions, making them quantum-resistant by design. The tradeoff is proof size and verification gas cost.
​

EVM compatibility has been the central engineering challenge for ZK rollups. Ethereum's EVM was not designed with ZK proving in mind, so generating proofs for arbitrary EVM opcodes requires circuit designs that can be expensive to compute. Projects like Scroll, Polygon zkEVM, and zkSync Era have made significant progress toward full EVM equivalence, with varying degrees of compatibility. Ethereum's ZK rollup documentation maintains a current list of deployed systems and their compatibility levels.
​

Near-instant finality is the key user-facing advantage. Once an L1 block containing the validity proof is confirmed (typically 1–2 Ethereum block times after batch submission), the rollup state is final. There is no withdrawal waiting period from the protocol's perspective, though bridge implementations may add their own delays for liquidity management.
​

Proof generation is computationally intensive, and proving time varies by system. zkSync Era uses a SNARK prover that generates proofs in minutes for typical batch sizes. StarkNet's STARK prover takes longer but scales better with batch size. Both approaches still offer far faster settlement than the 7-day optimistic window. As specialized proving hardware (GPUs, FPGAs, custom ASICs) becomes more common, ZK proof generation times are expected to fall further. Nil Foundation and other teams are building dedicated ZK coprocessors aimed at reducing proving latency below the 1-minute threshold.
​

The two rollup families share the same basic architecture (off-chain execution, L1 data posting, inherited Ethereum security) but differ across five dimensions that matter for developers and users choosing where to deploy. The table below summarizes these differences across production systems as of Q1 2026.
​

Data on TVL and activity for each chain is tracked in real time at L2Beat's scaling summary. No single rollup family is universally superior: the optimistic model offers simpler EVM compatibility with more mature tooling, while the ZK model offers faster finality and a stronger cryptographic security guarantee at the cost of higher proof computation overhead.
​

EIP-4844, activated in March 2024 as part of the Dencun upgrade, introduced blob-carrying transactions. Blobs store up to 128 KB of data per blob, priced in a separate fee market from L1 execution gas. Rollups post transaction data as blobs rather than calldata, reducing data posting costs by roughly 10x versus pre-Dencun levels. Blobs are pruned after approximately 18 days.
​

Before EIP-4844, rollups paid for every byte of calldata at the full L1 gas rate. Calldata costs 16 gas per non-zero byte. Blobs introduced a separate fee market with their own base fee that adjusts independently of L1 execution gas. At low blob demand, blob fees are near zero. The result is that rollup data submission, previously the dominant cost component, dropped sharply after March 2024.
​

The EIP-4844 specification describes the full blob transaction format, the KZG polynomial commitment scheme used to commit to blob contents, and the pruning schedule. Rollups use the KZG commitment as a verifiable anchor: L1 stores the commitment permanently, while the blob data itself is temporary. ZK rollups can also use the KZG commitment inside their circuits, since the commitment scheme is already precompiled into Ethereum's consensus layer after Dencun.
​

The practical cost impact was measurable within days. Arbitrum, Base, and Optimism all reported average user transaction fees in the $0.01–$0.05 range for simple transfers within weeks of Dencun activation, compared to $0.30–$1.50 pre-upgrade. This made rollup payments economically viable for microtransactions and high-frequency use cases that were not feasible at earlier fee levels.
​

EIP-4844 set an initial target of 3 blobs per block with a maximum of 6. Future Ethereum upgrades (Pectra and beyond) are planned to expand that target, which will further reduce the blob fee base rate as per-block supply grows.
​

For rollup developers, blob adoption required updating the data submission pipeline to use the new transaction type. Both Arbitrum and Optimism completed this migration within days of Dencun going live. The change was transparent to end users but produced immediate, measurable fee reductions that showed up in on-chain fee data tracked by tools like L2Fees.info.
​

Native USDC means Circle issues the token directly on a given chain via CCTP (Cross-Chain Transfer Protocol), rather than bridging it from Ethereum as a wrapped token. CCTP burns USDC on the source chain and mints it on the destination chain, eliminating bridge contract risk. As of Q1 2026, Circle supports native USDC on Arbitrum One, Optimism, and Base among rollup chains.
​

The distinction between native USDC and bridged USDC.e matters for applications. Bridged USDC (often labeled USDC.e or USDC on older bridge deployments) is an ERC-20 token whose backing sits in an L1 escrow contract. If the bridge contract is exploited, the backing is at risk. Native USDC carries only Circle's own counterparty risk, backed by Circle's attestation and reserve transparency reports rather than a bridge operator's smart contract.
​

From a developer perspective, native USDC also enables programmatic cross-chain settlement without a bridge intermediary. CCTP provides a burn-and-mint API that applications can call directly. A payment application on Optimism can burn USDC, pass the Circle-signed attestation to the destination chain, and mint USDC on Arbitrum in a single user flow. This is the mechanism Eco Routes uses for USDC settlement across its supported rollup chains, bypassing liquidity pool models that require pricing USDC at less than 1:1 during high-volume periods.
​

Optimism and Arbitrum both enabled native USDC via CCTP in 2023. Base, built on the OP Stack and launched by Coinbase in 2023, launched with native USDC available from the start. Circle's CCTP documentation lists the full set of supported chains and provides the canonical contract addresses for each deployment.
​

For stablecoin cross-chain transfers, the question of native versus bridged USDC determines the settlement path. Eco Routes supports native USDC on Arbitrum, Optimism, and Base as part of its 15-chain network, using CCTP as the internal transport layer for USDC moves between those chains. CCTP burns and mints rather than locking and wrapping, which means USDC transferred through the Eco Routes network arrives on the destination chain as Circle-issued, fully redeemable USDC rather than a bridge wrapper. For cross-chain intent protocols more broadly, see best cross-chain intent protocols 2026.
​

Optimistic rollups assume transactions are valid and rely on a 7-day fraud-proof window to catch errors, resulting in slower L1 finality for withdrawals. ZK rollups attach a cryptographic validity proof to each batch, so L1 can verify correctness immediately, giving near-instant finality without a waiting period. Both inherit Ethereum's security.
​

Rollup finality is the point at which a transaction's state change cannot be reversed. For optimistic rollups, L1 finality arrives after the 7-day challenge window closes with no successful fraud proof. For ZK rollups, finality arrives when the validity proof is verified in an L1 block, typically within minutes to a few hours of batch submission.
​

EIP-4844, activated in March 2024, introduced blob transactions that let rollups post transaction data in a cheaper, separately priced data market instead of expensive L1 calldata. Rollup data posting costs fell roughly 10x after activation. Average transfer fees on Arbitrum and Base dropped below $0.05 within weeks of the Dencun upgrade going live.
​

Rollups inherit Ethereum's security for settlement and data availability because all proof and transaction data is anchored to L1. The sequencer can reorder transactions but cannot steal funds or post invalid state without being caught, either by fraud proof (optimistic) or validity proof rejection (ZK). Users are exposed to sequencer liveness risk but not theft risk, as long as the proof system is sound. See what trustless means in blockchain for context.
​

As of Q1 2026, Circle issues native USDC directly on Arbitrum One, Optimism, and Base via the Cross-Chain Transfer Protocol (CCTP). These deployments allow USDC to be burned on one chain and minted on another without a bridge wrapper, eliminating bridge smart contract risk. Other rollups may offer bridged USDC.e, which is a wrapped representation backed by L1 escrow.
​

Sources and methodology. Rollup fee figures and TVL data sourced from L2Beat and DeFiLlama, Q1 2026. EIP-4844 specification verified against eips.ethereum.org/EIPS/eip-4844. CCTP chain support verified against Circle's CCTP documentation. Stablecoin supply data pulled from DeFiLlama on April 29, 2026. Protocol architecture details cross-referenced with official Arbitrum, Optimism, and Ethereum documentation.
​