zenith
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
| ZENITH_KEY_FILE | No | Path to a file containing a testnet-only private key (e.g. ~/.config/zenith-evm-mcp/testnet.env with ZENITH_PRIVATE_KEY=0x<testnet key>). Required only to enable the opt-in write tools zenith_deploy and zenith_send. | |
| ZENITH_SPEND_CAP_ZTH | No | Per-session spend cap in ZTH for write tools (default 1 ZTH). |
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
Tools for Zenith EVM, the Ethereum-compatible execution environment of the Canton Network (testnet, chain 936485).
Key facts:
Standard Ethereum JSON-RPC, Solidity and tooling work unchanged. Each EVM block settles as one Canton transaction, so a receipt is final: no confirmations, no reorgs.
Blocks are produced only when there are transactions. An unchanged block number is not a stall; use zenith_health.
The public RPC has no WebSockets, filters or subscriptions, and eth_getLogs covers at most 1000 blocks; zenith_get_logs handles this.
Gateway moves tokens between Zenith EVM and Canton. Before sending anything to a Canton party, ALWAYS run gateway_preflight. Tokens sent to a wrong inbox are lost for good.
Write tools (zenith_deploy, zenith_send) only work when the user configured a testnet key, and they refuse any chain other than Zenith testnet.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {
"listChanged": true
} |
| prompts | {
"listChanged": true
} |
| resources | {
"listChanged": true
} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| zenith_network_infoA | Chain ID, endpoints (RPC, explorer, faucet, Gateway API, docs), latest block and its age, gas price, the Gateway deployment (contract, party, deployment ID, genesis hash) and the public RPC limits. Call this first when working with Zenith EVM. |
| zenith_healthA | One verdict for whether Zenith is working: healthy, idle (no traffic but the block producer is alive; blocks are only made when there are transactions), degraded, or possible-reset (the testnet was reset, so stored inbox addresses and holdings are invalid). Checks the RPC, the explorer's services, the Gateway producer and synchronizer, and the faucet (amount, cooldown, GitHub-account rule). |
| zenith_get_accountB | Balance, nonce, wallet vs contract, and for contracts: verified source, proxy implementation, ERC-20 metadata, and whether the address is a Gateway inbox. Also lists token holdings and recent transactions from the explorer. |
| zenith_get_transactionA | Status, fee, decoded call and events (verified ABIs, ERC-20 and the Gateway's own events), whether it was a Gateway deposit, and the Canton update that settled it: update ID, command ID, settlement time. If it was never mined, explains why using Gateway's pending-transaction index. |
| zenith_read_contractA | Calls a contract function without sending a transaction. Give either a full signature (e.g. "balanceOf(address) view returns (uint256)") or just the function name if the contract is verified on the explorer (ERC-20 names work for any token). Arguments are converted to the right types. |
| zenith_get_logsA | Event logs for a contract and/or event over any block range, decoded. The public RPC only serves 1,000 blocks per call and has no filters or WebSockets, so the range is walked in chunks from newest to oldest; use nextToBlock to continue. Defaults to the last 1,000 blocks. |
| zenith_decodeA | Decodes raw hex using the contract's verified ABI, a signature you give, ERC-20, or the Gateway's events and errors (including the inbox's NotWholeQuanta error). |
| gateway_tokensA | Every token registered with Zenith Gateway, with both sides: EVM address, symbol and decimals; Canton instrument, symbol and scale; how each direction works and what the recipient needs (for example a standing acceptance for wrappers of Canton tokens). |
| gateway_inboxA | Checks a Canton party ID and computes its inbox: the EVM address that delivers to that party on Canton. Rejects shortened IDs, protocol parties (m-, r-, b-) and the Gateway party, says whether the inbox is deployed, and cross-checks the registry API. |
| gateway_preflightA | Runs every rule in Zenith's "Before you send" checklist for a transfer from Zenith EVM to a Canton party, then dry-runs the exact transaction against the network (eth_estimateGas) to surface its own refusal reason. Returns pass/fail per check with fixes, the amount that arrives on Canton, and the unsigned transaction. Never sends anything. ALWAYS call this before sending to a Canton party. |
| gateway_deposit_statusA | Follows a Zenith EVM → Canton deposit by transaction hash: held by Gateway (with reason and eviction time), evicted (with the nonce to resend at), mined and waiting for the inbox, credited (with the Gateway collection event), or not a deposit. Gives the exact next step from the docs' Common problems table. |
| gateway_mailboxA | Derives the mailbox party for an EVM address and token (the Canton party you transfer to, to move that token to that EVM address) and reports its state: absent, requested, active and so on. Explains how to request it. |
| gateway_convertB | Exact amount conversion for a Gateway token, in either direction, with the crossing rules applied: one EVM base unit is 1e-10 on Canton, 18-decimal tokens show 10^8 times larger on Canton (DORIGe-8), ZTH crosses in multiples of 10^8 wei and wZTH back in whole gwei. Never rounds silently. |
| gateway_token_eligibilityA | Checks an ERC-20 against Zenith's registration criteria: verified source, deployment transaction, not upgradeable, no fee/burn/reflection/rebase/hook/blocklist functions (bytecode selector scan), and a simulated transfer from a real holder (eth_call with a state override) proving it moves exactly the amount. Prepares what Zenith asks for in a request. |
| gateway_activityA | Recent token crossings between Zenith EVM and Canton, decoded from the Gateway contract's own events (Collected, NativeCollected, Minted, Released), with per-token counts by direction. |
| zenith_verify_contractA | Verifies a deployed contract through the explorer's Etherscan-compatible API. From a .sol file it compiles locally with the given settings, checks the bytecode matches the deployed code, then submits the exact standard-JSON input and waits for the result. Also accepts a standard-JSON input file (for example from forge verify-contract --show-standard-json-input). |
| zenith_project_configA | Ready-to-paste configuration for Foundry, Hardhat 3, Hardhat 2, viem, wagmi, MetaMask and .env, with the Zenith RPC, chain ID, explorer verification and the right EVM version (prague) already set, plus the notes that matter (no multicall, polling watchers, one-receipt finality). |
| zenith_check_compatA | Scans Solidity, TypeScript/JavaScript or deployed bytecode for things that behave differently on Zenith: block.number used as a clock (blocks only come with transactions), prevrandao randomness, blob opcodes, Osaka-only opcodes and compiler targets (Zenith runs Prague), dependencies on Multicall3/Permit2/EntryPoint/CreateX (not deployed), WebSockets, filters and subscriptions (not available), waiting for many confirmations (can hang), and unbounded getLogs ranges. |
| zenith_deployA | Deploys a contract to Zenith testnet from a .sol file (compiled for Prague and verified automatically), a Foundry/Hardhat artifact or bytecode. Without confirm it only simulates and shows the cost. Requires a testnet key configured by the user; refuses any other chain and respects the session spend cap. |
| zenith_sendA | Sends ZTH, an ERC-20 transfer or a contract call on Zenith testnet. For a transfer to a Canton party, set gatewayPartyId (with token and amount): the full Gateway preflight runs first and blocked sends are refused. Plain sends to a Gateway inbox are refused so the checks cannot be skipped. Without confirm it only simulates. |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
| deploy_and_verify | Check a Solidity contract for Zenith gotchas, deploy it to testnet, verify it and trace the deployment to Canton. |
| send_to_canton_safely | Run every Gateway check before sending tokens from Zenith EVM to a Canton party. |
| investigate_missing_deposit | Work out what happened to a transfer between Zenith EVM and Canton. |
| audit_token_for_gateway | Pre-screen an ERC-20 against Zenith's registration criteria. |
| port_ethereum_app | Review an existing Solidity or dApp project for what changes on Zenith EVM. |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
| network | Live network info: endpoints, latest block, Gateway deployment. |
| limits | |
| gateway-tokens | Every token Gateway can move, with both sides described. |
| gateway-checklist | |
| differences |
TDQS
Scored across 20 tools
Most tools have clear distinct roles, especially the gateway_* transfer/status tools versus the zenith_* chain utilities. A few pairs overlap conceptually, such as gateway_deposit_status vs zenith_get_transaction and gateway_activity vs zenith_get_logs, but the descriptions clarify when each should be used.
Names are consistently snake_case and grouped by gateway_ and zenith_ prefixes. The pattern mixes noun phrases like gateway_tokens and zenith_network_info with verb phrases like zenith_get_logs and gateway_convert, but it remains predictable and readable.
20 tools is above the typical 3-15 range but reflects a broad EVM plus Canton Gateway domain. Each tool appears to serve a specific workflow such as preflight, deploy, verify, logs, config, or sending, so the count is justified rather than padded.
Coverage is broad: network info, account/contract reads, logs, decoded transactions, gateway transfer preflight and status, deployment, verification, project config, compatibility checks, and sending. Minor gaps exist, such as no faucet request tool or explicit transaction replacement/cancel, but core lifecycle workflows are covered.