You are reading an excerpt from our free but shortened abridged report! While still packed with incredible research and data, for just $20/month you can upgrade to our FULL library of 50+ reports (including this one) and complete industry-leading analysis on the top crypto assets.
Becoming a Premium member means enjoying all the perks of a Basic membership PLUS:
- Full-length CORE Reports: More technical, in-depth research, actionable insights, and potential market alpha for serious crypto users
- Early access to future CORE ratings: Being early is sometimes just as important as being right!
- Premium Member CORE+ Reports: Coverage on the top issues pertaining to crypto users like bridge security, layer two solutions, DeFi plays, and more
- CORE report Audio playback: Don’t want to read? No problem! Listen on the go.
Overview of Zero-knowledge Rollups (ZK rollups)
Zero-knowledge rollups are Layer 2 scaling solutions that provide users with higher transaction speed, low gas fees, and similar security guarantees as Ethereum mainnet. ZK rollups achieve high scalability without compromising security by moving computation and state data off-chain while still posting a validity proof and minimum data to the Ethereum mainnet for final settlement. They send validity proofs to prove the validity of transactions and state changes.
How do Zero-Knowledge Rollups Work?
Zero-Knowledge Rollups TLDR
The process works as follows:
- Users of a ZKR approve transactions that are sent to the L2 ZKR operator, where they get ordered and batched
- Highly-compressed batches of transactions are combined with the current state root
- The combination is sent to an off-chain Prover
- Prover computes the transactions, generating a validity proof of the results
- Prover sends this to an on-chain Verifier (Ethereum nodes)
- Verifier confirms the validity proof
- Smart contract on Ethereum’s L1 that maintains the state of the rollup is updated to the new state
The Non-TL;DR Version
The conventional ZKR construction is built atop Ethereum mainnet and consists of two on-chain smart contracts: the "main" contract and a verifier contract. The main contract stores rollup blocks, monitors the state of the blockchain, and keeps track of deposits and withdrawals. The verifier contract verifies the ZKPs transmitted to Ethereum.
As stated previously, ZKRs are independent chains from Ethereum with their own execution environment/virtual machine. This independent virtual machine is not subjected to the same scalability limitations as mainnet Ethereum and thus provides the scalability benefits that Ethereum and its users seek.
With the two contracts in place and a proving system, you have the three critical components for a ZKR.
- The Execution Environment - This is where the smart contracts of the software execute. With ZK rollups, the execution environment is oftentimes different than the traditional Ethereum Virtual Machine (EVM). While some, like Scroll, Polygon, zkSync 2.0, etc., are working on a general-purpose zkEVM, current rollup implementations (StarkNet, Aztec, zkSync v1) have their own, distinct execution environments. This is where the output is a new state derived from the initial and current transaction.
- The Proving Circuit - With the proving circuit, transactions in the EM are validated with zero-knowledge proofs such as SNARKs, STARKs, POLNK, etc. Pre-state data, the transactions and execution, and post-state data are utilized by the circuit to complete the proof generation process. In this manner, the prover provides a simple proof of the state transition's veracity.
- The Verifier Contract - The verifier contract conducts calculations to the provided proof to verify that the outputs were accurately created from the inputs.
ZKRs can batch together thousands of off-chain transactions, execute the computation in their own virtual machine, and then post the batch to mainnet along with a “validity proof.” The validity proof is a cryptographic proof (called a “SNARK” or STARK) that has already computed the state of the L2 and is sent to mainnet for storage. Signed transactions are ordered and executed on the L2 by the operator on the rollup’s virtual machine.
The operator (mostly called sequencer) then aggregates many transactions using compression techniques into batches and submits the batches to Layer 1. The proof is far less data-heavy than if the L1 had to redo all the computation itself. The “batch” that’s rolled up is periodically posted to mainnet Ethereum and contains the net outcomes of many different transactions as they occurred on the rollup layer. This data is verified and updated by the rollup operator every time the L2 advances its state. Therefore, L2 execution and L1 data update in lockstep.
Currently, batches are sent to Layer 1 via calldata, but in 2023, EIP-4844 (proto-danksharding) will change this, making rollup transactions far cheaper. Learn more about EIP-4844 and other Ethereum future upgrades here.
The data posted to L1 includes:
- A Merkle tree of all transactions in a batch/block, including users’ balances, accounts, etc.
- A hash of the Merkle tree root for transactions that attest to the inclusion in the block
- The batch root, which contains the Merkle tree root of all transactions in a batch
- A set of intermediate state roots representing the state after the transaction
The ZK rollup smart contract on Layer 1 doesn’t automatically believe that the state root sent by the operator is valid. To prove the validity of the sent state root of Layer 2, the operator sends validity proofs, which prove the integrity of the state change of Layer 2 to the ZK rollup smart contract. Rollups use various validity rollups according to their requirements. Below you’ll read more about various types of validity proofs.
Notable Rollups using ZK Proofs for scalability
StarkNet
The Starkware team created StarkNet, a general-purpose ZK rollup already operational on Ethereum. They use Cairo as a smart contract programming language, which is inherent to StarkNet. StarkNet is one of the most feature-rich ZK rollups compared to other ZK rollups as it’s substantially different in every aspect from other ZK rollups.
To achieve significantly cheaper transaction fees than a non-volition-type rollup, StarkNet provides users with an optional off-chain data availability solution (making the rollup a volition). For gaming and social media applications, the volition model is best. The proving algorithm used by the StarkNet OS is also STARK-based.
Using its innovative STARK-based ZK technology, StarkWare provides users with a bespoke blockchain scaling solution known as “StarkEx.” StarkEx is a ZK rollup that's application-focused, as opposed to StarkNet. SoRare, Immutable, and DeversiFi are a few notable DeFi and NFT dApps that use StarkEx for increased scalability on Ethereum.
Polygon zkEVM
The Polygon team's zkEVM implementation achieves bytecode-level compatibility with the EVM. The open-source code for Polygon's zkEVM has just been made available to the public for evaluation and is scheduled to launch on Ethereum sometime in early 2023. The Polygon zkEVM testnet has already launched, and hundreds of dApps are already deployed.
The zkEVM implementation in Polygon uses STARK- and SNARK-based proofs. In particular, ZKSNARKs are employed to confirm the accuracy of zkSTARKs. This provides two major advantages to Polygon zkEVM, i.e., the quick proving times linked to zkSTARKs and the relatively low computing requirements needed to construct zkSNARKs.
zkSync 2.0
In December 2018, the blockchain development team Matter Labs was established. In June 2020, the team released zkSync, a custom ZK rollup protocol, on Ethereum.
By total value locked, zkSync is the seventh-largest L2 network on Ethereum. It offers several smart contract applications, such as limit orders, atomic swaps, and low gas transfers of ETH, ERC-20 tokens, and native NFTs.
zkSync 2.0 is made to handle various smart contract operations. The UltraPLONK SNARK-based proving algorithm underlies zkSync 2.0. Additionally, it uses the LLVM infrastructure, an open-source compiler, to translate Solidity and other programming languages into zkEVM bytecode.
Scroll
Another bytecode-level zkEVM implementation currently in development is Scroll. Sandy Peng, Ye Zhang, and Haichen Shen established Scroll in 2021. In 2022, they announced the launch of their pre-alpha testnet for whitelisted customers.
Notably, the whole codebase underlying their zkEVM implementation is open source and available to the public. Scroll won't enable an off-chain data availability solution and will instead rely on a specific SNARK-based proving algorithm.
The Scroll team is also developing a decentralized evidence-generation market to support its zkEVM. To do this, they’re concentrating on developing specialized hardware so users can generate ZKPs in a permissionless and censorship-resistant manner.
