What is the Zenith Stack?

The Zenith Stack is the framework that allows enterprises and developers to launch their own customizable, trusted EVM environments that are atomically composable with Canton. Where Zenith EVM is a single reference environment operated by Zenith, the Zenith Stack is the tooling and infrastructure that enables a Canton participant to operate their own EVM execution environment.

Each EVM instance launched via the Zenith Stack is Ethereum-equivalent, supporting the same smart contract standards, tooling, and developer workflows as Ethereum.

The Zenith Stack is built for horizontal scalability, enabling parallelization through shard-like scaling, and high aggregate throughput while preserving single-threaded EVM semantics and full compatibility with existing Ethereum tooling.

Enterprises and institutions retain full control over their environment:

  • Native tokens, custom fee and economic models, and ordering logic can all be configured independently.
  • Data access controls, compliance, and regulatory obligations remain within their domain.

Looking ahead, the Zenith Stack is designed to support additional virtual machine types beyond the EVM, with the SVM (Solana Virtual Machine) planned as a future addition, further extending Canton's composability across multiple ecosystems.

High-level architecture and execution model

All EVM environments launched using the Zenith Stack are built on Reth, a high-performance, modular Ethereum execution client. This means they are fully Ethereum-equivalent:

  • Execute the same EVM runtime.
  • Expose a fully compatible Ethereum RPC interface.
  • Support the same libraries and smart contract standards as Ethereum mainnet.

Atomic composability

Atomic composability between Zenith Stack chains and Canton is enabled by the external_call() primitive, implemented by Zenith in Daml. This function allows Daml contracts to invoke the EVM contracts deterministically, confirm the results of native EVM execution back to Canton, and to verify the EVM state roots in the Daml contract.

Each Zenith Stack chain has its own dedicated Daml contract deployed on Canton. This contract acts as the coordination and settlement layer between Canton and the EVM environment:

  • Handles transactions submitted via Canton including a wrapped EVM payload.
  • Invokes external_call() to communicate with the local EVM runtime.
  • Forwards the EVM payload for execution.
  • Receives execution results and confirmation.
  • Settles the resulting EVM state root on Canton.

Deterministic execution

The external_call() primitive ensures deterministic invocation of the EVM environment within Canton's native two-step validation model:

  1. The submitter executes the call during interpretation and includes the result in the transaction view.
  2. Other Canton validators in the domain re-execute the same external_call() locally.
  3. If any validator obtains a different result, validation fails.

This preserves Canton's determinism guarantees and does not introduce additional trust assumptions.

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

  • Execution is atomic, i.e. either both succeed or the entire transaction fails.
  • Finality is confirmed back to the user once the combined transaction is validated.

The EVM execution adds almost unnoticeable latency to the overall Canton transaction, in the range of a few hundred milliseconds.

Institutional-grade control and customization

The Zenith Stack is designed for institutional and enterprise-grade deployment. Each organization operating a Zenith Stack chain retains full control over its environment, including:

  • Its native tokens
  • Economic models
  • Transaction fee structures
  • Ordering logic
  • Participant permissions

Data access controls, compliance requirements, and regulatory obligations remain entirely within the operator's domain.

This allows institutions to deploy permissioned EVM environments tailored to their operational, jurisdictional, and regulatory requirements, while maintaining atomically composable with Canton and other Zenith chains.

Horizontal scalability by design

The Zenith Stack is built for horizontal scalability. It enables:

  • Off-chain parallelization across independent EVM environments.
  • Shard-like scaling through multiple isolated execution domains.
  • High aggregate throughput across chains.

Each individual Zenith chain preserves:

  • Sequential, single-threaded EVM semantics.
  • Full compatibility with existing Ethereum tooling.
  • Deterministic state transitions producing a verifiable state root.

This architecture allows enterprises to scale execution capacity horizontally without sacrificing Ethereum equivalence.

Interoperability across Zenith Stack chains and Canton subnets

One of the core design principles of the Zenith Stack is atomic interoperability, not only between Zenith EVM and Canton, but across multiple Zenith Stack chains and Canton subnets simultaneously.

Since every Zenith chain is anchored to Canton via its own Daml contract, and all cross-environment invocations use the deterministic external_call() primitive, transactions can span:

  • Multiple parallel Zenith Stack instances.
  • Multiple Canton subnets.
  • Combinations of Daml-native and EVM-native assets.

All within a single atomic transaction.

How atomic composition works across chains

Each Zenith Stack chain:

  • Maintains its own EVM state.
  • Produces its own EVM state root.
  • Settles the state root back to Canton via its dedicated Daml contract.

When a transaction involves multiple Zenith chains:

  1. The user submits a Canton transaction containing wrapped EVM payloads for each relevant Zenith environment.
  2. Each corresponding Daml contract:
    • Registers the request.
    • Invokes external_call().
    • Executes the transaction in its local EVM runtime.
    • Returns execution results and the updated state root.
  3. Canton validators deterministically re-execute all external calls.
  4. The transaction commits only if every execution across all chains succeeds.

If any leg fails, whether on a Canton subnet or on the EVM side on Zenith, the entire transaction is rejected.

This guarantees:

  • True atomic composability across independent EVM environments.
  • No partial execution.
  • No cross-chain race conditions.
  • Deterministic finality.

Parallel Zenith instances with atomic composability

Because the Zenith Stack enables horizontally scalable, independent EVM environments, enterprises can operate multiple parallel Zenith Stack instances, each customized for specific business lines, jurisdictions, or regulatory domains.

Despite being separate instances, these chains remain atomically composable through Canton.

This allows patterns such as:

  • Atomic swaps between assets living on different Zenith chains.
  • Coordinated DeFi operations spanning multiple Canton domains and EVM environments.
  • Regulated asset transfers across Canton subnets and EVM applications.
  • Multi-chain settlement workflows with single-transaction finality.
  • Unified liquidity across Zenith Stack and Canton.

The key architectural property is that composability is handled on Canton as coordination and settlement layer, not through asynchronous bridges or message relayers.

Multi-VM future

While the Zenith Stack initially focuses on EVM compatibility, it is designed as a multi-VM framework.

Looking ahead, the Stack will support additional virtual machine types beyond the EVM. The Solana Virtual Machine (SVM) is planned as a future addition, extending Canton's atomic composability across multiple execution ecosystems.