Rollups are Layer 2 scaling solutions that process transactions outside a blockchain's main network and compress them into a single batch before submitting it back to the base layer. First gaining prominence on Ethereum, rollups address throughput limitations from the blockchain trilemma — the tension between scalability, security, and decentralization that constrains most Layer 1 networks.
Every block on a blockchain holds a finite amount of data. As more users and decentralized applications compete for space, transactions slow and fees rise. Ethereum, for example, has historically processed roughly 15 to 30 transactions per second on its base layer, a bottleneck that becomes clear during high demand.
Blockchain networks can post two types of information: full transaction data and compressed output data from processing those transactions. The latter is much lighter, like a bank cheque weighing the same regardless of the amount written. Rollups exploit this by executing computation off-chain and posting only minimal resulting data to the mainnet, leaving the base layer to handle settlement and security instead of raw transaction processing.
A rollup bundles many individual transactions on a secondary layer, executes them, and submits a condensed summary back to the parent chain. This off-chain processing reduces the computational burden on the main network while preserving the security of the underlying blockchain, since the final state data is still recorded on-chain.
The result is a significant reduction in transaction fees and confirmation times. Users interact with decentralized applications as usual, while the rollup protocol handles aggregation and verification behind the scenes. The parent chain remains the ultimate arbiter of validity and security.
Rollups are broadly divided into two families, each with a different method for proving that the off-chain transactions they submitted were valid.
Optimistic rollups assume submitted transactions are valid by default. Instead of producing a cryptographic proof upfront, they let the transaction batch pass unchallenged unless someone objects. Any participant can contest a suspicious transaction during a challenge period, typically lasting about seven days.
When a challenge is filed, the protocol runs a fraud-proving mechanism that re-executes disputed transactions on-chain. If a transaction is invalid, the responsible block validator receives a financial penalty. This system keeps participants honest without requiring expensive proof generation for every batch.
Because optimistic rollups rely on Ethereum smart contracts for security, they inherit mainnet-level protection. Their simplicity also makes them cheaper to implement and easier to integrate with existing Ethereum infrastructure. The main trade-off is the withdrawal delay caused by the challenge period, as funds moved from the rollup back to Layer 1 must wait for that window to close.
Prominent implementations include Optimism and Arbitrum.
Zero-Knowledge (ZK) rollups take a different approach. Instead of assuming validity and waiting for challenges, they generate a validity proof for every batch before submitting it to the mainnet. This proof is a compact cryptographic piece that mathematically confirms all transactions were executed correctly without revealing the underlying data.
Validity proofs let the mainnet confirm the rollup state near-instantly, eliminating the waiting period of optimistic rollups. Withdrawals are faster, and there is no reliance on external fraud challengers. The trade-off is the computational overhead needed to generate these proofs, which historically required specialized and expensive hardware.
ZK-rollups come in two main variants.
ZK-SNARK stands for Zero-Knowledge Succinct Non-Interactive Argument of Knowledge. The "succinct" element is important: the proofs are compact and fast to verify, even as batch size grows. Verification requires no back-and-forth between prover and verifier, keeping the process efficient. ZK-SNARKs also consume considerably less gas than alternatives, lowering end-user costs.
Their limitation is dependence on a trusted setup, a one-time cryptographic ceremony to generate system parameters. If compromised, system security could be undermined. Additionally, ZK-SNARKs are theoretically vulnerable to attacks from powerful quantum computers, a concern growing as quantum computing research advances.
ZK-STARK stands for Zero-Knowledge Scalable Transparent Argument of Knowledge. Developed by StarkWare Industries, this variant eliminates the trusted setup, replacing it with publicly verifiable randomness. This makes ZK-STARKs more transparent and generally more secure against long-term threats, including quantum computing attacks.
The scalability improvements are notable. ZK-STARKs generate proofs faster than ZK-SNARKs as transaction volume grows, making them better for high-throughput applications. The trade-off is proof size: ZK-STARK proofs are larger than SNARKs, so they take slightly longer to verify and can increase on-chain data costs.
ZK-STARKs remain a comparatively newer technology, and their production deployments are still accumulating the battle-tested track record that more established systems have built over time.
The adoption of rollups has tangibly improved Ethereum's usability. By moving most transaction processing off the main chain, rollups enable decentralized applications to scale beyond what the base layer alone can support. Developers on rollup networks benefit from familiar tools and programming environments, while users enjoy lower fees and faster throughput.
Rollup activity has also been reinforced by Ethereum's roadmap. The introduction of EIP-4844 (Proto-Danksharding) in the Dencun upgrade in March 2024 significantly reduced the cost for rollups to post data by adding a dedicated data availability layer called "blob space." This lowered fees on major rollup networks substantially, accelerating adoption.
The space continues to expand beyond Ethereum as well. Rollup architectures are being explored and deployed on other Layer 1 networks, and new categories such as sovereign rollups and app-specific rollups are emerging to serve narrower use cases with optimized performance profiles.
.webp)