//Introduction:
Kakarot zkEVM is an innovative project that aims to enhance the scalability of the Ethereum blockchain using zero-knowledge proofs. By leveraging the power of the CairoVM, Kakarot zkEVM brings provable execution to decentralized applications (dApps) and introduces a more efficient approach to smart contract execution. In this article, we will delve into the key concepts and features of Kakarot zkEVM, explaining them in simple terms for better understanding.
//Key Differences between Cairo and Solidity:
Cairo and Solidity are both programming languages used in the context of smart contract development, but they differ in several ways:
Purpose and Design: Solidity was specifically designed for writing smart contracts on the Ethereum blockchain. It is a statically-typed, high-level language that borrows syntax and concepts from languages like JavaScript and C++. On the other hand, Cairo is the programming language associated with the CairoVM. It is a Turing-complete language designed for provable execution and focuses on expressing computations as polynomials for zero-knowledge proofs.
Provable Execution: One of the key differentiators of Cairo is its focus on provable execution. Cairo allows developers to write programs that can be proven using STARKs (Scalable Transparent ARguments of Knowledge). This means that every transaction executed on the CairoVM can be cryptographically proven to be correct, enhancing security and enabling scalability.
Abstraction Level: Solidity operates at a higher level of abstraction compared to Cairo. Solidity offers features specific to the Ethereum ecosystem, such as contract deployment, interaction with other contracts, and managing Ethereum-specific data types. Cairo, being a lower-level language, is more focused on the fundamental execution of programs and expressing computations as polynomials.
Code Reusability: Solidity benefits from a large ecosystem of existing smart contracts, libraries, and frameworks developed for Ethereum. This enables developers to leverage existing code and reuse components, enhancing productivity. Cairo, being relatively newer and more specialized, has a smaller ecosystem but offers opportunities for innovation and new approaches to smart contract development.
Learning Curve: Solidity has been around for a longer time and has a more extensive user base, making it relatively easier to find learning resources and community support. Cairo, being newer and more specialized, may have a steeper learning curve initially. However, as the adoption of CairoVM and zkEVMs grows, the availability of learning resources is expected to improve.
In summary, Cairo and Solidity differ in their focus, design principles, level of abstraction, and use cases. Solidity is widely used for Ethereum smart contract development, while Cairo is specifically designed for provable execution and the construction of zkEVMs on top of the CairoVM.
//Understanding CairoVM:
The CairoVM is a virtual machine designed for provable execution. It forms the backbone of Starknet, a Layer 2 (L2) validity rollup solution in the Ethereum ecosystem. What sets CairoVM apart is its ability to represent execution as polynomials, allowing for the proof of transactions using STARKs. Developers can write dApps in Cairo, a high-level programming language associated with the CairoVM.
//What is a zkEVM?
A zkEVM, or Zero-Knowledge Ethereum Virtual Machine, combines the benefits of zero-knowledge proof systems with the Ethereum Virtual Machine (EVM). It introduces increased scalability and, in some cases, privacy to smart contract execution by leveraging cryptographic techniques to prove transaction correctness.
//The Birth of Kakarot:
The idea of creating a zkEVM using the mature and well-defined EVM architecture gained traction when Shahar Papini, co-inventor of Cairo, proposed it in July 2022. The Kakarot project began in October 2022, with the goal of implementing the EVM in Cairo and achieving zkEVM functionality in less than 10,000 lines of code.
//Progress and Achievements:
The Kakarot core team, consisting of dedicated individuals, made remarkable progress in a short period. By the end of 2022, they successfully implemented all EVM opcodes, resulting in a naive implementation of a zkEVM in less than 5,000 lines of expressive, high-level code. This achievement was made possible through collaboration with the Starknet community and the support of the Starknet Foundation.
//Key Features of Kakarot zkEVM:
Open-Source and Community-Driven: Kakarot zkEVM is committed to open-source principles and welcomes contributions from the community. This approach fosters innovation and collaboration within the Ethereum ecosystem.
EVM Compatibility: Kakarot zkEVM ensures compatibility with existing EVM-based dApps written in Solidity or other EVM-supported languages. This compatibility allows for a seamless transition to the zkEVM environment without requiring modifications to the existing code.
Bytecode Equivalence: As of May 2023, Kakarot zkEVM has achieved 100% bytecode equivalence, which means that it can execute EVM bytecode with the same results as the original EVM. This compatibility enables developers to leverage the benefits of zkEVM without sacrificing functionality.
Implementation of EVM Precompiles: Kakarot zkEVM has implemented eight out of the nine EVM precompiles. These precompiles are essential for executing complex operations efficiently. With the upcoming completion of all nine precompiles, Kakarot zkEVM will reach the status of a type 2.5 zkEVM.
//Future Directions:
Kakarot zkEVM has an exciting roadmap ahead. The project aims to bring EVM compatibility to Starknet, allowing developers to deploy their Solidity dApps through Kakarot zkEVM. Furthermore, Kakarot zkEVM plans to build a zkRollup-as-a-service tool—a Layer 3 solution on top of Starknet—to facilitate the development of app-specific L3s. This approach offers cryptographic security, low gas costs, and fast execution.
//Conclusion:
Kakarot zkEVM represents a significant leap forward in enhancing the scalability and efficiency of the Ethereum blockchain. By combining the power of zero-knowledge proofs with the CairoVM, Kakarot zkEVM opens up new possibilities for dApp developers, ensuring compatibility with existing codebases and providing a more secure and cost-effective execution environment. The future of Ethereum scalability and provable execution looks promising with the advent of Kakarot zkEVM.
Sources:
https://medium.com/kakarot-zkevm/kakarot-an-intro-to-the-first-modular-zkevm-cd6ea45019f1
https://starkware.co/starknet/