Canton has always been built for institutional privacy preserving use cases. But until now, accessing Canton as a developer meant writing Daml. That was the only gate of entry, and for many builders coming from the EVM world, it was a friction. That changes with Zenith EVM.

Zenith, an ecosystem partner building on Canton,  is building a native EVM execution environment that is atomically composable with Canton. This is not a bridge. It is not a sidechain and it is NOT a rollup. It is something architecturally distinct, and this blog will make sure both Canton builders and EVM developers understand what it means for them in practice.

For Canton Builders & Daml:

If you have been building on Canton with Daml then Zenith EVM does not replace what you have built. It extends Canton’s ecosystem overall. Any Daml contract you have deployed on Canton can now interact atomically with Solidity contracts running on Zenith EVM. A Canton wallet, a Daml-based settlement workflow, a tokenized asset contract, all of these can compose directly with EVM native applications, within a single Canton transaction. 

Your Daml contracts do not need to change as the composability is handled at the protocol level via the external_call() primitive implemented by Zenith on Daml Infrastructure.

What does that unlock? A few things worth noticing:

  • EVM-native DeFi applications (lending protocols, DEXes, vaults) can now interact with Canton native assets like Canton Coin, USDCx, or any CIP-0056 token.
  • Institutional counterparties on Canton who hold tokenized bonds or other regulated assets can participate in EVM based financial applications that were previously inaccessible.
  • Your Daml dApp can trigger Solidity logic as part of the atomic transaction, so you do not have to rebuild EVM wrapped tooling from scratch. You can compose with what already exists on Zenith’s EVM environment on Canton .

The architectural detail worth understanding here is that when a Canton transaction includes an EVM interaction, the Zenith Daml contract processes it and fires external_call() which forwards the EVM payload to a locally running instance. Every Canton validator re-executes that same call against their local EVM runtime. If any validator gets a different result, the entire transaction is rejected. Same determinism guarantees as Daml native with no additional trust assumptions.

For EVM Developers:Building on Canton Is Now One RPC Away

If you have been building on an EVM compatible chain, and you are curious about Canton but have been put off by the learning curve of a new Language i.e Daml then Zenith EVM removes that barrier.

Your existing Solidity contracts work on Zenith EVM without modification. The developer experience is EVM equivalent because it runs on Reth, an Ethereum execution client. 

You interact with it exactly the same way you interact with any other EVM chain which make it literally just an RPC away, e.g

// In your hardhat.config.js
networks: { zenith: {
url: 'Zenith EVM's RPC',
chainId: Zenith EVM's chain ID
} }
// Then deploy as normal
npx hardhat deploy --network zenith

But once deployed on Zenith EVM, your application has access to atomic composability with Canton’s institutional grade ecosystem. 

Because Zenith EVM transactions are routed through Canton as native Canton transactions, your Solidity contract calling a Canton wallet or a Daml settlement contract is handled in a single atomic execution round, not via an asynchronous bridge message that can fail independently.

Why This Is NOT an Ethereum Rollup

EVM developers will immediately reach for a familiar mental model that ‘This sounds like a rollup BUT Zenith is more like Arbitrum or Optimism to Ethereum for Canton but Zenith does NOT divert volume, value, or fees away from Canton.‘ It is worth being precise about why that analogy breaks down, because the differences are what make this interesting.

Ethereum rollups only settle to Ethereum, everything else is done on the rollup itself. In Zenith’s case, EVM transactions go through Canton as the EVM payload is wrapped into a native Canton transaction. 

The second and more consequential difference is Ethereum rollups do not DIRECTLY compose atomically with Ethereum and that is a fundamental architectural limit. Zenith eliminates that limit between Zenith EVM and Canton by using Canton’s consensus.

Let’s Take a Real Example: A Lending Protocol

Suppose you have deployed a lending protocol on Zenith EVM and a Canton user, say Shreyas, holds $CC and wants to deposit it as collateral and borrow USDC against it. What happens under the hood then:

> Shreyas locks his $CC on Zenith’s bridge contract on Canton and mint wCC on Zenith’s EVM.

> Shreyas Deposits wCC in the lending frontend and his Canton wallet constructs one single Canton transaction containing two things that is a Daml instruction to lock his CC and a wrapped EVM payload calling deposit() on the Solidity contract.

> The Zenith Daml contract on Canton receives the transaction and fires external_call() forwarding the EVM payload to the locally running Reth instance.

> Every Canton validator re-executes the same external_call() against their local Reth instance and all get the same result, Consensus reached!

> Both finalize together as Shreyas’s CC is locked on Canton and he receives his lending receipt token on Zenith EVM. One confirmation, both succeed, or both revert.

How to Get Started

If you are a Canton/Daml builder, keep an Eye on Zenith’s upcoming documentation and public Testnet Launch for integrating external_call() into your existing Daml templates and reach out in the DAML Forum or Canton’s Discord with your questions.

If you are an EVM developer and this is your first look at Canton then try to deploy a contract on Zenith’s upcoming EVM testnet, and explore what is available to compose with on the Canton side with your EVM Expertise.