Tenzro Testnet is live. Get testnet TNZO

MCP Server

Tenzro Network runs a Model Context Protocol server at mcp.tenzro.network that exposes 146 tools across 26 categories covering wallets, identity, payments, AI models, agents, task marketplace, governance, cross-chain bridges, staking, tokens, contracts, NFTs, compliance, crypto primitives, TEE attestation, ZK proofs, and more. Any MCP-compatible client — Claude Desktop, Claude Code, Cursor, Windsurf, or a custom LLM — can connect and interact with the Tenzro Ledger through natural language.

What is MCP?

The Model Context Protocol (MCP) is an open standard for connecting LLMs to external tools and data sources. Tenzro's MCP server exposes every major subsystem — wallet creation, identity registration, payment challenges, inference routing, bridge transfers — as structured tool calls that any MCP-compatible assistant can invoke directly.

  • Transport: Streamable HTTP (MCP 2025-03-26) at /mcp
  • Implementation: rmcp crate, session-based with automatic reconnect
  • Authentication: JWT bearer tokens for authenticated operations, anonymous read access for public data
  • Endpoint: https://mcp.tenzro.network/mcp (live testnet)

Connect Claude Desktop

Add the Tenzro MCP server to your Claude Desktop config file at ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "tenzro": {
      "type": "http",
      "url": "https://mcp.tenzro.network/mcp"
    }
  }
}

Restart Claude Desktop. You should see tenzro listed under connected MCP servers, with all 146 tools available to Claude.

Connect Claude Code

# Add Tenzro MCP server via claude mcp add
claude mcp add tenzro https://mcp.tenzro.network/mcp

# Or locally during development
claude mcp add tenzro http://localhost:3001/mcp

Tools Overview

The 146 tools are organized into 26 categories. Each tool returns structured JSON that the LLM can parse and reason over. Below are the core categories with examples. For the full listing, connect to the MCP server and invoke tools/list.

Wallet & Ledger (4 tools)

  • get_balance — Get TNZO token balance by hex address
  • create_wallet — Create a new Ed25519 or Secp256k1 keypair
  • send_transaction — Send a TNZO transfer transaction
  • request_faucet — Request 100 testnet TNZO (24h cooldown per address)
// Call the get_balance tool
{
  "name": "get_balance",
  "arguments": {
    "address": "0xdfa52b634363dc604065ef5dbce468125ff6e704039f7896079811f93fc78910"
  }
}

// Response
{
  "address": "0xdfa52b634363dc604065ef5dbce468125ff6e704039f7896079811f93fc78910",
  "balance": "100000000000000000000",
  "balance_tnzo": "100.0",
  "asset": "TNZO"
}

Network & Blocks (3 tools)

  • get_node_status — Node health, block height, peer count, uptime, role
  • get_block — Retrieve a block by height with transactions and metadata
  • get_transaction — Look up a transaction by hash (type, sender, recipient, amount, status)

Identity & Delegation (3 tools)

  • register_identity — Register a human or machine DID via TDIP with auto-provisioned MPC wallet
  • resolve_did — Resolve a DID to its identity record and delegation scope
  • set_delegation_scope — Set spending limits, allowed operations, protocols, and chains for a machine DID
// Register a human identity
{
  "name": "register_identity",
  "arguments": {
    "identity_type": "human",
    "public_key": "0xed25519-public-key-hex",
    "display_name": "Alice",
    "kyc_tier": "Enhanced"
  }
}

// Register a machine identity with controller DID
{
  "name": "register_identity",
  "arguments": {
    "identity_type": "machine",
    "public_key": "0xed25519-public-key-hex",
    "controller_did": "did:tenzro:human:alice-uuid",
    "capabilities": ["inference", "trading"]
  }
}

// Set delegation scope for a machine
{
  "name": "set_delegation_scope",
  "arguments": {
    "did": "did:tenzro:machine:alice:bot-uuid",
    "max_transaction_value": "100000000000000000000",
    "max_daily_spend": "500000000000000000000",
    "allowed_operations": ["inference", "payment"],
    "allowed_payment_protocols": ["mpp", "x402"],
    "allowed_chains": ["tenzro", "ethereum"]
  }
}

Payments (3 tools)

  • create_payment_challenge — Create an MPP (session-based), x402 (stateless), or native payment challenge
  • verify_payment — Verify a payment credential against a challenge and settle on-chain
  • list_payment_protocols — List all supported payment protocols (MPP, x402, native, Visa TAP, Mastercard Agent Pay)
// Create an MPP session-based challenge
{
  "name": "create_payment_challenge",
  "arguments": {
    "protocol": "mpp",
    "resource": "/api/inference/gemma3-270m",
    "amount": "1000",
    "asset": "USDC",
    "recipient": "0xrecipient..."
  }
}

// Or a stateless x402 challenge
{
  "name": "create_payment_challenge",
  "arguments": {
    "protocol": "x402",
    "resource": "/api/download/model.safetensors",
    "amount": "5000",
    "asset": "USDC",
    "chain": "tenzro"
  }
}

AI Models & Inference (3 tools)

  • list_models — List available AI models, filtered by category, modality, or name
  • chat_completion — Send a chat completion request to any served model (OpenAI-compatible format)
  • list_model_endpoints — List all model service endpoints with API/MCP URLs and current status

Cross-Chain Bridge (3 tools)

  • bridge_tokens — Bridge tokens between Tenzro, Ethereum, Solana, Base via LayerZero, CCIP, or deBridge
  • get_bridge_routes — Get available routes between two chains with real-time fees and timing
  • list_bridge_adapters — List registered bridge adapters and their supported chain pairs
// Bridge TNZO from Tenzro to Ethereum
{
  "name": "bridge_tokens",
  "arguments": {
    "from_chain": "tenzro",
    "to_chain": "ethereum",
    "token": "TNZO",
    "amount": "1000000000000000000000",
    "recipient": "0xevm-recipient...",
    "adapter": "layerzero"
  }
}

// Get all routes between two chains
{
  "name": "get_bridge_routes",
  "arguments": {
    "from_chain": "tenzro",
    "to_chain": "solana"
  }
}

Verification (1 tool)

  • verify_zk_proof — Verify a Groth16, PlonK, or STARK proof with its public inputs and verifying key
// Verify a Groth16 ZK proof
{
  "name": "verify_zk_proof",
  "arguments": {
    "proof_type": "Groth16",
    "proof": "0xproof-bytes-hex",
    "public_inputs": ["0xinput1...", "0xinput2..."],
    "verifying_key_id": "inference-verification-circuit"
  }
}

Staking & Providers (4 tools)

  • stake_tokens — Stake TNZO tokens as Validator, ModelProvider, or TeeProvider
  • unstake_tokens — Unstake TNZO tokens (initiates the 7-day unbonding period)
  • register_provider — Register as a provider with optional initial staking
  • get_provider_stats — Get provider statistics: models served, inferences completed, total stake
// Stake as a validator
{
  "name": "stake_tokens",
  "arguments": {
    "address": "0xvalidator...",
    "amount": "100000000000000000000000",
    "role": "Validator"
  }
}

// Register as a model provider with initial stake
{
  "name": "register_provider",
  "arguments": {
    "address": "0xprovider...",
    "role": "ModelProvider",
    "stake_amount": "10000000000000000000000"
  }
}

Tokens & Contracts (7 tools)

  • create_token — Create ERC-20 token via factory, register in unified registry
  • get_token_info — Lookup token by symbol, EVM address, or token ID
  • list_tokens — List registered tokens with optional VM type filter
  • deploy_contract — Deploy bytecode to EVM/SVM/DAML via MultiVmRuntime
  • cross_vm_transfer — Atomic cross-VM token transfer (TNZO pointer model)
  • wrap_tnzo — Wrap native TNZO to VM representation (no-op in pointer model)
  • get_token_balance — Get TNZO balance across all VMs with decimal conversion
// Create an ERC-20 token via the factory
{
  "name": "create_token",
  "arguments": {
    "name": "My Token",
    "symbol": "MTK",
    "decimals": 18,
    "initial_supply": "1000000000000000000000000",
    "creator": "0xcreator-address..."
  }
}

// Response
{
  "token_id": "tok_abc123...",
  "symbol": "MTK",
  "evm_address": "0xtoken-contract-address...",
  "vm_type": "EVM",
  "initial_supply": "1000000000000000000000000"
}
// Atomic cross-VM token transfer (TNZO pointer model)
{
  "name": "cross_vm_transfer",
  "arguments": {
    "from_vm": "EVM",
    "to_vm": "SVM",
    "token": "TNZO",
    "amount": "5000000000000000000",
    "sender": "0xevm-sender...",
    "recipient": "solana-recipient-pubkey..."
  }
}

// Response
{
  "transfer_id": "xvm_abc123...",
  "from_vm": "EVM",
  "to_vm": "SVM",
  "amount": "5000000000000000000",
  "status": "completed"
}

Task Marketplace (7 tools)

  • post_task — Post a new AI task to the decentralized marketplace
  • list_tasks — Browse and filter open tasks
  • quote_task — Submit a price quote as a provider
  • get_task — Get details of a specific task by ID
  • cancel_task — Cancel a pending task
  • assign_task — Assign a task to an agent
  • complete_task — Mark a task as completed with a result

Agent Template Marketplace (7 tools)

  • register_agent_template — Publish a reusable agent template
  • list_agent_templates — Browse and filter published templates
  • get_agent_template — Get full details of an agent template
  • download_agent_template — Instantiate a template with custom config
  • update_agent_template — Update metadata on an existing template
  • search_agent_templates — Search templates by name, category, or capability
  • get_agent_template_stats — Get usage statistics for a template

Agent Spawning & Swarms (5 tools)

  • spawn_agent — Spawn a child agent under a parent (max 50 per parent)
  • run_agent_task — Run an agentic task loop (LLM + tools, up to 10 steps)
  • create_swarm — Create a swarm of coordinated agents
  • get_swarm_status — Get swarm status and all member details
  • terminate_swarm — Terminate a swarm and all its member agents

Agent Advanced (5 tools)

  • register_agent — Register a new agent identity
  • send_agent_message — Send a message from one agent to another
  • delegate_task — Delegate a task to another agent with optional budget
  • discover_models — Discover models with category/price filters
  • discover_agents — Discover agents by capability or type

Model Lifecycle (5 tools)

  • download_model — Download a model from HuggingFace Hub
  • serve_model_mcp — Start serving a downloaded model
  • stop_model — Stop serving a model
  • delete_model_mcp — Delete a downloaded model from disk
  • get_download_progress — Check download progress

Governance (5 tools)

  • list_proposals — List governance proposals
  • vote_on_proposal — Vote yes/no/abstain on a proposal
  • create_proposal — Create a new governance proposal
  • get_voting_power — Get voting power for an address
  • delegate_voting_power — Delegate voting power to another address

Provider Config (4 tools)

  • set_provider_schedule — Set provider availability schedule
  • get_provider_schedule — Get current schedule
  • set_provider_pricing — Set per-token pricing
  • get_provider_pricing — Get current pricing config

Settlement (5 tools)

  • settle_payment — Immediately settle a payment
  • create_escrow — Create an escrow contract
  • release_escrow — Release escrow with authorizing signature
  • open_payment_channel — Open a micropayment channel
  • close_payment_channel — Close channel with final balance

Canton / DAML (3 tools)

  • list_canton_domains — List connected Canton synchronizer domains
  • list_daml_contracts — List active DAML contracts
  • submit_daml_command — Submit DAML create/exercise commands

NFTs (6 tools)

  • create_nft_collection — Create an NFT collection
  • mint_nft — Mint a new NFT token
  • transfer_nft — Transfer an NFT to another address
  • get_nft_info — Get NFT metadata and ownership
  • list_nft_collections — List all NFT collections
  • register_nft_pointer — Register cross-VM NFT pointer

Compliance / ERC-3643 (3 tools)

  • check_compliance — Check if a transfer is compliant
  • register_compliance — Register compliance rules for a token
  • freeze_address — Freeze/unfreeze an address

Cross-Chain Advanced (5 tools)

  • bridge_quote — Get a cross-chain bridge quote with hook support
  • bridge_with_hook — Execute a cross-chain transfer with post-bridge hooks
  • crosschain_mint — ERC-7802 cross-chain mint
  • crosschain_burn — ERC-7802 cross-chain burn
  • authorize_crosschain_bridge — Authorize a bridge for cross-chain operations

Events (3 tools)

  • get_events — Query events by type, address, or block range
  • subscribe_events — Subscribe to real-time event notifications
  • register_webhook — Register a webhook for event delivery

Crypto Primitives (9 tools)

  • sign_message — Sign a message with Ed25519 or Secp256k1
  • verify_signature — Verify a cryptographic signature
  • encrypt_data — Encrypt data with AES-256-GCM
  • decrypt_data — Decrypt AES-256-GCM ciphertext
  • derive_key — Derive a key via HKDF-SHA256
  • generate_keypair — Generate a new keypair
  • hash_sha256 — Compute SHA-256 hash
  • hash_keccak256 — Compute Keccak-256 hash
  • x25519_key_exchange — Perform X25519 Diffie-Hellman key exchange

TEE (6 tools)

  • detect_tee — Detect available TEE hardware
  • get_tee_attestation — Generate a TEE attestation report
  • verify_tee_attestation — Verify a TEE attestation
  • seal_data — Seal data inside TEE enclave
  • unseal_data — Unseal data from TEE enclave
  • list_tee_providers — List registered TEE providers

ZK Proofs (3 tools)

  • create_zk_proof — Generate a ZK proof for a circuit
  • generate_proving_key — Generate a proving key for a circuit
  • list_zk_circuits — List available ZK circuits

Wallet Advanced (8 tools)

  • create_mpc_wallet — Create a 2-of-3 MPC threshold wallet
  • export_keystore — Export encrypted keystore
  • import_keystore — Import from encrypted keystore
  • get_key_shares — Get key share info for an MPC wallet
  • rotate_keys — Rotate MPC key shares
  • set_spending_limits — Set daily/per-tx spending limits
  • get_spending_limits — Get current spending limits
  • authorize_session / revoke_session — Manage session keys

Apps & Sponsorship (5 tools)

  • register_app — Register an application with master wallet
  • create_user_wallet — Create a sub-wallet for an app user
  • fund_user_wallet — Fund a user wallet from master wallet
  • list_user_wallets — List all user wallets for an app
  • sponsor_transaction — Sponsor a transaction for a user

deBridge DLN (5 tools)

  • debridge_search_tokens — Search tokens on deBridge
  • debridge_get_chains — List deBridge supported chains
  • debridge_get_instructions — Get operational instructions
  • debridge_create_tx — Create a cross-chain transaction
  • debridge_same_chain_swap — Execute a same-chain swap

Usernames & Utility (4 tools)

  • set_username — Set a human-readable username for an address
  • resolve_username — Resolve a username to an address
  • encode_function — ABI-encode a function call
  • decode_result — ABI-decode a contract call result

Authentication

Read-only tools (get_balance, get_node_status, get_block, list_models, list_payment_protocols, resolve_did, list_bridge_adapters, get_bridge_routes, verify_zk_proof) are accessible anonymously. Tools that mutate state or spend tokens (send_transaction, register_identity, stake_tokens, bridge_tokens, create_payment_challenge, verify_payment) require a JWT bearer token.

JWT tokens are issued by the node's OAuth endpoint after authenticating with a TDIP DID. The token encodes the DID in its sub claim and the wallet address in its address claim. Every authenticated tool call is delegation-scope-checked against the associated identity.

Running Your Own MCP Server

When you run a Tenzro node, the MCP server starts automatically on 0.0.0.0:3001. Override the bind address with the --mcp-addr CLI flag or by setting mcp_addr in config.toml:

# Run a node with MCP on a custom port
cargo run --bin tenzro-node -- \
  --role validator \
  --listen-addr /ip4/0.0.0.0/tcp/9000 \
  --mcp-addr 0.0.0.0:4001

# Or via config.toml
[server]
mcp_addr = "0.0.0.0:4001"

Related Resources