Overview of zkEVM Solutions: A Brief Analysis of zkSync, StarkNet, Polygon zkEVM, and Scroll
TechFlow Selected TechFlow Selected
Overview of zkEVM Solutions: A Brief Analysis of zkSync, StarkNet, Polygon zkEVM, and Scroll
The progress made in zkEVM design is noteworthy, and 2023 could be the decisive year for this technology.
Navigating Web3 tides with focused insights
Author: Filippo Armani
Translated by: TechFlow
ZK Rollups, also known as validity rollups, represent a revolutionary approach to Ethereum scaling that enables transactions to be processed off-chain and then aggregated into a single compressed transaction on the main chain. This process increases transaction throughput and reduces fees while preserving the security and decentralization of the main chain.
One of the defining features of ZK Rollups is their use of zero-knowledge proofs (ZKP), a type of cryptographic proof that allows a prover to convince a verifier that a statement is true without revealing any additional information.
For ZK Rollups, ZKPs ensure the integrity of off-chain transactions, enabling provers to demonstrate the validity of batches of transactions without disclosing specific details or requiring verifiers to re-execute all transactions before accepting a new state.
Compared to Optimistic Rollups, ZK Rollups offer a higher level of security because they introduce no additional trust assumptions atop Ethereum, relying instead on Ethereum itself and mathematical guarantees for security. Optimistic Rollups depend on game theory and an assumption that at least one honest node (the 1/n assumption) will challenge fraudulent transactions in each batch.
In contrast, operators of ZK Rollups—known as sequencers and provers—have no opportunity to compromise user funds, as their role is "merely" to collect transaction batches and generate ZK proofs. User funds remain secured on Ethereum L1, which ultimately validates the ZK proofs submitted by the L2 and finalizes the underlying transactions.
Validity proofs are generated through complex polynomial computations over state data. If the state data is invalid, a valid proof cannot be created. Validators on L1 input the state data to verify the correctness of the proof; thus, if a prover alters the state data, the validator will reject the proof.
Compared to Optimistic Rollups, ZK Rollups also offer two key advantages: faster finality and more efficient data availability.
First, they enable faster finality. Transactions are considered confirmed on Ethereum as soon as a validity proof is provided. In contrast, Optimistic Rollups require a one-week challenge period before transactions are deemed final and legitimate.
Second, ZK Rollups are more efficient in terms of data availability. They only need to publish state differences, since there is no need to reconstruct every transaction for verification. In contrast, Optimistic Rollups must publish full transaction data so anyone can re-execute transactions and potentially challenge them.
As a result, ZK Rollups consume less data bandwidth on Ethereum—a scarce resource shared by all rollups regardless of their execution system, including ZK circuits—potentially enabling even lower (or even zero) user fees.
ZK rollups are widely regarded as the ultimate solution for Ethereum scalability. However, implementing them is challenging because the Ethereum Virtual Machine (EVM) was not originally designed to support ZK circuits. To address this, many organizations and researchers have attempted to create a rollup-supporting virtual machine called zkEVM, capable of executing smart contracts in a way compatible with zero-knowledge proof computation.
Vitalik’s Four Categories of zkEVM
In his blog post, Vitalik outlined four types of zkEVMs based on their degree of compatibility with Ethereum.
It should be noted that:
The closer a zkEVM is to Ethereum functionality, the slower and more costly ZK proof generation becomes.
On the other hand, the more closely a blockchain or rollup adheres to Ethereum's specifications and standards, the easier it is for developers to build applications and integrate into the Ethereum ecosystem.
In short, blockchains with high Ethereum compatibility may hold a competitive edge.
Type 1: Fully equivalent to Ethereum zk rollups precisely replicate Ethereum across all aspects—including hashes, state trees, transaction trees, precompiles, and all consensus logic. So far, no zkEVM has achieved full equivalence with Ethereum.
Type 2: Fully EVM-equivalent zk rollups aim for EVM equivalence but are not fully equivalent to Ethereum. They are fully compatible with existing applications but make minor modifications to Ethereum to simplify development and accelerate proof generation. Scroll and Polygon zkEVM theoretically belong to this category; in practice, they currently fall into the third group.
Type 3: Nearly EVM-equivalent, sacrificing some components and equivalence to speed up proof generation. Polygon zkEVM and Scroll currently belong to this category. This category often serves as a stepping stone toward Type 2.
Type 4: High-level language equivalent, meaning they accept smart contracts written in Solidity and then compile them into another custom, zk-friendly language. zkSync and StarkNet fall into this category, although zkSync may gradually add compatibility with EVM bytecode and eventually move toward higher equivalence over time.
While Vitalik’s classification is currently the most popular and balanced, other classification frameworks exist.
Immutable’s Four Categories
Immutable, a StarkWare-based Layer 2 focused on NFTs, offered the following useful classification in one of its blog posts:
Compared to Vitalik’s taxonomy, this framework more clearly categorizes existing zkEVMs based on the specific layer of the stack (high-level language, bytecode, or runtime environment) where they achieve compatibility or equivalence with Ethereum.
Solidity Compatible: Compatibility with Ethereum is achieved at the high-level language layer (Solidity), meaning developers can continue writing smart contracts using familiar tools. However, these rollups immediately translate Solidity into an intermediate representation, compile it into custom bytecode, and execute it in a custom environment. Specifically, these L2s use transpilers to convert Solidity code into readable code for their custom VMs (Cairo for StarkWare, LLVM-IR for zkSync). These transpilers do not support certain Solidity features, so developers may need to adjust their contracts. Examples: zkSync and StarkNet.
EVM Compatible: At the language level, these rollups are EVM-compatible but use their own bytecode. Solidity compiles directly into EVM opcodes/bytecode, which is then converted into custom bytecode before execution in a custom VM runtime. These rollups are compatible with most Ethereum dApps, though some may require rewriting. Additionally, certain bytecode features (e.g., precompiles) are unsupported. Example: Polygon zkEVM.
EVM Equivalent: These rollups create a zk-proof circuit that can directly interpret EVM opcodes and bytecode, even though the underlying VM differs from the EVM. They are fully compatible with existing applications but may include minor modifications to simplify development and accelerate proof generation. Example: Scroll.
Ethereum Equivalent: This means replicating Ethereum across all components, similar to what Polygon aims to do. No zk rollup currently falls into this category.
Combining this framework with Immutable’s and adding further insights yields the following diagram, highlighting key design differences and similarities among various zkEVM implementations—especially relevant in the absence of performance benchmarks:
zkSync 2.0
zkSync 2.0 (recently renamed zkSync Era prior to mainnet launch) is a scaling solution for the Ethereum network, fully compatible with the Solidity programming language. With zkSync, users can choose between two data availability modes: zkSync Rollup and zkSync Porter. The former publishes data directly on Ethereum, ensuring security equivalent to Ethereum L1, while the latter stores data off-chain, resulting in faster transactions and lower costs at the expense of reduced security.
zkSync is EVM-compatible because it converts Solidity smart contract code into Yul, then into LLVM-IR, and finally recompiles it into a custom set of circuit-compatible bytecode designed specifically for zkSync. While this involves intermediate steps, it also enables non-EVM features such as Account Abstraction. Matter Labs, the company behind zkSync, plans to gradually improve compatibility with Ethereum tooling and is preparing to launch the first prototype of its three-layer scaling solution, zkSync Opportunity, as part of its broader ambitions, initially on testnet.
At the time of writing, zkSync Era has just launched, so it is too early to assess its performance. zkSync 1.0 (now called zkSync Lite), which supports only simple transfers, is one of the largest zk rollups by volume, with over $83 million in TVL and more than 19 million cumulative transactions. In comparison, StarkNet has a TVL of just over $19 million and around 4 million transactions.
StarkNet
StarkNet is a Type 4 / Solidity-compatible zk-rollup that uses a different kind of zero-knowledge proof called STARKs (Scalable Transparent ARguments of Knowledge) to ensure the integrity of off-chain transactions. STARKs are considered more efficient and scalable than SNARKs, though they may require more complex technical setups.
Although StarkNet supports smart contracts, its capabilities are relatively limited due to the use of STARKs and the fact that both StarkNet contracts and the StarkNet OS are written in Cairo. To ease development, StarkWare recently upgraded to Cairo 1.0, which mimics Rust. Like zkSync Era, StarkNet can be classified as “Solidity-compatible” because it does not execute programs within the EVM but instead creates a completely new, purpose-built VM using custom bytecode. StarkWare uses the Warp transpiler to convert Solidity code into Cairo VM bytecode.
However, unlike zkSync Era and other zkEVM implementations, the StarkNet team does not aim for compatibility with the EVM or other Ethereum components. Instead, they focus on maximizing the efficiency of StarkNet’s VM through a custom client API, JavaScript libraries, and wallet systems—requiring Ethereum-compatible tools to manually add StarkNet support. Although Cairo 1.0 introduced Sierra, a secure intermediate representation between Cairo 1.0 and Cairo bytecode, the Warp transpiler still lacks support for certain Solidity features and remains far from matching zkSync Era’s level of EVM compatibility.
Polygon zkEVM
Polygon zkEVM is a zk-rollup that uses a custom language, zkASM, to interpret zkEVM code and validate smart contract execution in a non-EVM runtime environment. The project began in 2021 when Polygon acquired Hermez Network for $250 million to develop an EVM-equivalent system combining the security of STARKs with the efficiency of SNARKs. While STARKs are used to generate validity proofs for transaction states, SNARKs are employed to verify the correctness of STARK proofs. This hybrid approach delivers security, speed, and low transaction fees.
In July 2022, Polygon announced the rebranding of Polygon Hermez to Polygon zkEVM, which has just launched at the time of writing. The latest testnet version of Polygon zkEVM introduces recursive proving, allowing one ZK validity proof to verify other ZK proof batches, each validating multiple transactions. This functionality leverages Plonky2, a recursive SNARK that is 100 times faster than existing alternatives and natively compatible with Ethereum.
Beyond Polygon zkEVM, Polygon has developed Polygon Avail, a blockchain optimized solely for data availability. The network will be permissionless, allowing anyone to join as a validator—unlike existing DACs (Data Availability Committees), which rely on a small number of nodes. Avail will work in tandem with Polygon Hermez (a rollup), receiving state data from Hermez rather than publishing directly to Ethereum, offering a middle ground between Validium and Rollup.
Although some experts argue that Polygon’s current specifications better fit the description of EVM compatibility, the team is actively working toward creating the first fully EVM-equivalent solution.
Scroll
Scroll is an EVM-equivalent zk-rollup developed by the Scroll team in collaboration with the Ethereum Foundation’s Privacy and Scaling Explorations (PSE) group. Currently in the Pre-Alpha testnet phase, it aims for full bytecode-level compatibility with the Ethereum Virtual Machine (EVM). This means developers can use any EVM-compatible language to write and deploy smart contracts on Scroll. Although Scroll does not yet support EVM opcodes, it plans to implement a 1:1 opcode mapping and accept EVM opcodes directly without compiler intervention.
Scroll’s architecture includes a centralized sequencing node and a decentralized proving network. The centralized sequencer orders transactions, creates blocks, and submits transaction data as calldata to the rollup contract on Ethereum for data availability. Scroll plans to gradually decentralize the sequencer. On the other hand, a decentralized network of proof generators called "Rollers" produces and submits proofs to L1, leveraging distributed computing power. Rollers are selected randomly and can generate proofs for different blocks in parallel to increase speed.
*Note: While only on-chain data availability is currently supported, Scroll’s original design also includes a Validium mode.
Indeed, both Scroll and Polygon adopt a bytecode-level approach to building their zkEVMs. This approach completely eliminates the transpilation step, meaning these zkEVMs do not convert Solidity code into another language before compilation and interpretation. However, while Scroll differs from Ethereum only in its runtime environment, Polygon created a custom VM, optimized it, and then translated EVM bytecode into that VM’s bytecode. Unlike Scroll, Polygon’s runtime (“zkExecutor”) executes custom “zkASM” opcodes (micro-opcodes in the diagram) instead of native EVM opcodes, optimizing EVM interpretation by reducing constraints rather than directly proving EVM operations. As a result, Polygon zkEVM may not be fully compatible with 100% of Solidity code, tools, and applications, though most should work.
While these are the most prominent projects focused on general-purpose zkEVM implementations, other application-specific projects are already using zk technology in practice.
Loopring is an application-specific zk-rollup supporting decentralized exchange (DEX) protocols. It also provides a platform for anyone to build DEXs using zk proofs. Immutable X is another application-specific zk-rollup built on StarkWare, designed for NFT trading and gaming. Aztec is a privacy-first Ethereum-based zk-rollup that encrypts data to maintain protocol transparency and data availability while protecting user privacy. Aztec also invented the PLONK proof system, now used by zkSync and other projects.
Multiple protocols—including Immutable X, Sorare, rhino.fi, ApeX, and dYdX—are built on StarkEx. Projects using StarkEx ZK-Rollup send data as calldata to Ethereum and publish it on-chain. In Validium mode, data is stored off-chain, with only hashes stored on-chain. While Rollup mode ensures higher security (users can reconstruct ledger state by interacting solely with Ethereum), Validium mode offers lower costs and greater privacy.
Overall, while zkSync Lite is the largest zk rollup by transaction volume, StarkWare boasts the largest ecosystem, including projects built on StarkEx, and holds the highest TVL and market share.
Conclusion
In summary, zk-rollups are a promising solution for scaling blockchain networks, with diverse implementations catering to different needs and requirements. While several classification systems exist, it’s important to note that they are approximate and lack consensus on precise definitions and technical distinctions.
As Scroll co-founder Sandy Peng acknowledged: “There is no definition that achieves clear consensus. The entire research team at Scroll leans toward a particular narrative or perspective, but it’s not definitive. Even our research team doesn’t agree on the meaning of everything.”
Nonetheless, several common trends are emerging among zk rollup implementations:
First, they appear to adopt a hybrid approach to data availability, offering both a traditional on-chain rollup version and an off-chain data storage Validium version. As Anurag Arjun, CEO of Avail, told Blockworks: “In my view, you’ll find that every rollup will have a rollup version and a validium version.”
Second, most delay open-sourcing their code until after deployment, partly due to intense competition from optimistic rollups like Arbitrum and Optimism. Zk-rollups promise greater efficiency but are technically harder to implement.
Moreover, as the table above clearly shows, optimistic rollups—especially Arbitrum—are benefiting from first-mover advantage and currently lead in applications, transaction volume, and market share. If successful, optimistic rollups could integrate validity proofs into their established user bases (e.g., Optimism’s Bedrock upgrade may introduce validity proofs).
Additionally, although all implementations start with centralized sequencers for efficiency, they are committed to gradual decentralization to address centralization concerns. Interestingly, decentralized sequencing may require native token incentives, suggesting all mentioned projects will likely take this step.
Finally, the remarkable progress made by these zkEVM implementations over the past year has sparked renewed interest in zk technology overall, with companies focusing on various fronts—including developing new zk hardware to accelerate proof generation.
Despite ongoing challenges, the advancements in zkEVM design over just over a year are impressive, and 2023 may well be the decisive year for this technology.
Join TechFlow official community to stay tuned
Telegram:https://t.me/TechFlowDaily
X (Twitter):https://x.com/TechFlowPost
X (Twitter) EN:https://x.com/BlockFlow_News
