The Next Big Narrative: The Race to Scale Ethereum

Bixin Ventures
11 min readMay 25, 2022

In terms of market cap, Ethereum is the second largest blockchain after Bitcoin, and one of the reasons for its success can be attributed to the usability of decentralized applications(dApps). Despite the growth of alternative blockchain networks, a big amount of dApps exist exclusively on Ethereum. Ethereum currently boasts total value locked (TVL) of just over $80 billion, and dominates 64.16% of the entire DeFi market. This is roughly eight times as much as the preceding network, BSC. Projects benefit from a vast community of developers by using the Ethereum framework, amplifying the network effect. Ethereum has been one of the preferred blockchains for many development teams for a long time.

As the ecosystem continues to grow, Ethereum faces a huge challenge in terms of scalability: the average transaction or “gas” fee rose to as high as $63 in November 2021, just behind May’s record high of $70. People even needed to pay more than $100 to deposit money on the DeFi platforms or buy new non-fungible tokens (NFTs). The network congestion and high gas fee seriously hinder usage especially for newer users.

The Ethereum community foresaw the problem of scaling several years ago and has been exploring solutions. There are two ways to solve the scaling problem: one is to directly modify the underlying architecture (often called Layer 1) to scale Ethereum blocks, increasing the number of transactions verified per block to improve the throughput of the entire system, but this means that nodes need to be configured with better equipment, which may reduce number of nodes due to cost issues, eventually leading to a more centralized network.

Layer 2 Scaling Solutions

One of the reasons why the Ethereum community might not want to change the underlying layer is because it would sacrifice decentralization. An alternative way is to change the way that you would operate the blockchain: instead of putting all the operational information on the blockchain directly, users perform the bulk of their activity off-chain in a “Layer 2” protocol; the main chain only needs to process deposits and withdrawals, and verify proofs that everything happening off-chain is abiding by the rules. Since thousands of transactions are bundled up, this is equivalent to increasing the throughput of the entire Ethereum. Based on this idea, there are three major types of Layer 2 scaling options: state channels, Plasma and rollups.

State Channels and Plasma

Both channels and Plasma are “full” Layer 2 schemes. The channels’ users or representatives need to be constantly monitoring Layer 1 to be available for any challenges. Plasma has another data availability problem: when a transaction is made and the result is broadcast to the whole chain for confirmation, the node needs to make sure that the message does not contain a fake message or if it contains all the data — users need to trust the operators to make available all the transaction data required to verify correctness if/when required. If a user attempts to withdraw funds from a Plasma MVP chain, all exits can only be processed after the challenge period is over, which takes up to a week. Also, both channels and Plasma do not support smart contracts, which severely limits applications that require EVM compatibility.

Examples of state channels in Ethereum include Raiden, Celer Network, Connext, and statechannels. Plasma Cash is an important use case of Plasma, but it requires users to remain online at least once every two weeks to catch faulty withdrawals during their challenge periods, and it was not the Visa-scale solution Ethereum was promised. Most companies developing clients for Plasma Cash halted work, and their implementations were archived in a half-finished state. Besides Ethereum, there are many other cryptocurrencies currently working with Plasma, including OmiseGO and Loom Network.


Rollups take a compromise approach: it moves the computation (and full state storage) under the Ethereum chain, but keeps “partial” data for per transaction on-chain (for storage only, not execution), meaning that anyone can look at the “calldata” and get all the data on Layer 2 to perform operations including fraud detection, initiating withdrawals, generating batches, and so on.

In short, there are three properties of rollups:

● Transactions are executed outside of Layer 1 (reduces gas fees)

● Data and proof of transactions reside on Layer 1 (maintains security)

● A rollup smart contract, which is stored on Layer 1, can enforce proper transaction execution on Layer 2, by using the transaction data that is stored on Layer 1

Since storing data is lower than executing transactions in terms of gas, this equates to helping users reduce gas overhead and also increase the throughput of the entire network: according to data given by Vitalik Buterin, rollup consumes about 1/10th of the gas of mainnet transfer for an ETH transfer, thus users’ transaction costs are greatly reduced.

·An ETH transfer takes ~12 bytes on a rollup, but ~112 bytes on Ethereum mainnet

Since the tedious transaction execution process is placed on Layer 2, nodes need to know whether the post-state roots are correct after the batch execution is completed. This is because if someone submits a post-state root without consequences, they can transfer all the assets inside the rollup to themselves. This question is critical, and rollups are divided into two main families based on the way to verify whether the post-state roots are correct: Zero-Knowledge rollups (ZK rollups) and Optimistic rollups.

ZK Rollups

ZK rollups bundle thousands of transactions off the main Ethereum chain and create cryptographic proof which is known simply as SNARK (succinct non-interactive argument of knowledge). This is called validity proof, which is posted to the Ethereum main chain. Since only the proof is required — rather than all the transaction data — validating a block is faster and less expensive.

There are a handful of ZK-rollup solutions that are available for you to explore building with, including StarkNet, ZKSync, and Mina Protocol. Using ZK rollups, you can support a wide variety of functionalities for fungible tokens, NFTs, and dApps.

1. zkSync

zkSync, a programmable rollup that is used for low-cost payments on Ethereum mainnet, is a ZK-Rollup created by Matter Labs. It uses the zk system based on SNARKs certification (especially PLONK). Therefore, the entire security of the system relies on a set of trust settings (Multi-party Computation Ceremony).

zkSync took a big step on scaling Ethereum, and it first went into production during the summer of 2020. They officially announced 2.0 last year, it will expand on the current functionality and will be smart contract friendly (programmable). The most important part is that it will feature zkPorter mode, an off-chain data availability system with 2 orders of magnitude more scalability than rollups, which can increase scaling to 100,000+ TPS.

According to the data of L2BEAT, zkSync currently sits at a TVL of $79.73M, which is a respectable number, and the demand for zkSync seems to be growing fast.

2. StarkWare

StarkWare, the team that pioneered zero-knowledge-based rollups in 2018, launched the mainnet alpha of StarkNet on Nov 29 2021. StarkNet is very similar to zkSync in its approach to transaction validation and instant withdrawals. However, StarkNet uses ZK-STARK, which stands for Zero Knowledge, Scalable, Transparent, Argument Of Knowledge. This technology was invented by the StarkWare team and has two main advantages over SNARKs (the technology used by zkSync):

● “T” means that the system does not need to trust settings;

● The speed of generating STARKs certificates is 10 times faster than that of SNARKs.

The problem with STARKs is that their technology is not as mature as SNARKs. All of StarkNet’s smart contracts are written in StarkWare’s custom programming language: Cairo. It means that StarkWare does not natively support EVM. However, many teams like Nethermind’s Warp team, are developing a transpiler for Solidity to Cairo conversions.

As a solution that provides scalability and L1 security by using STARK-based validity proofs, StarkEx already supports major projects like: Immutable X, Deversifi, Sorare and dYdX.

StarkEx for Perpetual Trading

ZK rollups are already more mature with regard to ERC-20 token transfers, specialized or customized applications, but it will take a little longer to implement general-purpose smart contracts, and more research work is required to efficiently wrap EVM in zero-knowledge proofs. At a time when zkEVM will take some time to perfect, Optimistic rollups might have a first-mover advantage in the long-term competition with ZK rollups.

Optimistic Rollups

Optimistic rollups use fraud proofs (same as Plasma) to solve the problem, which is based on the premise that batches posted to rollup contracts are valid by default unless someone submits a fraud proof showing that the sequencer contains invalid or malicious transactions. To counteract the incentive for fraud, Optimistic rollups introduce a fidelity bond mechanism, where to become a sequencer, one must first deposit a bond on Ether and will lose it if they are proven to have committed fraud.

Optimistic rollups assume that users will report fraud, thus ensuring the integrity of the system, so another important parameter of it is to define a challenge period for (eg.) 7 days, waiting to see if someone makes a proof of fraud and thus cancels the invalid withdrawal request. In contrast to ZK rollups, Optimistic rollups’ purpose in setting a longer challenge period is to ensure financial security.

The main design choice around Optimistic rollups is how to resolve the dispute: suppose Alice asserts that a rollup will run to produce a certain result, but Bob disagrees, how should the protocol choose who submits the correct result? The approaches to this problem fall into two categories: interactive proving and single round fraud proofs, and this is the main difference between the two Layer 2 projects, Arbitrum and Optimism.

1. Arbitrum

Arbitrum is a Layer2 protocol developed by the OffChain Labs team, Arbitrum One is the current mainnet and updated Arbitrum Nitro is also live on Ethereum’s Görli testnet. Arbitrum utilizes Optimistic rollups to scale the Ethereum mainnet, so it uses fraud proofs and records all data of each transaction on mainnet as call data in order to guarantee the data availability.

For Optimistic rollups, when one sequencer submits a rollup block, other validators may have different opinions, leading to a dispute. How to resolve the dispute is the most important part in the design of the Optimistic rollups mechanism. Different Optimistic rollups protocols may choose different solutions and Arbitrum uses interactive proving to resolve disputes. The simplified version of this mechanism is that if Bob has a dispute over a certain rollup block proposed by Alice. Alice will divide her claim in half and post the state at the half-point and Bob has to point out which of the two half-size assertions is the disputed one.

This bisecting process will continue until Alice and Bob finally find the single step of execution they disagree with and Arbitrum protocol (more precisely EthBridge) will check the one-step proof and referee who is right. Interactive proving hopes nodes do as much off-chain work as possible to resolve their dispute, providing higher efficiencies and lower transaction fees at the same time.

The main actors in the Arbitrum protocol include nodes, validators and stakers. Similar to Ethereum nodes, Arbitrum nodes help users to interact with Arbiturm and anyone can choose to become a node. Nodes can choose to become validators at any time. Validators can continuously verify the execution results of new rollup blocks to ensure the new state is executed correctly. In addition, validators can choose to become stakers by depositing a certain amount of funds into Arbitrum’s EthBridge and only stakers can propose new rollup blocks. Stakers need to stake funds on the predecessor of the new block they want to create. If this new block is confirmed eventually, stakers can get back the pledged funds, otherwise they will lose their stake.

Arbitrum currently has the highest TVL among all Layer 2 projects due to its excellent EVM compatibility and low transaction fees. As of May 26, 2022, Arbitrum’s MAU is 216k and its TVL is $ 2.65B, accounting for 55.19% of the Layer 2 market. With the increasing number of TVL and users, more and more protocols are deploying on Arbitrum, including Uniswap, SushiSwap, Curve, 1inch, AAVE, Stargate, etc., further improving the user experience of Arbitrum and attracting more users to use Arbitrum in turn.

2. Optimism

Optimism is also a Layer 2 project that uses Optimistic rollups to scale the Ethereum mainnet. Optimism and Arbitrum have many similarities such as they both use fraud proofs and store all transaction data on Ethereum, but for the crucial dispute resolution mechanism, Optimism uses single round fraud proofs (re-execution) instead of Arbitrum’s multi-round fraud proofs (interactive proving) , when a dispute appears, all steps of execution in the rollup block will be re-executed to referee which of the disputing parties is right. But as the side-effect of the OVM 2.0 upgrade, the Optimism fraud proof mechanism is disabled temporarily and users must trust the execution results of the sequencer node run by Optimism PBC.

The main actors in the Optimism protocol are two types of nodes, sequencers and verifiers, whose functions are similar to that of stakers and validators in Arbitrum. Sequencers are responsible for processing transactions, constructing new rollup blocks, and submitting transaction data and new L2 state root to L1. Sequencers also need to stake a certain amount of funds. When sequencers fail in the dispute, the funds will be slashed. Verifiers are responsible for verifying the correctness of state commitment. When the malicious sequencers produce a wrong commitment, the verifiers can re-execute all transactions and challenge the execution result. If the challenge is successful, verifiers will get part of the funds staked by malicious sequencers.

Optimism’s MAU is 92.7k and its current TVL is $ 492M, with a market share of 10.24%, ranking second in the Optimistic rollups field and third in the entire Layer2 field. Many leading protocols have been deployed on Optimism, including Uniswap, Stargate, AAVE, Curve, Hop, etc. Optimism currently has the only sequencer run by the official and the fraud proof mechanism is temporarily unavailable, leading to a serious centralization issue. The team plans to implement sequencer rotation and multiple concurrent sequencers by introducing new economic and governance mechanisms in order to decentralize the Optimism protocol.


In the short term, Optimistic rollups have a certain first-mover advantage because they have achieved EVM compatibility and entered the market earlier than ZK rollups to obtain funds and users. In the long run, the long challenge period of Optimistic rollups will be solved by acceptors to improve user experience and composability across rollups; centralized sequencers currently operated by Arbitrum and Optimism teams could be decentralized by the participation of sequencers and validators run by users who attracted by these protocols’ subsequent economic stimulus.

We believe that, as a powerful Layer 2 scaling paradigm, Optimistic rollups and ZK rollups will jointly become the cornerstone of Ethereum’s future scaling.

Written By Mustafa Yilham & Jermaine Wong



Bixin Ventures

Established in 2017, focusing on venture capital in the area of blockchain