31
The zkEVM is a technological innovation that seamlessly integrates zero-knowledge proofs and the Ethereum Virtual Machine (EVM), enabling the creation of zero-knowledge proof-based smart contracts that can be executed on the EVM. This allows for the development of ZK-Rollups that are not limited to specific applications, and can be utilized to build decentralized applications with greater scalability.
The fundamental goal of these projects is to utilize zero-knowledge succinct non-interactive arguments of knowledge (ZK-SNARK) technology to create cryptographic proofs of execution of Ethereum-like transactions, with the aim of either facilitating the verification of the Ethereum blockchain or constructing ZK-rollups that are equivalent to Ethereum, but with improved scalability. However, it's important to note that there are subtle distinctions between these projects and the trade-offs they make between practicality and speed.
Why zkEVM?
The compatibility of the Ethereum Virtual Machine (EVM) with ZK-Rollups technology is a spectrum, with trade-offs between high compatibility (easy to redeploy from Layer 1) and high performance (quick to generate ZK proofs). Generally speaking, the higher the compatibility with Layer 1, the lower the performance, and vice versa.
The zkEVM aims to address these limitations by providing a more EVM-compatible option for developers. It operates at the language level and makes use of zkPorter to increase its scalability, with the ability to reach up to 20,000 transactions per second (TPS). The zkSync 2.0 testnet is currently live, providing an opportunity for developers to explore and test the potential of zkEVM for their projects.
It's important to note that zkEVM has its own advantages and disadvantages. Its advantage includes faster prover time. However, its disadvantage is more incompatibility with EVM.
Overall, zkEVM offers a promising solution for scaling and improving the efficiency of blockchain transactions. It aims to overcome the limitations of ZK-Rollups technology and provide a more EVM-compatible option for developers.
zkEVMs are a significant advancement in the field of blockchain because they allow for ZK rollups to support a much broader range of applications than they currently can. The initial implementation of ZK rollups enabled basic operations on highly scalable and cost-efficient Layer 2s, such as sending ETH and transferring tokens. However, with the introduction of zkEVMs, developers can now write arbitrarily complex smart contract code and deploy it to ZK-powered Layer 2s.
One of the most significant benefits of zkEVMs is that developers can use the same Solidity code they are accustomed to using on Ethereum, making it easier for them to adopt and utilize ZK-rollup Layer 2s. This opens up a wide range of possibilities for the development of complex, composable, and customizable decentralized applications on ZK-rollup Layer 2s, similar to what we see on Ethereum.
Ethereum is a decentralized blockchain platform for building and running autonomous, Turing-complete smart contracts over a global network of permissionless nodes. The most popular implementation of the protocol (Geth) is written in , and the most widely-used smart contract language on the platform is
Solidity is designed to compile down to Ethereum Virtual Machine (EVM) bytecode, and it is currently the primary choice when coding smart contracts. Solidity has its problems, though, and other languages like for coding more secure and auditable smart contracts are on the rise. Despite this, Solidity’s syntactic similarity to JavaScript – one of the most popular programming languages in the world – affords it the unique advantage of having a less prohibitive learning curve compared to other languages.
Having Solidity become the de facto "standard" language for writing smart contracts enables more composability for dApps on Ethereum. Because smart contracts are deployed as open-source code in Solidity on Ethereum, anyone can build on top of these smart contracts by forking the code, incorporating their Solidity code, and creating an entirely new dApp.
What exactly is the EVM, though? In the context of Ethereum, a virtual machine is a software-based computing environment (consisting of Ethereum clients) that replicates the capabilities of a single computer but can be globally accessed. Any entity participating in the Ethereum network must run the EVM to compute state transitions. If all nodes run the same EVM (same rules), all nodes are aware of global state changes.
The EVM keeps state using a data structure known as a "Merkle Patricia tree." Merkle Trees are generated through multiple rounds of hashing. The initial data begins at the bottom (of the image) and is combined with the other data and hashed together to create the parent hash on the rung above. These hashes are pooled (of the same size) and hashed again until a single (root) node remains. A Merkle tree's aim is to enable Merkle proofs, which prove a piece of data exists in the underlying dataset without requiring the broadcasting of the complete dataset.
Merkle trees can store all key-value pairs for all Ethereum addresses. The keys relate to both public and smart contract addresses, and their respective values describe their current state.
For builders utilizing the EVM, composability means they can leverage one or more of the following:
- Ethereum's Social Graph: addresses are the same across EVM chains, meaning that any new project or chain can leverage the metadata associated with a user/address to solve cold-start problems
- Tooling and infrastructure: Some tools include Gnosis Safe, WalletConnect, Zerion, Metamask, and Etherscan. There are many open-source toolkits like OpenZeppelin, Hardhat, and Foundry
- Interoperability: Cross-chain governance, ERC-20 token trading identical address system, etc.
- 8 of the top 20 blockchain ecosystems are running EVM.
zkEVMs are EMV-compatible based on their ability to deploy smart contracts without modifying the underlying logic.
How do zkEVMs work?
The utilization of zkEVMs (zero-knowledge Ethereum Virtual Machines) has become increasingly important for blockchain scalability and cost-effectiveness. These EVMs allow for secure scalability by re-executing computations performed in the EVM, assuring safety but limiting the transaction speed to about 15 per second. With zkEVM-compatible rollups, the rate optimizes to over 2000 transactions per second without compromising security.
Zk roll-ups are also cost-effective by efficiently combining transaction data on Ethereum by omitting transactions and publishing only the final states, reducing the data requirements and costs for posting data on-chain, making it a cost-efficient solution for decentralized applications such as decentralized exchanges and NFT marketplaces.
zkEVMs also offer fast finality and capital efficiency, providing instant finality in transactions after being written on Ethereum, making it an effective solution for NFT traders and DeFi investors who constantly move assets between Ethereum Layers 1 and 2.
Another key aspect of zkEVMs is the ability to leverage Ethereum's network effects. Being the most prominent smart contract platform, the Ethereum ecosystem is valuable to developers and projects. By utilizing zkEVMs, developers can tap into crucial infrastructures such as audited code libraries, extensive tools, and reliable documentation, harnessing the power of Ethereum's networt effects.
zkEVMs are composed of three distinct parts: a running (execution) environment, a proving circuit, and a verifier contract. Each of these components plays a crucial role in the operation of the zkEVM, from execution and proof generation to verification.
The Execution Environment is where smart contracts run in the zkEVM. It functions similarly to the EVM, and its output is a new state derived from the initial and current transaction.
The Proving Circuit is where transactions in the execution environment are verified using zero-knowledge proofs. The circuit uses pre-state, transaction, and post-state inputs to complete the proof generation process. Through this process, the prover asserts a concise validity proof of the state transition.
The Verifier Contract is responsible for providing validity proofs to smart contracts deployed on Ethereum. The pre-states, transactions, and post-states are further committed to the verifier contract. Then, the verifier contract analyzes the provided proof through computations, ensuring that the submitted outputs are correctly generated from inputs.
four different types of zkEVMs depending on their implementations, compatibility, and performance metrics as there are tradeoffs with different design choices.
1. Fully Ethereum-equivalent
2. Fully EVM-equivalent
3. EVM-equivalent except for gas costs
4. Solidity equivalent
The Different Levels of zkEVMs - Vitalik Buterin
Performance in zkEVMs is measured by the time it takes to generate zk-proofs. The faster the generation of zk-proofs, the more scalable the zkEVM is. zksync is a type 4 zk-EVM, which offers higher performance but at the cost of lower compatibility. This type is more challenging to implement due to its lower compatibility with EVM.
Type 4 zkEVMs like zksync sacrifice some compatibility with the EVM in order to achieve faster proof generation, resulting in higher scalability. However, developers must consider the trade-off between performance and compatibility when implementing these types of zkEVMs.
Polygon’s zkEVM is similar to that of Scroll as both are considered to be EVM-equivalent as of Q1 2023. This means that both Polygon zkEVM and Scroll are not fully compatible with all things Ethereum, but the EVM. Strides have been made to improve this compatibility, hence the “upgrade” from Hermez v1 to zkEVM on the part of Polygon. Polygon zkEVM is a Type-3 zkEVM as it makes some sacrifices in terms of compatibility to optimize performance. Thus, Polygon zkEVM is far easier to build, has faster prover times, and quick finality, but less compatibility with Ethereum than some competitors. Some applications wishing to move to Polygon zkEVM will require additional work in rewriting some code to make it compatible, though this is stated to be at least minimized in Polygon zkEVM compared to Hermez v1.
In many respects, Type-3 zkEVMs are considered to be more transitional than permanent with the expectation being that the zkEVM will eventually build out to be Type-4 or fully compatible with Ethereum. For now, most Solidity code is compatible with Polygon zkEVM as is, therefore most of the additional overhead for developers remains limited.
Want more? Click the button below for a follow-up article on zero-knowledge proofs and all things rollups!
