What is Zenith EVM?

Zenith EVM is a reference EVM environment operated by Zenith. It is built on Reth, a performant Ethereum execution client, and exposes a standard Ethereum RPC interface. This means developers can interact with Zenith EVM exactly as they would with any Ethereum-compatible chain, deploying smart contracts using existing tooling like Solidity, Hardhat, Foundry, and MetaMask, and lifting and shifting existing EVM applications with no or minimal changes.

Zenith EVM is atomically composable with Canton subnets and Canton-native applications. Users can submit native Canton transactions that carry a wrapped EVM payload, enabling cross-chain atomic operations, for example, an atomic swap between a Canton-native asset and an EVM-native asset living on Zenith EVM, with finality confirmed back to the user once both legs of the transaction have executed successfully.

Interoperability extends beyond Canton as well: Zenith EVM will be connected to the broader Ethereum ecosystem through interoperability solutions such as Chainlink's or LayerZero's.

Technical overview

Zenith EVM is built on Reth, a high-performance, modular Ethereum execution client. This means Zenith EVM is fully Ethereum-equivalent at the execution layer:

  • Executes the same EVM runtime.
  • Exposes a fully compatible Ethereum RPC interface.
  • Supports the same libraries and smart contract standards as Ethereum mainnet.

Atomic composability

Atomic composability between Zenith EVM and Canton is enabled by the external_call() primitive, implemented by Zenith in Daml. This function allows Daml contracts to invoke the EVM execution environment deterministically.

It is used to confirm the results of native EVM execution back to Canton, and to verify the EVM state roots in the Daml contract.

The external_call() primitive follows Canton's native two-step validation process and does not introduce additional trust assumptions.

  1. The submitter executes the function during interpretation and includes the result (and optionally its hash + metadata) as part of the transaction view.
  2. Each validator re-executes the same external_call() locally.
  3. If any validator obtains a different output, validation fails, mirroring the same determinism rule as for any existing Daml primitive.

Finality

For transactions spanning Canton and Zenith EVM application, the time to finality will be almost the same as that of a transaction within Canton only: Zenith EVM adds almost unnoticeable latency in the range of a few hundred milliseconds.

How to build on Zenith EVM

Since Zenith EVM is powered by Reth under the hood, the developer experience is effectively identical to building on Ethereum. In most cases, the only required change is updating your RPC configuration to point to a Zenith EVM endpoint instead of a standard Ethereum node.

RPC configuration

Zenith EVM exposes a vanilla Ethereum RPC endpoint. To connect your tooling, replace your existing RPC URL with the Zenith EVM RPC endpoint provided for your environment. Everything else in your workflow remains the same.

Tooling

All standard Ethereum development tools work with Zenith EVM out of the box:

  • Foundry: compile, test, and deploy contracts as usual.
  • Hardhat: add the Zenith EVM network configuration and deploy normally.
  • MetaMask: add Zenith EVM as a custom network using the provided RPC URL and chain ID.

From a developer's perspective, Zenith EVM behaves like Ethereum, while enabling atomic composability and settlement within the Canton environment.

Deploying smart contracts

Contract deployment works exactly as it does on Ethereum.

Write your contracts in Solidity, compile them with your preferred toolchain, and deploy to Zenith EVM using the Zenith EVM RPC endpoint. Existing contracts can be lifted and shifted from Ethereum or any EVM-compatible chain with no or minimal modification.

Transaction flow between Canton and Zenith EVM

As discussed, Zenith extends Canton with an EVM-compatible execution environment that is natively composable with Canton subnets. All EVM activity is routed through Canton and settles on Canton MainNet.

The following describes the high-level flow of a transaction spanning Canton and Zenith EVM:

1. Transaction submission via Canton

Users submit a native transaction through Canton. If interaction with Zenith EVM is required, the Canton transaction includes:

  • A signed and wrapped EVM transaction payload.
  • The corresponding Daml operations.

2. Invocation from Daml to the EVM

Each Zenith environment, including Zenith EVM, has its own Daml contract on Canton.

When the Daml contract processes the transaction, it:

  • Registers the incoming request.
  • Invokes the external_call() function.
  • Forwards the EVM payload to the locally running EVM environment.

The external_call() primitive allows a Daml contract to call a deterministic, locally running service and receive the result within the same atomic transaction

3. Native EVM execution

The Canton participant operates in a dual role:

  • As a node in the Canton domain.
  • As the sequencer/operator of Zenith EVM.

The EVM transaction is executed natively in a Reth-based EVM runtime.

Execution guarantees include:

  • Sequential, single-threaded EVM semantics (consistent with Ethereum).
  • No state contention due to rejection of conflicting transactions.
  • State transitions producing a new EVM state root.

4. Deterministic transaction validation through re-execution

The external_call() follows Canton's native two-step validation model:

  1. The submitter executes the function during interpretation and includes the result in the transaction view.
  2. All other Canton participants in the same domain re-execute the same call locally.
  3. If any validator obtains a different output, validation fails.

This ensures deterministic cross-environment execution consistent with Canton's existing execution model.

5. Settlement and finality

After successful EVM execution:

  • The EVM transaction outputs are returned to the Daml contract.
  • The new EVM state root is posted to Canton.

Because both the Canton leg and the EVM leg are part of the execution tree of the same transaction:

  • Execution is atomic: either both legs succeed or the entire transaction fails.
  • Finality is confirmed back to the user.

Composable EVM applications on Canton

Zenith brings native EVM execution to Canton, enabling developers to deploy Solidity applications that are atomically composable with Canton-native contracts and subnets.

You can build using familiar Ethereum tooling, such as Solidity, Foundry, Hardhat, MetaMask, while benefiting from Canton's privacy model and settlement guarantees. Applications deployed on a Zenith EVM environment maintain Ethereum-equivalent execution semantics, with state roots settled on Canton MainNet.

This opens up new design possibilities, including:

  • EVM-based DeFi applications composing directly with regulated Canton-native assets.
  • Enterprise-grade permissioned EVM environments operated by Canton participants.
  • Cross-domain transactions that execute atomically across Daml and EVM.

If you're building smart contracts, migrating an existing EVM application, or exploring cross-environment composability, we're happy to support you with technical guidance, integration support, and architecture discussions.

Reach out to collaborate or to explore how Zenith can support your application on Canton.