Get unrivaled scalability using the apps, infra and tooling you love
Build, test and launch dApps with the skills you have and tools you know. Connect instantly with MetaMask and Infura, deploy bytecode as is and deploy apps just as you would on Ethereum.
Low gas fees
Build dApps that users can interact with at scale
EVM equivalent
Fully compatible with existing tooling, infrastructure, IDEs and wallets.
Secured by Ethereum
Backed by the security of Ethereum, where all rollup transactions are verified on-chain by a decentralized community of over 500k validators
Next gen scalability
Innovative lattice-based zkSNARK prover generates fast zero-knowledge proofs.
Scale dapps with zero switching costs
Migrate existing dapps with no code changes or smart contract rewrites
- Next generation scaling: Our zkEVM delivers industry leading throughput and opens the door to infinite scaling with L3s
- Ethereum aligned: 100% EVM bytecode compatibility, so you can deploy your existing dapp in minutes without changes
- Developer-friendly design: Built to minimize onboarding time, our rollup abstracts away ZK complexity, uses ETH for gas and has no reliance on third party transpilers or bespoke middleware
- Highly composable: General purpose rollup designed for atomic synchronous interoperability between all deployed dApps
- Industry leading efficiency: Award winning prover built with in house libraries delivers ultra-low gas fees
Accelerate time to value with Linea's developer friendly integrations
Build, test and launch dapps on the Linea network using native integrations with tools like Truffle, Infura and MetaMask
- Connect in seconds: Easy user onboarding with default MetaMask integration
- Ship faster and scale with confidence: Infura’s easy to use API abstracts protocol complexity enabling devs to ship faster and scale with the confidence of 99.9% uptime
- Use the tools you love: Build, test, debug and deploy Solidity smart contracts with popular dev environments like Truffle, HardHat, Foundry and Brownie
- Test locally: Fork and debug the zkEVM locally and test faster with built in Ganache compatibility support
- Securely bridge and swap tokens: Safely move tokens on and off network with our native, trustless bridge and access to MetaMask’s user-friendly Bridge
Build with confidence
From the genesis block, Consensys has helped build and democratize Ethereum.
- Open, flexible architecture: Extensible and modular design will enable developers to configure dApps for their unique privacy, data availability and access control needs.
- Grounded in research: Built on four years of research on zk-based scalability, elliptic curves for zk proof systems, zk design circuits, rollups and bridging with full formal verification of cryptography and arithmetization for complete security
- Built for Ethereum: Created alongside the teams that designed the Beacon Chain and Ethereum’s Engine API, the Consensys zk rollup will be managed as an open source public good alongside Hyperledger Besu, Teku and Web3Signer
- Commitment to decentralization: Committed to decentralization and open source development of our prover and arithmetization. With full EVM equivalence there is no developer lock in and protocols can easily port apps to other EVM based networks.
"We are excited to support Consensys zkEVM and allow users to bridge between Ethereum and their new chain using the familiar Hop interface. The ease of integration, tooling [and] compatibility allowed this integration to work seamlessly with the existing Hop development stack."
Shane Fontaine - Co-Founder and COO, Hop Protocol
For me it was really smooth and all of this takes minutes to migrate our dapp so I found the process really smooth to be honest.
I didn’t have to rewrite some special dedicated script, I can take my normal deployment scripts and it just works”
Frederic Heng - Senior Web3 Software Engineer
"When I build on an L2 or another network, I want minimal modifications. To use this zkEVM I just changed the network ID and that's it!"
Kevin Bluer - Head of Curriculum & Training
"I was having problems deploying on other zkEVMs due to low latency and bad UX, but when deploying on ConsenSys everything worked smoothly.”
Lead Developer
"Deploying my smart contracts on the Consensys zkEVM using Truffle dashboard took less than a minute. All I had to do was select the network in MetaMask and click deploy and my dapp was up and running.”
Private Testnet User
Get Started
Community
Scaling Ethereum is something we do together.
You can submit your project, become an ambassador and dial into upcoming community calls to get started.
Join us on Discord (zkevm-rollup) to shill you projects, get help and let us know how we can do better!
Deploying a zk-rollup that offers the same experience as Ethereum is technically challenging. The EVM was never designed to be proven in a zk circuit and therefore most zk-rollup teams decided to go a different path, using bespoke languages and virtual machines separate to the EVM. We felt this created friction for developers familiar with Ethereum.
ConsenSys R&D, along with others in the ecosystem, have been working on an approach to wrap EVM computation in zero-knowledge proofs to create a zkEVM implementation. This zkEVM handles native EVM bytecode for proving and verification to allow the execution of Solidity smart contracts and enable developers to get the benefits of a zk-rollup using the developer tools and infrastructure they are familiar with. You can read more about our goals and the specification here
Yes, the plan is to open source both the specification and the code. You can read our specification for the arithmetization, which was published during DevCon 6. We will provide an update to this specification and the source code when it is documented and is ready to be assessed by the community. Additionally, we recently published the prover scheme.
There are different types of zkEVM. Vitalik’s blog post describes zkEVM’s in types and the goal of our Rollup is to be a Type 2 zkEVM. A Type 2 zkEVM is bytecode-compatible which means we’re the most compatible with Ethereum and the EVM making it easy for developers to build and maintain applications on Layer 2.
We do not use transpilers or custom compilers to generate zk proofs for Solidity smart contracts. We take the compiled bytecode of Solidity. We believe this approach reduces the surface area risk for bugs and hacks.
The prover is still incomplete–typically we do not prove the precompiles. In the testnet, we decided to make them available to the smart contracts (i.e. they are executed properly, but the execution is not proven), as we plan to support them for the production ready release.