zano-mcp 0.1.0

package/src/tools/register.ts

@@ -0,0 +1,194 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Config } from "../config.js";
+import { DaemonClient } from "../clients/daemon.js";
+import { WalletClient } from "../clients/wallet.js";
+import { TradeClient } from "../clients/trade.js";
+import { DaemonHandlers } from "./daemon/handlers.js";
+import { WalletHandlers } from "./wallet/handlers.js";
+import { AssetHandlers } from "./assets/handlers.js";
+import { SwapHandlers } from "./swap/handlers.js";
+import { TradeHandlers } from "./trade/handlers.js";
+import * as daemonDefs from "./daemon/definitions.js";
+import * as walletDefs from "./wallet/definitions.js";
+import * as assetDefs from "./assets/definitions.js";
+import * as swapDefs from "./swap/definitions.js";
+import * as tradeDefs from "./trade/definitions.js";
+import { logger } from "../logger.js";
+
+export function registerAllTools(server: McpServer, config: Config): void {
+  const daemonClient = new DaemonClient(config.daemonUrl);
+  registerDaemonTools(server, daemonClient);
+
+  if (config.walletUrl) {
+    const walletClient = new WalletClient(config.walletUrl, config.walletAuth);
+    registerWalletTools(server, new WalletHandlers(walletClient, daemonClient));
+    registerAssetTools(server, new AssetHandlers(walletClient));
+    registerSwapTools(server, new SwapHandlers(walletClient));
+    logger.info("Wallet/Asset/Swap tools registered");
+  } else {
+    logger.info("No ZANO_WALLET_URL set - wallet/asset/swap tools disabled");
+  }
+
+  const tradeClient = new TradeClient(config.tradeUrl, config.tradeToken);
+  registerTradeTools(server, new TradeHandlers(tradeClient), !!config.tradeToken);
+  logger.info("Trade tools registered");
+}
+
+function registerDaemonTools(server: McpServer, client: DaemonClient): void {
+  const h = new DaemonHandlers(client);
+
+  server.tool(
+    "get_network_info",
+    "Get Zano network status including height, difficulty, hashrate, connections, version",
+    daemonDefs.GetNetworkInfoShape,
+    async () => h.getNetworkInfo(),
+  );
+
+  server.tool(
+    "get_height",
+    "Get current Zano blockchain height",
+    daemonDefs.GetHeightShape,
+    async () => h.getHeight(),
+  );
+
+  server.tool(
+    "get_block_by_height",
+    "Get block header at a specific height",
+    daemonDefs.GetBlockByHeightShape,
+    async (args) => h.getBlockByHeight(args),
+  );
+
+  server.tool(
+    "get_block_by_hash",
+    "Get block header by its hash",
+    daemonDefs.GetBlockByHashShape,
+    async (args) => h.getBlockByHash(args),
+  );
+
+  server.tool(
+    "get_last_block",
+    "Get the latest block header",
+    daemonDefs.GetLastBlockShape,
+    async () => h.getLastBlock(),
+  );
+
+  server.tool(
+    "get_block_details",
+    "Get full block details including transactions",
+    daemonDefs.GetBlockDetailsShape,
+    async (args) => h.getBlockDetails(args),
+  );
+
+  server.tool(
+    "get_transaction",
+    "Get transaction details by hash",
+    daemonDefs.GetTransactionShape,
+    async (args) => h.getTransaction(args),
+  );
+
+  server.tool(
+    "get_transactions",
+    "Batch lookup of multiple transactions by their hashes",
+    daemonDefs.GetTransactionsShape,
+    async (args) => h.getTransactions(args),
+  );
+
+  server.tool(
+    "get_pool_info",
+    "Get mempool (transaction pool) status and pending transactions",
+    daemonDefs.GetPoolInfoShape,
+    async () => h.getPoolInfo(),
+  );
+
+  server.tool(
+    "get_asset_info",
+    "Get metadata for a registered asset by its ID",
+    daemonDefs.GetAssetInfoShape,
+    async (args) => h.getAssetInfo(args),
+  );
+
+  server.tool(
+    "get_assets_list",
+    "List all registered assets on the Zano blockchain",
+    daemonDefs.GetAssetsListShape,
+    async (args) => h.getAssetsList(args),
+  );
+
+  server.tool(
+    "resolve_alias",
+    "Resolve a Zano alias to its address",
+    daemonDefs.ResolveAliasShape,
+    async (args) => h.resolveAlias(args),
+  );
+
+  server.tool(
+    "get_alias_by_address",
+    "Look up the alias for a Zano address",
+    daemonDefs.GetAliasByAddressShape,
+    async (args) => h.getAliasByAddress(args),
+  );
+
+  server.tool(
+    "search_blockchain",
+    "Search the blockchain by hash, alias, or address",
+    daemonDefs.SearchBlockchainShape,
+    async (args) => h.searchBlockchain(args),
+  );
+
+  server.tool(
+    "validate_signature",
+    "Verify a signed message against an address",
+    daemonDefs.ValidateSignatureShape,
+    async (args) => h.validateSignature(args),
+  );
+
+  logger.info("Daemon tools registered (15 tools)");
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+function registerWalletTools(server: McpServer, h: WalletHandlers): void {
+  server.tool("get_balance", "Get wallet balance for all assets", walletDefs.GetBalanceShape, async () => h.getBalance());
+  server.tool("get_address", "Get wallet public address", walletDefs.GetAddressShape, async () => h.getAddress());
+  server.tool("get_wallet_status", "Get wallet sync status and info", walletDefs.GetWalletStatusShape, async () => h.getWalletStatus());
+  server.tool("transfer", "Send ZANO or assets to an address. Amounts in human-readable units.", walletDefs.TransferShape, async (args: any) => h.transfer(args));
+  server.tool("get_recent_transactions", "Get recent wallet transactions", walletDefs.GetRecentTransactionsShape, async (args: any) => h.getRecentTransactions(args));
+  server.tool("search_transactions", "Search wallet transactions by criteria", walletDefs.SearchTransactionsShape, async (args: any) => h.searchTransactions(args));
+  server.tool("sign_message", "Sign arbitrary data with the wallet", walletDefs.SignMessageShape, async (args: any) => h.signMessage(args));
+  server.tool("save_wallet", "Persist wallet state to disk", walletDefs.SaveWalletShape, async () => h.saveWallet());
+  server.tool("make_integrated_address", "Create an integrated address with payment ID", walletDefs.MakeIntegratedAddressShape, async (args: any) => h.makeIntegratedAddress(args));
+  server.tool("split_integrated_address", "Decode an integrated address", walletDefs.SplitIntegratedAddressShape, async (args: any) => h.splitIntegratedAddress(args));
+  server.tool("get_mining_history", "Get PoS staking reward history", walletDefs.GetMiningHistoryShape, async (args: any) => h.getMiningHistory(args));
+  server.tool("sweep_below", "Consolidate small outputs below a threshold", walletDefs.SweepBelowShape, async (args: any) => h.sweepBelow(args));
+}
+
+function registerAssetTools(server: McpServer, h: AssetHandlers): void {
+  server.tool("deploy_asset", "Deploy a new asset on Zano", assetDefs.DeployAssetShape, async (args: any) => h.deployAsset(args));
+  server.tool("emit_asset", "Mint additional supply of an asset", assetDefs.EmitAssetShape, async (args: any) => h.emitAsset(args));
+  server.tool("burn_asset", "Burn tokens of an asset", assetDefs.BurnAssetShape, async (args: any) => h.burnAsset(args));
+  server.tool("update_asset", "Update asset metadata", assetDefs.UpdateAssetShape, async (args: any) => h.updateAsset(args));
+  server.tool("transfer_asset_ownership", "Transfer ownership of an asset", assetDefs.TransferAssetOwnershipShape, async (args: any) => h.transferAssetOwnership(args));
+  server.tool("whitelist_asset", "Add an asset to the wallet whitelist", assetDefs.WhitelistAssetShape, async (args: any) => h.whitelistAsset(args));
+  server.tool("remove_asset_from_whitelist", "Remove an asset from the wallet whitelist", assetDefs.RemoveAssetFromWhitelistShape, async (args: any) => h.removeAssetFromWhitelist(args));
+}
+
+function registerSwapTools(server: McpServer, h: SwapHandlers): void {
+  server.tool("create_swap_proposal", "Create an ionic swap proposal. Amounts in human-readable units.", swapDefs.CreateSwapProposalShape, async (args: any) => h.createSwapProposal(args));
+  server.tool("get_swap_info", "Get details of an ionic swap proposal", swapDefs.GetSwapInfoShape, async (args: any) => h.getSwapInfo(args));
+  server.tool("accept_swap", "Accept and execute an ionic swap proposal", swapDefs.AcceptSwapShape, async (args: any) => h.acceptSwap(args));
+}
+
+function registerTradeTools(server: McpServer, h: TradeHandlers, hasAuth: boolean): void {
+  server.tool("get_trading_pair", "Get trading pair info by ID", tradeDefs.GetTradingPairShape, async (args: any) => h.getTradingPair(args));
+  server.tool("get_order_book", "Get order book for a trading pair", tradeDefs.GetOrderBookShape, async (args: any) => h.getOrderBook(args));
+
+  if (hasAuth) {
+    server.tool("create_order", "Create a buy/sell order on the DEX", tradeDefs.CreateOrderShape, async (args: any) => h.createOrder(args));
+    server.tool("cancel_order", "Cancel an active order", tradeDefs.CancelOrderShape, async (args: any) => h.cancelOrder(args));
+    server.tool("get_my_orders", "Get your active orders for a pair", tradeDefs.GetMyOrdersShape, async (args: any) => h.getMyOrders(args));
+    server.tool("apply_order", "Apply to match with another order (initiator role)", tradeDefs.ApplyOrderShape, async (args: any) => h.applyOrder(args));
+    server.tool("confirm_trade", "Confirm a finalized trade transaction", tradeDefs.ConfirmTradeShape, async (args: any) => h.confirmTrade(args));
+    server.tool("get_active_trade", "Get active transaction by order IDs", tradeDefs.GetActiveTradeShape, async (args: any) => h.getActiveTrade(args));
+    server.tool("dex_authenticate", "Authenticate with the Zano Trade API", tradeDefs.DexAuthenticateShape, async (args: any) => h.dexAuthenticate(args));
+  }
+}

package/src/tools/swap/definitions.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+
+const SwapAsset = z.object({
+  asset_id: z.string().describe("Asset ID"),
+  amount: z.string().describe("Amount in human-readable units"),
+});
+
+export const CreateSwapProposalShape = {
+  to_finalizer: z
+    .array(SwapAsset)
+    .describe("Assets to send TO the finalizer (what you give)"),
+  to_initiator: z
+    .array(SwapAsset)
+    .describe("Assets to receive FROM the finalizer (what you get)"),
+  destination_address: z.string().describe("Finalizer's Zano address"),
+  mixins: z.number().int().default(10).describe("Privacy parameter (default: 10)"),
+  fee: z.string().optional().describe("Fee in ZANO human units (default: 0.01)"),
+  expiration_time: z.number().int().default(0).describe("Expiration timestamp (0 = no expiry)"),
+};
+
+export const GetSwapInfoShape = {
+  hex_raw_proposal: z.string().describe("Hex-encoded swap proposal"),
+};
+
+export const AcceptSwapShape = {
+  hex_raw_proposal: z.string().describe("Hex-encoded swap proposal to accept"),
+};
+
+// Schemas and types
+export const CreateSwapProposalSchema = z.object(CreateSwapProposalShape);
+export const GetSwapInfoSchema = z.object(GetSwapInfoShape);
+export const AcceptSwapSchema = z.object(AcceptSwapShape);
+
+export type CreateSwapProposalInput = z.infer<typeof CreateSwapProposalSchema>;
+export type GetSwapInfoInput = z.infer<typeof GetSwapInfoSchema>;
+export type AcceptSwapInput = z.infer<typeof AcceptSwapSchema>;

package/src/tools/swap/handlers.ts

@@ -0,0 +1,139 @@
+import { WalletClient } from "../../clients/wallet.js";
+import {
+  humanToAtomic,
+  atomicToHuman,
+  formatAssetAmount,
+  getAssetInfo,
+} from "../../utils/formatting.js";
+import { ZANO_ASSET_ID, ZANO_DECIMALS, DEFAULT_FEE } from "../../utils/constants.js";
+import type {
+  CreateSwapProposalInput,
+  GetSwapInfoInput,
+  AcceptSwapInput,
+} from "./definitions.js";
+
+type ToolResult = { content: Array<{ type: "text"; text: string }> };
+function textResult(text: string): ToolResult {
+  return { content: [{ type: "text", text }] };
+}
+function errorResult(error: unknown): ToolResult {
+  const msg = error instanceof Error ? error.message : String(error);
+  return textResult(`Error: ${msg}`);
+}
+
+export class SwapHandlers {
+  private client: WalletClient;
+
+  constructor(client: WalletClient) {
+    this.client = client;
+  }
+
+  async createSwapProposal(input: CreateSwapProposalInput): Promise<ToolResult> {
+    try {
+      const toFinalizer = input.to_finalizer.map((a) => {
+        const info = getAssetInfo(a.asset_id);
+        const decimals = info?.decimals ?? ZANO_DECIMALS;
+        return {
+          asset_id: a.asset_id,
+          amount: humanToAtomic(a.amount, decimals),
+        };
+      });
+
+      const toInitiator = input.to_initiator.map((a) => {
+        const info = getAssetInfo(a.asset_id);
+        const decimals = info?.decimals ?? ZANO_DECIMALS;
+        return {
+          asset_id: a.asset_id,
+          amount: humanToAtomic(a.amount, decimals),
+        };
+      });
+
+      const fee = input.fee
+        ? humanToAtomic(input.fee, ZANO_DECIMALS)
+        : String(DEFAULT_FEE);
+
+      const res = await this.client.call<{ hex_raw_proposal: string }>(
+        "ionic_swap_generate_proposal",
+        {
+          proposal: {
+            to_finalizer: toFinalizer,
+            to_initiator: toInitiator,
+            mixins: input.mixins,
+            fee_paid_by_a: Number(fee),
+            expiration_time: input.expiration_time,
+          },
+          destination_address: input.destination_address,
+        },
+      );
+
+      const lines = [
+        "Swap Proposal Created",
+        "",
+        "You send (to finalizer):",
+      ];
+      for (const a of input.to_finalizer) {
+        lines.push(`  ${a.amount} ${getAssetInfo(a.asset_id)?.ticker || a.asset_id.slice(0, 12)}`);
+      }
+      lines.push("", "You receive (from finalizer):");
+      for (const a of input.to_initiator) {
+        lines.push(`  ${a.amount} ${getAssetInfo(a.asset_id)?.ticker || a.asset_id.slice(0, 12)}`);
+      }
+      lines.push("", `Hex proposal: ${res.hex_raw_proposal.slice(0, 40)}...`);
+      lines.push(`Full hex length: ${res.hex_raw_proposal.length} chars`);
+
+      return textResult(lines.join("\n"));
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async getSwapInfo(input: GetSwapInfoInput): Promise<ToolResult> {
+    try {
+      const res = await this.client.call<{ proposal: Record<string, unknown> }>(
+        "ionic_swap_get_proposal_info",
+        { hex_raw_proposal: input.hex_raw_proposal },
+      );
+
+      const proposal = res.proposal;
+      const lines = ["Swap Proposal Details"];
+
+      const toFinalizer = (proposal.to_finalizer || []) as Array<{ asset_id: string; amount: string | number }>;
+      const toInitiator = (proposal.to_initiator || []) as Array<{ asset_id: string; amount: string | number }>;
+
+      lines.push("", "Initiator sends (to finalizer):");
+      for (const a of toFinalizer) {
+        lines.push(`  ${formatAssetAmount(a.amount, a.asset_id)}`);
+      }
+
+      lines.push("", "Finalizer sends (to initiator):");
+      for (const a of toInitiator) {
+        lines.push(`  ${formatAssetAmount(a.amount, a.asset_id)}`);
+      }
+
+      lines.push(
+        "",
+        `Fee: ${proposal.fee_paid_by_a ? atomicToHuman(BigInt(String(proposal.fee_paid_by_a)), ZANO_DECIMALS) + " ZANO" : "N/A"}`,
+        `Mixins: ${proposal.mixins || "N/A"}`,
+        `Expiration: ${proposal.expiration_time === 0 ? "None" : String(proposal.expiration_time)}`,
+      );
+
+      return textResult(lines.join("\n"));
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async acceptSwap(input: AcceptSwapInput): Promise<ToolResult> {
+    try {
+      const res = await this.client.call<{ result_tx_id: string }>(
+        "ionic_swap_accept_proposal",
+        { hex_raw_proposal: input.hex_raw_proposal },
+      );
+      return textResult(
+        `Swap accepted and executed!\nTransaction ID: ${res.result_tx_id}`,
+      );
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+}

package/src/tools/trade/definitions.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+
+export const GetTradingPairShape = {
+  id: z.number().int().describe("Trading pair ID"),
+};
+
+export const GetOrderBookShape = {
+  pairId: z.number().int().describe("Trading pair ID"),
+};
+
+export const DexAuthenticateShape = {
+  address: z.string().describe("Zano wallet address"),
+  alias: z.string().optional().describe("Zano alias (optional)"),
+  message: z.string().describe("Message that was signed"),
+  signature: z.string().describe("Signature from wallet sign_message"),
+};
+
+export const CreateOrderShape = {
+  type: z.enum(["buy", "sell"]).describe("Order type"),
+  price: z.string().describe("Price per unit"),
+  amount: z.string().describe("Amount of asset"),
+  pairId: z.number().int().describe("Trading pair ID"),
+};
+
+export const CancelOrderShape = {
+  orderId: z.number().int().describe("Order ID to cancel"),
+};
+
+export const GetMyOrdersShape = {
+  pairId: z.number().int().describe("Trading pair ID"),
+};
+
+export const ApplyOrderShape = {
+  id: z.string().describe("Tip ID (from applyTips)"),
+  connected_order_id: z.string().describe("Your order ID that the tip matches"),
+  hex_raw_proposal: z.string().describe("Encrypted ionic swap proposal hex"),
+};
+
+export const ConfirmTradeShape = {
+  transactionId: z.number().int().describe("Transaction ID to confirm"),
+};
+
+export const GetActiveTradeShape = {
+  firstOrderId: z.number().int().describe("First order ID"),
+  secondOrderId: z.number().int().describe("Second order ID"),
+};
+
+// Schemas and types
+export const GetTradingPairSchema = z.object(GetTradingPairShape);
+export const GetOrderBookSchema = z.object(GetOrderBookShape);
+export const DexAuthenticateSchema = z.object(DexAuthenticateShape);
+export const CreateOrderSchema = z.object(CreateOrderShape);
+export const CancelOrderSchema = z.object(CancelOrderShape);
+export const GetMyOrdersSchema = z.object(GetMyOrdersShape);
+export const ApplyOrderSchema = z.object(ApplyOrderShape);
+export const ConfirmTradeSchema = z.object(ConfirmTradeShape);
+export const GetActiveTradeSchema = z.object(GetActiveTradeShape);
+
+export type GetTradingPairInput = z.infer<typeof GetTradingPairSchema>;
+export type GetOrderBookInput = z.infer<typeof GetOrderBookSchema>;
+export type DexAuthenticateInput = z.infer<typeof DexAuthenticateSchema>;
+export type CreateOrderInput = z.infer<typeof CreateOrderSchema>;
+export type CancelOrderInput = z.infer<typeof CancelOrderSchema>;
+export type GetMyOrdersInput = z.infer<typeof GetMyOrdersSchema>;
+export type ApplyOrderInput = z.infer<typeof ApplyOrderSchema>;
+export type ConfirmTradeInput = z.infer<typeof ConfirmTradeSchema>;
+export type GetActiveTradeInput = z.infer<typeof GetActiveTradeSchema>;