Zenith demonstrates atomic transaction flows across Canton and Zenith EVM

Atomic transaction flows across Canton and Zenith EVM

On our path to bring EVM compatibility to Canton, at Zenith, we’ve recently implemented end-to-end transaction processing across Canton and Zenith EVM on a Canton test environment, and in today’s blog, we dive into Zenith’s atomic transaction flows spanning Canton and Zenith EVM.

What is Zenith?

Zenith extends Canton Network with an EVM environment, followed by SVM soon after, bringing Ethereum applications to Canton, and enabling developers to deploy EVM applications that atomically interact with Canton while allowing enterprises to run their own programmable EVM environments composable with Canton subnets.

How Zenith enables atomic composability

One of the core design principles of Zenith is that all EVM activity is routed through Canton and also settles on Canton MainNet, hence Zenith EVM is very much akin to an EVM-based subnet on Canton.

Atomic composability between Zenith EVM and Canton is enabled by the external_call() primitive, implemented by Zenith in Daml, Canton’s native language. 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 EVM’s Daml contract on Canton.

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

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

To see atomic composability live, visit our internal testnet’s public explorer that allows the tracking of the entire transaction lifecycle: https://explorer.zenith.network/

The test environment

Our internal test environment is a local multi-node Canton test network that includes the end-to-end implementation of the transaction flow between Canton and Zenith, with Zenith EVM deployed to it.

The network consists of the following:

• A synchronizer that facilitates message passing, transaction ordering (as the sequencer) and confirms consensus and finality (as the mediator).
  • Note: The sequencer and mediator are “roles” or “functions” performed by Canton synchronizer nodes.
• Two Canton participant nodes (Validator 1 and Validator 2) re-executing all transactions end-to-end, including the external call and the EVM event.
• A Canton observer that validates transactions without re-executing the external call.
• The EVM node, the relayer and the external call server (ECS), run by the two Canton participant nodes.

External call and EVM execution

As mentioned, all EVM transactions are routed through Canton, wrapped into a native Canton transaction, and therefore the Canton participants hosting the Zenith EVM contract on Canton also run the EVM node, the relayer and the external call server (ECS) to execute transactions across Canton and Zenith EVM.

At the time of writing we’ve successfully processed more than 100K EVM transactions through the current test network instance, with a typical latency fluctuating between 400ms and 1.5 seconds. (Note: we have not spent any time optimizing EVM execution time.)

Transaction lifecycle across Canton and Zenith

Let’s take this transaction as an example:

• Canton update ID: 1220fd2553b5b39d2154f79d05fc058c906672e285bba0adcbc68d3b2d1a8ee967ba
• EVM tx hash: 0x96b71ed28b7d593c5d78dfc76fef0dae2a35dc39284908ec7cb8c2fb52bb5f2f

This transaction is initiated directly on the EVM side and is processed through Canton’s consensus. The transaction flow is as follows:

1. The EVM node listens to incoming transactions.
2. The relayer submits the wrapped EVM payload to a synchronizer that sequences it on Canton.
3. Validator 1 (one of the Canton participants hosting the Zenith EVM contract)
   • Receives the Canton transaction,
   • Initiates the external_call() through the ECS,
   • Natively executes the EVM transaction in the EVM node,
   • Includes results (including tx hash and metadata) in the transaction view, and passes side effects to the Canton node.
4. 1. Validator 2 (the other Canton participant hosting the Zenith EVM contract in our test network) re-executes the transactions following the same steps as Validator 1.
   2. The Observer validates the transactions using the EVM results posted by the other participants.
5. The synchronizer (as the mediator) checks all signatures and confirms finality.
6. The new state root is updated and the EVM block is published.

The EVM event was executed atomically within the operation tree of the native Canton transaction, with an end-to-end processing time of 650 milliseconds.

EVM transaction initiated from Canton

The above example describes the flow of a transaction that is initiated through the EVM, and in order to be processed, gets routed through Canton.

The other way around, when a Canton user initiates a transaction on Canton that triggers an EVM event, the flow is quite similar but there are some key differences to be considered, because we need to allow Canton participants that do not run the EVM node, to be able to submit transactions including the wrapped EVM payload. In this case the initial steps look like this:

1. The Canton participant receiving the user transaction will call /prepare on one of the EVM-capable participant nodes, for instance, Validator 1.
2. Validator 1 will run the EVM to generate the transaction but instead of submitting it, sends it back to the initial participant that will inspect and sign it and then submit the transaction to the synchronizer.
3. From this point on, the process continues with steps 3 to 6 of our previous example.

This allows any Canton participant to submit transactions including EVM payloads, and therefore unlocks true atomic interoperability.

What’s next?

Once the external_call() primitive is rolled out to Canton TestNet, we will launch a testnet deploying Zenith EVM directly on Canton’s TestNet.

In parallel, our focus is making Zenith EVM production-grade. Zenith is expected to go live on Canton MainNet in early Q3 2026.

We are committed to working closely with enterprises, developers, and ecosystem partners to accelerate real utility and adoption across markets and use cases.

Whether you’re an enterprise exploring blockchain solutions, a developer building novel applications, or a Canton ecosystem contributor shaping the future of digital finance, we’d love to collaborate.

Contact us to explore how Zenith can support your applications.

About Zenith:

Zenith is the EVM and SVM execution layer for Canton Network, advancing real-world capital markets initiatives on-chain.

“Zenith’s addition of atomically composable EVM, and planned SVM, execution expands Canton’s capabilities in a way that can increase network utility,” said Eric Saraniecki, Head of Network Strategy at Digital Asset. “It enables developers to deploy Solidity applications that can interact atomically with Canton-based infrastructure, bringing established financial building blocks to institutional-grade rails already operating at significant real-world volumes.”

Learn more about Zenith: Website | Docs | GitHub | Blog | X (Twitter) | Telegram | Discord