Sidechains vs Rollups: Differences and Choices in Scalability Solutions
TechFlow Selected TechFlow Selected
Sidechains vs Rollups: Differences and Choices in Scalability Solutions
This article provides an overview of Rollups and sidechains, and explores their differences in architecture, security guarantees, scalability performance, and other aspects.
Navigating Web3 tides with focused insightsWritten by: Emmanuel Awosika
Compiled by: TechFlow
Sidechains and Rollups are two solutions for addressing blockchain scalability. The core idea behind both approaches is to offload computation from resource-constrained blockchains (such as Ethereum) to independent blockchains optimized for scale. This approach brings several benefits, such as lower per-transaction costs, reduced latency, and higher overall throughput. But that's where the similarities end.
Sidechains and Rollups fundamentally differ in their scaling methodologies and involve distinct design decisions and trade-offs. For developers aiming to build scalable dapps using these solutions, understanding their differences is crucial.
This article provides an overview of Rollups and sidechains, exploring their differences in architecture, security guarantees, scalability performance, and more.
What Is a Sidechain?
A sidechain is a blockchain network that runs parallel to another blockchain, known as the "main chain." Typically, a sidechain connects to the main chain via a two-way cross-chain bridge, enabling the transfer of assets—and potentially arbitrary data such as contract states, Merkle proofs, and specific transaction outcomes—between the two networks.
Most sidechains have their own consensus mechanisms and validators, separate from the main chain. This allows sidechains to settle and finalize transactions independently without relying on other blockchains. However, it also means the security of funds bridged to the sidechain depends on strong cryptoeconomic incentives to prevent malicious behavior among validators.
Types of Sidechains
EVM-Compatible and Non-EVM Sidechains: EVM-compatible sidechains use custom implementations of the Ethereum Virtual Machine (EVM), the execution environment for deploying smart contracts on Ethereum. In practice, most of these blockchains originated as forks of go-ethereum (also known as Geth, the most popular implementation of the Ethereum protocol).
While retaining most features of Ethereum’s design (such as support for smart contracts), EVM-compatible sidechains are optimized in other aspects—particularly consensus mechanisms—to improve execution efficiency and throughput. Today, EVM-compatible sidechains host the majority of smart contracts written in EVM languages like Solidity, while reducing costs and latency for decentralized application users.
Non-EVM sidechains implement different virtual machine architectures and cannot run Ethereum-native dapps without extensive code refactoring. Developers building on non-EVM chains cannot use familiar EVM development environments and tools (like Truffle, Remix, or Hardhat) and may need to learn alternative programming languages (such as Rust or Golang) to create dapps.
Note: Avalanche, Fantom, Celo, and Palm are examples of EVM-compatible sidechains. NEAR, Solana, and Algorand are examples of non-EVM sidechains.
Commit Chains and Optimistic Sidechains: Not every sidechain relies entirely on its own security; some, particularly commit chains and optimistic chains, depend on the main chain to provide certain security guarantees. Commit chains periodically submit cryptographic commitments (e.g., block headers) to another blockchain to update their latest state. The main chain cannot verify these state proofs because it lacks access to the sidechain’s state, but it ensures honest participants can challenge invalid block headers before confirmation.
Typically, this is implemented through a smart contract on the main chain that handles rewards, staking, rotation, and penalties for sidechain validators. If a validator commits a provable violation (e.g., signing two blocks at the same height), anyone can submit evidence to the smart contract and slash the validator’s stake.
Optimistic chains operate similarly, requiring validators to regularly submit block headers to a smart contract on the main chain. However, optimistic chains lack a separate consensus mechanism—the block headers are simply assumed valid unless challenged via fraud proofs. Thus, optimistic chains can operate with only a single (honest) validator, whereas commit chains require multiple validators to function properly.
In both cases, honest participants can prove malicious activity on the sidechain to the parent blockchain. This way, even if most of the sidechain’s validators act maliciously, users still receive some level of security assurance.
However, note that honest participants cannot prove malicious behavior without access to the state data stored within the blocks. Since the main chain receives only block headers (not block bodies) from the sidechain, it cannot guarantee data availability. This enables dishonest block proposers to act maliciously—such as stealing funds from the bridge—by withholding block data.
This issue is known as the data availability problem and lies at the heart of differences in security properties across all sidechains—not just commit chains, optimistic sidechains, and Rollups.
What Is a Rollup?
Rollups enhance the scalability of underlying blockchains by processing transactions in a separate execution environment. Like sidechains, Rollups feature bridges for transferring assets between the parent blockchain and the Rollup. They also implement optimizations to improve computational speed and cost-efficiency for users.
However, Rollups periodically submit blocks to the main chain, thereby inheriting the security and decentralization of the parent chain. This means the parent blockchain provides guarantees for the following security properties of the Rollup:
-
Availability: Rollup block availability is guaranteed because data is stored on a more decentralized and secure parent network. For example, users can always prove details of the Rollup state (such as ownership of certain tokens) to the bridge contract and withdraw funds when Rollup validators hide transaction data.
-
Validity: Only Rollup blocks satisfying validity conditions enforced by the parent chain can be finalized.
-
Liveness: Because Rollup data is stored on the base layer, anyone can reconstruct the Rollup’s last valid state and produce new blocks. Additionally, users can force inclusion of their transactions into the Rollup by submitting them directly to the Rollup’s on-chain smart contract.
Types of Rollups
There are two types of Rollups: Optimistic and zero-knowledge. Zero-knowledge Rollups (also called validity Rollups) submit blocks along with proofs to the parent chain confirming correct execution of off-chain transactions. If the proof is verified on-chain, the block is finalized on the base layer.
Optimistic Rollups submit blocks without any proof verifying the validity of off-chain computations. Blocks are simply assumed valid unless another party challenges a transaction result via a "fraud proof." Fraud proofs take the form of verification games, where two parties dispute a computation under the parent chain’s supervision until the dishonest party is identified.
Optimistic Rollups are named after the optimistic assumption that most state transitions are valid. However, this optimistic assumption, combined with cryptoeconomic incentives, ensures that an invalid block will never be finalized on the main chain unless it remains unchallenged for a prolonged period.
Note: Arbitrum and Optimism are examples of Optimistic Rollups.
Another notable difference between Optimistic and zero-knowledge Rollups is EVM compatibility. While Optimistic Rollups are EVM-compatible, zero-knowledge Rollups vary in EVM compatibility. Proving native EVM instructions within a proof circuit is complex and resource-intensive, so some validity Rollups use custom virtual machine instruction sets optimized for more efficient proving.
For EVM-compatible ZK-Rollups, we describe their execution environment as a "zero-knowledge EVM" (ZK-EVM). A ZK-EVM can execute Ethereum smart contracts off-chain and prove that all parts of the computation were correctly executed. Therefore, compared to Optimistic Rollups—which rely on cryptoeconomic incentives and honesty assumptions to prevent invalid execution—ZK-Rollups are considered more secure.
Linea is an example of a second-layer validity Rollup with full EVM support, allowing developers to reuse Ethereum infrastructure and tools to build dapps. In contrast, deploying on a non-EVM ZK-Rollup like StarkNet requires either (a) building smart contracts using a different stack or (b) modifying the codebase to run on the StarkNet virtual machine.
How Do Sidechains Differ From Rollups?
Throughput: Sidechains typically have higher average transaction throughput than Rollups because they do not depend on the main chain’s consensus or data availability. For instance, sidechains can implement larger block sizes and extremely fast block times to achieve higher throughput, which Rollups cannot do.
Rollups must avoid processing too many transactions, lest transaction batches exceed the capacity of a single main chain block. Otherwise, this would reintroduce congestion on the base layer and make it difficult for the main chain to keep up with Rollup-generated blocks. Therefore, the parent chain’s data bandwidth imposes an effective limit on Rollup throughput.
Even sidechains that partially rely on main chain security (such as commit chains and optimistic chains) still outperform Rollups in terms of throughput.
Cost: Users may pay lower fees when transacting on sidechains compared to Rollups. As with other distinctions between sidechains and Rollups, this stems from Rollups relying on the parent chain for settlement and finality. Here are some operational costs incurred by Rollups (borne by users):
-
Data Storage: Submitting Rollup blocks to the base layer incurs fixed costs (the cost of including transactions in a block) and variable costs (based on the size of the Rollup block). Therefore, Rollups charge users for both computation and data, with data-heavy transactions paying more and vice versa.
-
Proof Generation and Verification: Zero-knowledge Rollups require generating validity proofs for verification on the base layer, which adds extra cost. Validating validity proofs is resource-intensive—for example, currently costing around 500,000 gas on Ethereum.
Pure sidechains do not incur these costs, making them cheaper to use. Commit chains or optimistic sidechains may incur minor additional costs, such as submitting block headers, but these are negligible. Moreover, costs can be further reduced by batching multiple block headers into a single transaction.
Finality: Sidechains fully responsible for their own security achieve instant finality—blocks cannot be reverted once approved by a majority of validators. However, this does not apply to commit chains or optimistic sidechains, which must account for challenges that could delay block header finalization.
Generally, Rollups have longer finality times than pure sidechains for various reasons. For example, Optimistic Rollups delay transaction confirmation to ensure honest participants have sufficient time to challenge invalid state updates.
Validity Rollups have instant finality (once verified), but their finality time is still longer than that of pure sidechains. Due to the high cost of generating and verifying validity proofs, sequencers prefer to accumulate large batches of transactions before generating and submitting validity proofs.
Security: Rollups (Optimistic or zero-knowledge) derive their security from the underlying blockchain, reducing user trust assumptions. As previously explained, Rollups rely on the (economically secured) main chain for consensus and data availability (unlike sidechains). This reduces risks of censorship, withdrawal freezing, and invalid execution.
Pure sidechains are responsible for their own security. However, launching a diverse and reliable set of validators can be difficult, which is why sidechains are generally considered less secure than Rollups.
Commit chains and optimistic sidechains are slightly more secure than pure sidechains, but users must trust validators and proposers for data availability. If a data withholding attack occurs without penalty, commit chains and optimistic sidechains offer no security guarantees.
Bridges: Rollups and sidechains (in most cases) use the same asset bridging scheme: locking X tokens in a smart contract on the main chain and minting X tokens for the user on the child chain. Their difference lies in how funds deposited in the bridge contract are secured.
Since Rollups are dedicated to a specific base-layer blockchain, there is usually a “canonical bridge” connecting the two. Funds deposited into a Rollup bridge are secured by the parent chain:
-
Funds deposited into a validity Rollup can only be withdrawn after the proof associated with the batch containing the withdrawal transaction has been verified on-chain.
-
For Optimistic Rollups, users can only withdraw funds after the block containing their withdrawal transaction has passed the challenge window (approximately 1–2 weeks) without being contested.
In contrast, the security of funds deposited into a sidechain bridge depends on its design. For example, if a sidechain has a canonical bridge with another blockchain, the bridge’s security depends on the honesty of the validators. Another concern is whether the bridge is validated by the entire validator set (e.g., Polygon PoS bridge) or a small group of external validators (e.g., Avalanche-Ethereum bridge).
The difference in finality time between Rollup and sidechain bridges also explains their divergence. For instance, Optimistic Rollup users experience greater delays when bridging funds back to the main chain due to the waiting period for the challenge window. With sidechains, users can withdraw funds from the bridge contract as soon as a finalized block header (and, when needed, a valid Merkle proof) is received.
Choosing Between Rollups and Sidechains
When deploying smart contracts, choosing between a Rollup and a sidechain depends on your goals, user feedback, and project requirements. Below are the advantages of using Rollups, sidechains, or both in different scenarios.
When to Use a Rollup:
-
Your users demand the highest security guarantees.
-
Your users can tolerate slightly higher costs and increased latency/finality. Rollups are significantly cheaper and faster than Ethereum (by orders of magnitude), but cannot match sidechains on these metrics.
-
You (or your users) want a closer relationship with the parent chain ecosystem (e.g., Ethereum).
-
You plan to improve the user experience for DApp users on Rollups. This might mean using liquidity providers to reduce withdrawal delays from Optimistic Rollups or implementing code optimizations to reduce transaction data generated when users interact with your smart contract.
-
You want to use EVM tools and infrastructure when building your DApp. Most Rollups are EVM-compatible and use the same tools, client software, and node APIs as Ethereum.
When to Use a Sidechain:
-
Your users want to transact with the lowest possible fees.
-
Your users want fast transaction processing, especially when bridging funds.
-
Your users can tolerate increased trust assumptions and lower security guarantees.
-
You (or your users) don’t consider a close relationship with the main chain ecosystem a top priority.
-
You are willing to learn a new set of programming languages, tools, and infrastructure for building DApps (if using a non-EVM sidechain).
When to Use Both a Sidechain and a Rollup:
-
Your project already has strong network effects on one blockchain and is ready to expand into multiple ecosystems simultaneously (e.g., to leverage liquidity).
-
You want to cater to different user segments and avoid alienating any part of the market.
-
Your project has sufficient resources to manage cross-chain expansion. This might mean having separate teams responsible for deploying your DApp on different blockchain platforms.
Join TechFlow official community to stay tuned
Telegram:https://t.me/TechFlowDaily
X (Twitter):https://x.com/TechFlowPost
X (Twitter) EN:https://x.com/BlockFlow_News
@infura_io
