Scaling The Ethereum Using Rollups-Layer 2
By Sumi Maria Abraham, Research and Development Engineer, Kerala Blockchain Academy
Over the past few years, we have witnessed an exponential increase in demand for Ethereum transactions, which has led to skyrocketing gas prices (increased transaction fees). Rollups offer a solution to perform transactions secured by blockchain at a lower cost. The basic idea strongly resembles the concept of shadow chains proposed by Vitalik Buterin in 2014.
What is a Rollup?
Rollup is an L2 scaling solution that extends the concept of sidechains. They help reduce the load of Ethereum by performing transaction executions on L2 (off-chain). Unlike the sidechain example which we discussed, rollups save certain data corresponding to each transaction on Ethereum. Rollups group transactions into batches, execute them off-chain and store some data related to each transaction on the main chain. Let’s find out more about rollups.
Rollup Vs Sidechain
Sidechains are secondary blockchains which occasionally communicate with the main chain (L1). Sidechains have independent consensus mechanisms and protocols; thus, Ethereum cannot guarantee the security of a sidechain. Whereas a rollup relies on the security of the L1 blockchain. It will function properly as long as the Ethereum is live. All transactions are
stored on the blockchain and executed off-chain by a central entity. Rollups group transactions into batches and compress them. It increases the throughput by reducing the size of each transaction and by removing the need for execution on L1. The verification part is done on the blockchain.
How do rollups work?
Let us see an example.
In the Ethereum network, transactions from an account can only occur sequentially. Alice wishes to transfer some tokens to Bob, Carol and David. She has to first transact with Bob, wait for it to be confirmed, next transact with Carol and so on. When she finishes the transactions, it will take approximately 36 seconds (assuming an optimal situation) or longer.
Rollups offer a solution to reduce the overall time and price to carry out these transactions by exempting Ethereum from doing the execution.
To understand this concept, let’s review what happens when a user submits a transaction.
Ethereum maintains the state of the blockchain, which refers to the current balance held by each account (contract & user accounts), and current values assigned to the state variables in the contract. This data is represented using Merkle Patricia Tries, which are stored in Key-Value databases like LevelDB or CouchDB. A transaction is a request for state transition. When the transaction: Alice transfers 10 ETH to Bob is processed, Ethereum will check if Alice has enough amount to pay Bob, debits her account balance and credits Bob’s account. This will alter the data stored in the trie, which will generate a new root value.
Assume we have a rollup. Rollup will maintain a state that records the addresses and account states being handled by them. The state of a rollup is stored on the L1 chain by a rollup smart contract.
>> Alice will submit all three transactions to the rollup. Each transaction will require a state change.
>> The rollup will process the transactions into a batch (block). This will generate the new state root.
>> The compressed set of transaction batch, previous state root and current state root will be sent to the smart contract.
>> The rollup contract on the L1 checks if the previous state root in the batch matches its current state root. It will update the state root to the new value if it is a match.
How can Ethereum secure Rollups without executing the transactions in L1?
This is the factor which makes rollups different from a sidechain. Ethereum guarantees the genuineness of the state updates. This approval is represented in the form of proof. Rollups prove their correctness to Ethereum using particular proofs that allow Ethereum to verify the transaction processing without actually executing the transactions.
What is the role of the proof?
Rollups are categorized based on the nature of the proof.
Optimistic rollups such as Arbitrum and Optimism are based on fraud proofs. They follow an optimistic perspective and assume that transactions are valid unless someone challenges them. They post the updated state to Ethereum without posting any proof. Anyone can post a batch of transactions. To challenge it, one should execute the same transactions and submit a proof of incorrect computation called fraud-proof on the rollup smart contract. The contract will verify this. If incorrect computation is detected, that batch of transactions and subsequent batches will be reverted. The contract maintains a history of previous state root upgrades and the corresponding batch hashes. An incentive mechanism rewards the participating entities so that they are tempted to produce correct claims and challenge incorrect claims.
Zk Rollups(Zero-knowledge) submits a validity proof along with every batch of transactions. The validity proof is a cryptographic proof which proves the new root has been computed correctly from the submitted batch of transactions. This proof is checked by the contract. Zk-proof represents the mathematical certainty that whatever is posted on L1 is valid and occurred on the rollup. If the proof evaluates to true, the transaction can be considered final. StarkWare and Zksync are working on ZK-rollups in Ethereum.
Optimistic rollups are less expensive and suitable for general-purpose computations. Generally optimistic rollups are EVM-compatible. However, they have limited throughput. Though the proof computation is technically challenging and costly, zk rollups offer better data compression and faster finality. This makes zk rollups fit for financial applications. EVM compatibility of zk-rollups is an active research area.
The proofs ensure that even if the validators/operators of the rollup act wrongly, they cannot steal any funds since the ultimate security guarantees are derived from Ethereum.
How does rollup compress data?
Many fields typical to an Ethereum transaction can be omitted or represented in a storage-efficient way in rollup transactions. For example, every Ethereum transaction has a nonce value, which is incremented for every subsequent transaction of the sender. But a rollup transaction does not require a nonce value since it can be computed from the previous state. Another example is the recipient’s address. In rollups, the address is replaced by an index value much smaller.
A detailed review of storage savings can be found here.
Rollups try to replace data with computation wherever possible. They can reduce the overall size of a transaction to almost one-tenth of its Ethereum equivalent.
How can rollups reduce cost?
Batching multiple transactions together reduces overall transaction fees by
spreading fixed costs over all transactions within a given batch. The L2 operators also apply some compression techniques to minimize the data posted to Ethereum.
Rollups convey their state roots back to Ethereum using calldata for storage. Calldata is currently the cheapest form of storage on Ethereum.
Summing up
Rollups execute transactions “off-chain” from the main network (L1), batch (“rollup”) these transactions into a single block, and then send that block to the L1 as a single transaction. In short, thousands of transactions can be processed off-chain and represented by submitting a single transaction to the main network. In this way, rollups can significantly increase the scalability and throughput of the underlying L1 blockchain.
References
[1] Cosimo Sguanci, Roberto Spatafora, Andrea Mario Vergani, “Layer 2 Blockchain Scaling: a Survey”.
[2]Gangwal, Ankit & Gangavalli, Haripriya & Thirupathi, Apoorva. (2022). A Survey of Layer-Two Blockchain Protocols.
[3]https://ethereum.org/en/layer-2/
[4] https://vitalik.ca/general/2021/01/05/rollup.html
[5] https://www.preethikasireddy.com/post/a-normies-guide-to-rollups
Image Courtesy: https://www.flaticon.com/
