Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
ZENITH_KEY_FILENoPath 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_ZTHNoPer-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

CapabilityDetails
tools
{
  "listChanged": true
}
prompts
{
  "listChanged": true
}
resources
{
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
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

NameDescription
deploy_and_verifyCheck a Solidity contract for Zenith gotchas, deploy it to testnet, verify it and trace the deployment to Canton.
send_to_canton_safelyRun every Gateway check before sending tokens from Zenith EVM to a Canton party.
investigate_missing_depositWork out what happened to a transfer between Zenith EVM and Canton.
audit_token_for_gatewayPre-screen an ERC-20 against Zenith's registration criteria.
port_ethereum_appReview an existing Solidity or dApp project for what changes on Zenith EVM.

Resources

Contextual data attached and managed by the client

NameDescription
networkLive network info: endpoints, latest block, Gateway deployment.
limits
gateway-tokensEvery token Gateway can move, with both sides described.
gateway-checklist
differences

TDQS

A3.7/5.0

Scored across 20 tools

Disambiguation4/5

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.

Naming Consistency4/5

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.

Tool Count4/5

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.

Completeness4/5

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.

Maintenance

ActivityMaintained
ResponsivenessNo recent community issues