Discuss Sidechain and Rollup: Similarities and Differences in Architecture, Security Guarantee, and Scalability

原文：《Sidechains vs. Rollups: Breaking down the differences for dapp development》by Emmanuel Awosika

Compilation: Deep Tide TechFlow

Sidechains and Rollups are two solutions to blockchain scalability issues. At the heart of both solutions is the idea of offloading computation from resource-constrained blockchains like Ethereum to standalone blockchains optimized for scale. This approach brings benefits such as lower cost per transaction, less latency, and higher overall throughput. But the similarities end there.

Sidechains and Rollups are fundamentally different in their approach to scaling, and differ in design decisions and tradeoffs. For developers looking to leverage both solutions to build scalable dapps, it is important to understand the differences.

This article provides an overview of Rollups and sidechains, and explores their differences in architecture, security guarantees, scaling performance, and more.

**What is a sidechain? **

A sidechain is a network of blockchains that run in parallel to another blockchain (called the "main chain"). Typically, sidechains are connected to the mainchain via a two-way cross-chain bridge, allowing assets to be transferred between the two networks, and possibly arbitrary data such as contract states, Merkle proofs, and outcomes of specific transactions.

Most sidechains have their own consensus mechanism and validators, separate from the mainchain. This enables sidechains to settle and complete transactions without relying on other blockchains. However, this also means that the security of funds bridged to sidechains depends on the existence of strong cryptoeconomic incentives to prevent malicious behavior among validators.

Type of sidechain

EVM-Compatible and Non-EVM Sidechains: EVM-compatible sidechains use a custom implementation of the Ethereum Virtual Machine, an execution environment for deploying smart contracts on Ethereum. In fact, most of these blockchains were initially forked from go-ethereum (also known as Geth, the most popular implementation of the ethereum protocol).

While retaining most of the features of Ethereum's design (such as support for smart contracts), EVM-compatible sidechains are optimized in other aspects, especially the consensus mechanism, to improve execution efficiency and throughput. Today, EVM-compatible sidechains run most 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 (such as Truffle, Remix, Hardhat), and may need to learn other 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 side chains: Not every side chain relies entirely on its own security; some side chains, notably commit chains and optimistic chains, rely on the main chain to provide certain security guarantees. A commit chain periodically submits cryptographic commitments (such as block headers) to another blockchain to update its latest state. The main chain cannot verify these proofs of state because it does not have access to the state of the side chain, but it ensures that honest participants can challenge invalid block headers before they are confirmed.

Typically, this is done by implementing a smart contract on the main chain that handles rewards, staking, rotation, and penalties for sidechain validators. If a validator commits a provable violation (such as signing two blocks at the same height), anyone can submit the proof to the smart contract and slash that validator's stake.

The Optimistic chain works similarly, requiring validators to periodically submit block headers to a smart contract on the main chain. However, the Optimistic chain has no separate consensus mechanism - block headers are simply assumed to be valid until challenged by fraud prevention. Thus, an Optimistic chain can operate with only one (honest) validator, whereas a commit sidechain requires multiple validators to function properly.

In both cases, honest actors can prove to the parent blockchain that malicious behavior occurred on the sidechain. In this way, even if most of the verifiers of the side chain are evil, users can still obtain a certain security guarantee.

But it is important to note that honest actors cannot prove malicious behavior without access to the state data stored in the block. However, since the main chain only receives block headers (not block bodies) from sidechains, it cannot guarantee block availability. This allows dishonest block proposers to hide block data for dishonest actions such as stealing funds from cross-chain bridges.

This problem is known as the data availability problem, and it is at the heart of the differences in the security properties of all sidechains (not just commit chains, optimistic sidechains, and Rollups).

**What is Rollup? **

Rollup improves the scalability of the underlying blockchain by processing transactions in a separate execution environment. Similar to sidechains, Rollups have a cross-chain bridge for transferring assets between the parent blockchain and Rollup. They also implement optimizations to increase computing speed and cost-effectiveness for users.

However, Rollup will periodically submit blocks to the main chain, thus inheriting the security and decentralization characteristics of the main chain. This means that the parent blockchain provides Rollup with guarantees of the following security properties:

1. Availability: The availability of Rollup blocks is guaranteed because the data is stored on the more decentralized and secure parent network. For example, users can always attest to cross-chain bridge contracts details of the Rollup state (such as owning certain tokens) and withdraw funds while Rollup validators hide transaction data.
2. Validity: Only Rollup blocks that meet the validity conditions enforced by the parent chain can be finalized.
3. survivability: Since Rollup data is stored on the base layer, anyone can reconstruct the last valid state of Rollup and generate new blocks. Additionally, users can enforce inclusion of a transaction in a Rollup by sending it to the Rollup's on-chain smart contract.

Rollup type

Rollup has two forms: Optimistic and zero-knowledge. Zero-knowledge rollups (also known as validity rollups) submit blocks to the parent chain along with proofs to confirm the correct execution of off-chain transactions. If the proof is verified on-chain, the block will be finalized on the base layer.

The blocks submitted by Optimistic Rollup do not have any proof to prove the validity of off-chain calculations. Blocks are simply assumed to be valid unless the outcome of a transaction is challenged by another party via a "fraud proof". The fraud proof takes the form of a verification game. With the intervention of the parent chain, two parties dispute a calculation until the dishonest party is found.

Optimistic rollups are named after the Optimistic assumptions that most of the state transitions are valid. However, this optimistic assumption combined with cryptoeconomic incentives guarantees that unless an invalid block goes unchallenged for a long time, it will never be finalized by the main chain.

Note: Arbitrum and Optimism are examples of Optimistic rollups.

EVM compatibility is another noteworthy difference between Optimistic and Zero-Knowledge Rollups. While Optimistic Rollups are EVM compliant, Zero-Knowledge Rollups differ in EVM compatibility. Since proving native EVM instructions in a proof circuit is complex and resource intensive, some effectiveness rollups use custom virtual machine instruction sets optimized for more efficient proofs.

For EVM-compatible ZK-Rollup, we describe its execution environment as "Zero-Knowledge EVM" (ZK-EVM). ZK-EVM can execute Ethereum smart contracts off-chain and prove that all parts of the computation were executed correctly. Therefore, ZK-Rollup is considered to be more secure than Optimistic Rollup, which relies on cryptoeconomic incentives and honesty assumptions to prevent invalid execution.

Linea is an example of a second-layer effectiveness 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 such as StarkNet requires (a) building smart contracts with a different stack, or (b) modifying the code base to run in the StarkNet virtual machine.

**How is sidechain different from Rollup? **

Throughput: Sidechains typically have higher average transaction throughput than Rollups because they do not depend on the mainchain's consensus and data availability. For example, sidechains can achieve large block sizes and extremely fast block times for higher throughput, which Rollup cannot do.

Rollup must avoid processing so many transactions that batches of transactions cannot fit in a single main chain block. Otherwise, this would reintroduce congestion at the base layer and make it difficult to keep up with the blocks produced by the Rollup. Thus, Rollup's parent chain data bandwidth imposes an effective limit on its throughput.

Even sidechains that partially rely on the security of the main chain (such as commit chains and optimistic chains) still outperform Rollup in throughput.

Cost: Compared with Rollup, users may pay less fees for transactions on the side chain. As with other differences between sidechains and Rollups, this one has to do with Rollups' reliance on the parent chain for settlement and finality. Here are some of the operating costs incurred by Rollup (these costs are borne by the user):

• Data Storage: Committing a Rollup block to the base layer incurs a fixed cost (the cost of including the transaction in the block) and a variable cost (based on the size of the Rollup block). As a result, Rollup charges users for computation and data, and transactions with larger data volumes pay more, and vice versa.
• Proof generation and verification: Zero-knowledge Rollup needs to generate validity proofs for the verification of the base layer, which will incur additional costs. Verifying the validity proof requires a lot of resources, for example, the current cost on Ethereum is about 500,000 Gas.

Pure sidechains do not incur the above costs, so using them is less expensive. Committing chains or Optimistic sidechains may incur some additional costs, such as submitting block headers, but these costs are negligible. Additionally, costs can be reduced by accumulating multiple block headers in a single transaction.

Finality: A sidechain that is fully responsible for its security has instant finality, where a block cannot be revoked once it has been approved by a majority of validators. However, commit chains or optimistic sidechains do not apply to this rule, as they must account for challenges that may delay block header finalization.

Typically, Rollups have longer finality times than pure sidechains, for various reasons. For example, Optimistic Rollup delays the confirmation of transactions to ensure that honest participants have enough time to challenge invalid state updates.

Validity Rollups have instant finality (once verified), but have a longer finality time than pure sidechains. Due to the high cost of generating and verifying proofs of validity, serializers prefer to accumulate a large number of transactions before generating and submitting proofs of validity for a batch.

Security: The security of Rollup (Optimistic or zero-knowledge) is guaranteed by the underlying blockchain, reducing user trust assumptions. As explained earlier, Rollup relies on the (economically secure) mainchain for consensus and data availability (unlike sidechains). This reduces the risk of censorship, frozen withdrawals, invalid execution, etc.

Pure sidechains are responsible for their security. However, starting diverse and reliable validators can be difficult, which is why sidechains are considered less secure than Rollups.

Commit chains and Optimistic sidechains are slightly more secure than pure sidechains, but users must trust the data availability of validators and proposers. In the event of a data hiding attack without penalty, the commit chain and the Optimistic sidechain will have no security guarantees.

Cross-chain bridge: Rollups and sidechains (for the most part) use the same asset bridging scheme: lock X tokens in a smart contract on the main chain, and mint X tokens for users on the child chain. They differ in how the funds deposited in the bridge contract are secured.

Since Rollups are specific to a particular base layer blockchain, there is usually a "canonical bridge" connecting the two. Funds deposited into the Rollup bridge are secured by the parent chain:

• Funds deposited into a Validity Rollup can only be withdrawn after verifying that the proofs associated with the batch containing the exit transaction are verified on-chain.
• For Optimistic Rollup, users can only withdraw funds if the block containing the user's withdrawal transaction has not been challenged after the end of the dispute window (approx. 1-2 weeks).

Instead, the security of funds deposited into a sidechain bridge depends on its design. For example, if the sidechain has a canonical cross-chain bridge with another blockchain, then the security of the bridge funds is related to how honest the validators are. Another issue is whether the bridge is validated by an entire validator (e.g., the Polygon PoS bridge) or a small set of external validators (e.g., the Avalanche-Ethereum bridge).

The difference in finality time between Rollup and sidechain bridging also explains the difference between them. For example, Optimistic Rollup users will experience more delays when bridging funds back to the main chain due to the need to wait for the dispute window. With a sidechain, users can withdraw funds from the cross-chain bridge contract once the finalized block header (and, if necessary, a valid Merkle proof) has been received.

Choose between Rollup and Sidechain

When deploying smart contracts, the choice between using Rollups or sidechains depends on your goals, user feedback, and project needs. Here are the advantages of using Rollups, sidechains, or both in different situations.

When to use Rollup:

1. Your users expect the highest level of security.
2. Your users can tolerate slightly higher cost and increased latency/finality. Rollups are much cheaper and faster (orders of magnitude) than Ethereum, but cannot match sidechains on these metrics.
3. You (or your users) want a closer relationship with the parent chain ecosystem (e.g. Ethereum).
4. You plan to improve the user experience for DApp users on Rollup. This could mean using liquidity providers to reduce latency in withdrawing funds from an Optimistic Rollup, or implementing code optimizations to reduce the amount of transaction data generated when users interact with your smart contract.
5. 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 sidechains:

1. Your users want to transact with the lowest fees.
2. Your users expect transactions to be processed quickly, especially when bridging funds.
3. Your users can tolerate increased trust assumptions and lower security assurances.
4. You (or your users) do not consider a strong relationship with the main chain ecosystem to be a priority.
5. You can learn to use a new set of programming languages, tools and infrastructure to build DApps (if using non-EVM sidechains).

When to use Sidechain and Rollup at the same time:

1. Your project has established a strong network effect on one blockchain and is ready to scale to multiple ecosystems simultaneously (for example, to leverage liquidity).
2. You want to cater to different types of users and avoid alienating one side of the market.
3. Your project has enough resources to handle cross-chain scaling. This may mean having different teams responsible for deploying your DApp on different blockchain platforms.