Validity Rollups: The Best Choice for Ethereum Scaling

Validity Rollups (also known as zk-rollups) are considered the most promising solution for enhancing Ethereum's processing capability in a secure and decentralized manner. The core of this scaling solution lies in the use of validity proofs for verifiable computation. Its operation is as follows:

Operators move transaction processing to an off-chain environment (known as Layer 2), rather than processing each transaction on the Ethereum mainnet. After processing a large number of transactions, the Layer 2 operator returns the results to be applied to the Ethereum state while providing a validity proof of the off-chain execution integrity. This proof guarantees the validity of all transactions in the batch and is automatically verified by an on-chain validator contract. This allows Ethereum to apply the results to its own state.

It is worth noting that Validity Rollups are often inaccurately referred to as zero-knowledge rollups, but this is not correct. Most Validity Rollups neither use ZKP nor are used to ensure privacy. Therefore, the term "Validity Rollup" is more accurate.

Off-chain Virtual Machine

Before delving into the discussion, we need to understand the concept of a virtual machine (VM). In short, a VM is an environment that can run programs, just like running the Windows operating system on a Mac. It transitions between different states after performing calculations on certain inputs. The Ethereum Virtual Machine (EVM) is the VM that runs Ethereum smart contracts.

Zero-Knowledge Virtual Machine (zkVM) is a program execution environment that can generate easily verifiable validity proofs to demonstrate that a program has been executed correctly. The term "zkEVM" typically refers to a summary that leverages the Ethereum Virtual Machine (EVM) and is capable of proving the execution of the EVM. This term can be misleading, as the EVM itself does not generate these proofs; rather, the proofs are generated by a separate proof mechanism that starts with the results of the EVM execution. Furthermore, these proofs primarily focus on validity rather than privacy, so they are not strictly zero-knowledge proofs.

Although all Validity Rollups aim to utilize validity proofs to scale Ethereum, they differ in their choice of VM for executing off-chain transactions. Many Validity Rollups choose to replicate the design of the EVM (thus referred to as "zkEVM rollups"), attempting to replicate the Ethereum experience on an L2 rollup. Starknet, on the other hand, uses a new VM - Cairo VM (CVM), specifically designed to optimize the efficiency of validity proofs.

Both methods have their pros and cons: zkEVM trades performance for Ethereum compatibility, while Cairo VM prioritizes performance over compatibility, focusing on scalability.

zkEVM Approach

zkEVM aims to fully bring the Ethereum experience to Layer-2 blockchains. Its goal is to replicate the Ethereum developer environment within the aggregation. With zkEVM, developers can write smart contracts or port them to more scalable solutions without changing their code or giving up existing EVM tools and smart contracts.

However, one major drawback of this approach is that it limits the scalability potential of validity proofs. Since zkEVM is committed to being compatible with Ethereum, it is slower and consumes more resources. Unlike CVM, EVM was not designed with proof efficiency in mind. This limits optimization measures that could improve efficiency and scalability, ultimately affecting the overall performance of the system.

The Proving Challenge of EVM

The core challenge faced by zkEVM methods stems from the original design of the EVM—it was not designed to operate within a validity proof environment. Therefore, efforts to replicate its functionality cannot fully leverage the potential of validity proofs, resulting in inefficiencies. This low efficiency ultimately hampers the overall performance of the system. The compatibility of the EVM with validity proofs is hindered by the following factors:

1. The EVM adopts a stack-based model, while validity proofs are better suited for a register-based model. The stack characteristics of the EVM make it more difficult to prove the correctness of its execution and to provide direct support for its native toolchain.

2. Ethereum's storage layout heavily relies on Keccak and large Merkle Patricia Trees, both of which are detrimental to validity proofs and add a significant proof burden. For example, Keccak runs very fast on x86 architecture but requires 90k steps to prove. In contrast, Pedersen (a zk-friendly hash function) only requires 32 steps.

Therefore, various zkEVMs provide different levels of support for Ethereum tools - the higher the compatibility of zkEVM with Ethereum, the worse the performance.

Cairo-VM Methods

Unlike zkEVM, which invests a lot of development time in "adapting EVM to Validity Rollups", there is another option: using a brand new dedicated virtual machine and adding support for Ethereum tools as an additional layer on top of it. This is exactly the approach taken by Starknet, a permissionless Validity Rollup launched in November 2021. Starknet is the first Validity Rollup to provide a general smart contract platform on a fully composable network.

Starknet uses Cairo-VM (CVM), which is a high-level language of the same name. Cairo-VM is specifically designed to efficiently generate validity proofs for program execution.

The use of Cairo (virtual machine and language) provides the following advantages:

1. Optimized Proof of Validity - Each instruction has a valid algebraic representation.
2. A class Rust language used for writing provable programs
3. The intermediate representation (Sierra) between advanced Cairo and Cairo assembly (VM instructions) allows for efficient execution of Cairo code.

Developing a new language allows for customization based on specific needs and equipping it with features that meet previously unmet requirements.

Cairo and Encoding Diversification

Starknet encourages innovation, which is reflected in its diverse coding approaches. Cairo's ability to achieve optimal scalability using STARKs is not limited to developers who write contracts directly in Cairo. Developers can choose the approach that best suits them:

1. Write code natively in Cairo: With the release of Cairo 1.0, developers can now use an ergonomic and safe Rust-like language.

2. Solidity Compatibility: Solidity developers can write code that is usable by the Cairo VM. This approach provides a development experience similar to Ethereum and makes Solidity smart contracts portable to Starknet. There are two implementation methods:

   • Transpilation: Use the Warp Transpiler to convert Solidity code to Cairo.
   • zkEVM on Starknet: Using Kakarot, a zkEVM written in Cairo, to run Ethereum smart contracts on Starknet.

Despite its short existence, Cairo has become the fourth most popular smart contract language in terms of TVL and has received over $350 million in funding support.

Summary

zkEVM aims to replicate the Ethereum environment as a rollup, allowing developers to use familiar Ethereum tools. However, this approach limits the potential of validity proofs and may consume significant resources.

Cairo VM is designed specifically for validity proof systems and is not constrained by the EVM. It is supported by a new, secure, and ergonomic Rust-like programming language, Cairo 1.0, forming a powerful tool aimed at maximizing Ethereum's scalability efficiency through the use of STARK proofs.

The continuous progress of Cairo, the growth of diverse development options such as Kakarot zkEVM and Warp, is exciting. As Starknet dApps enter the production phase, showcasing the powerful capabilities of Cairo, it is believed that it will be used for more ambitious projects in the future.

Thanks to the various pathways of STARK scaling and the potential new methods that may emerge in the coming months, developers now have unprecedented control over blockchain scaling.