zano-mcp 0.1.0

package/src/tools/trade/handlers.ts

@@ -0,0 +1,264 @@
+import { TradeClient } from "../../clients/trade.js";
+import type {
+  GetTradingPairInput,
+  GetOrderBookInput,
+  DexAuthenticateInput,
+  CreateOrderInput,
+  CancelOrderInput,
+  GetMyOrdersInput,
+  ApplyOrderInput,
+  ConfirmTradeInput,
+  GetActiveTradeInput,
+} 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 TradeHandlers {
+  private client: TradeClient;
+
+  constructor(client: TradeClient) {
+    this.client = client;
+  }
+
+  async getTradingPair(input: GetTradingPairInput): Promise<ToolResult> {
+    try {
+      const data = await this.client.post<Record<string, unknown>>(
+        "/api/dex/get-pair",
+        { id: input.id },
+      );
+      const pair = data;
+      const first = (pair.first_currency as Record<string, unknown>) || {};
+      const second = (pair.second_currency as Record<string, unknown>) || {};
+      const lines = [
+        `Trading Pair #${pair.id}`,
+        `  ${first.code || first.name || "?"} / ${second.code || second.name || "?"}`,
+        `  Rate: ${pair.rate}`,
+        `  24h High: ${pair.high}`,
+        `  24h Low: ${pair.low}`,
+        `  Volume: ${pair.volume}`,
+      ];
+      return textResult(lines.join("\n"));
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async getOrderBook(input: GetOrderBookInput): Promise<ToolResult> {
+    try {
+      const orders = await this.client.post<Array<Record<string, unknown>>>(
+        "/api/orders/get-page",
+        { pairId: input.pairId },
+      );
+
+      if (!orders || orders.length === 0) {
+        return textResult(`No orders found for pair ${input.pairId}.`);
+      }
+
+      const buys = orders.filter((o) => o.type === "buy").sort((a, b) => parseFloat(String(b.price)) - parseFloat(String(a.price)));
+      const sells = orders.filter((o) => o.type === "sell").sort((a, b) => parseFloat(String(a.price)) - parseFloat(String(b.price)));
+
+      const lines = [`Order Book for Pair ${input.pairId} (${orders.length} orders):`];
+
+      if (sells.length > 0) {
+        lines.push("", "  SELLS (asks):");
+        for (const o of sells) {
+          const user = (o.user as Record<string, unknown>) || {};
+          const instant = o.isInstant ? " [INSTANT]" : "";
+          lines.push(
+            `    ${o.price} | ${o.left} remaining (of ${o.amount}) | ${user.alias || "anon"}${instant}`,
+          );
+        }
+      }
+
+      if (buys.length > 0) {
+        lines.push("", "  BUYS (bids):");
+        for (const o of buys) {
+          const user = (o.user as Record<string, unknown>) || {};
+          const instant = o.isInstant ? " [INSTANT]" : "";
+          lines.push(
+            `    ${o.price} | ${o.left} remaining (of ${o.amount}) | ${user.alias || "anon"}${instant}`,
+          );
+        }
+      }
+
+      if (buys.length > 0 && sells.length > 0) {
+        const bestBid = parseFloat(String(buys[0].price));
+        const bestAsk = parseFloat(String(sells[0].price));
+        const spread = bestAsk - bestBid;
+        const spreadPct = ((spread / bestAsk) * 100).toFixed(2);
+        lines.push("", `  Spread: ${spread.toFixed(8)} (${spreadPct}%)`);
+        lines.push(`  Best bid: ${bestBid} | Best ask: ${bestAsk}`);
+      }
+
+      return textResult(lines.join("\n"));
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async dexAuthenticate(input: DexAuthenticateInput): Promise<ToolResult> {
+    try {
+      const data = await this.client.post<Record<string, unknown>>(
+        "/api/auth",
+        {
+          data: {
+            address: input.address,
+            alias: input.alias || "",
+            message: input.message,
+            signature: input.signature,
+          },
+          neverExpires: true,
+        },
+      );
+      if (data && typeof data === "string") {
+        this.client.setToken(data);
+        return textResult(`Authenticated with Trade API. Token stored.`);
+      }
+      return textResult(`Authentication response: ${JSON.stringify(data)}`);
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async createOrder(input: CreateOrderInput): Promise<ToolResult> {
+    try {
+      const data = await this.client.post<Record<string, unknown>>(
+        "/api/orders/create",
+        {
+          orderData: {
+            type: input.type,
+            side: "limit",
+            price: input.price,
+            amount: input.amount,
+            pairId: input.pairId,
+          },
+        },
+        true,
+      );
+      return textResult(
+        `Order created!\n  ID: ${data.id}\n  Type: ${data.type}\n  Price: ${data.price}\n  Amount: ${data.amount}\n  Status: ${data.status}`,
+      );
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async cancelOrder(input: CancelOrderInput): Promise<ToolResult> {
+    try {
+      await this.client.post(
+        "/api/orders/cancel",
+        { orderId: input.orderId },
+        true,
+      );
+      return textResult(`Order ${input.orderId} cancelled.`);
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async getMyOrders(input: GetMyOrdersInput): Promise<ToolResult> {
+    try {
+      const data = await this.client.post<Record<string, unknown>>(
+        "/api/orders/get-user-page",
+        { pairId: input.pairId },
+        true,
+      );
+      const orders = (data.orders || []) as Array<Record<string, unknown>>;
+      const tips = (data.applyTips || []) as Array<Record<string, unknown>>;
+
+      const lines = [`Your Orders for Pair ${input.pairId}:`];
+
+      if (orders.length === 0) {
+        lines.push("  No active orders.");
+      } else {
+        for (const o of orders) {
+          const instant = o.isInstant ? " [INSTANT]" : "";
+          lines.push(
+            `  #${o.id} ${o.type} ${o.left}/${o.amount} @ ${o.price}${instant}`,
+          );
+        }
+      }
+
+      if (tips.length > 0) {
+        lines.push("", `  Pending Tips (${tips.length}):`);
+        for (const t of tips) {
+          const user = (t.user as Record<string, unknown>) || {};
+          const hasTx = t.transaction ? " [HAS TX]" : "";
+          lines.push(
+            `    Tip #${t.id} for order #${t.connected_order_id} | ${t.left} @ ${t.price} | ${user.alias || "anon"}${hasTx}`,
+          );
+        }
+      }
+
+      return textResult(lines.join("\n"));
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async applyOrder(input: ApplyOrderInput): Promise<ToolResult> {
+    try {
+      await this.client.post(
+        "/api/orders/apply-order",
+        {
+          orderData: {
+            id: input.id,
+            connected_order_id: input.connected_order_id,
+            hex_raw_proposal: input.hex_raw_proposal,
+          },
+        },
+        true,
+      );
+      return textResult(`Applied to order. Tip ID: ${input.id}, connected to order: ${input.connected_order_id}`);
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async confirmTrade(input: ConfirmTradeInput): Promise<ToolResult> {
+    try {
+      await this.client.post(
+        "/api/transactions/confirm",
+        { transactionId: input.transactionId },
+        true,
+      );
+      return textResult(`Trade ${input.transactionId} confirmed.`);
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async getActiveTrade(input: GetActiveTradeInput): Promise<ToolResult> {
+    try {
+      const data = await this.client.post<Record<string, unknown>>(
+        "/api/transactions/get-active-tx-by-orders-ids",
+        {
+          firstOrderId: input.firstOrderId,
+          secondOrderId: input.secondOrderId,
+        },
+        true,
+      );
+      const lines = [
+        `Active Trade:`,
+        `  Buy order: ${data.buy_order_id}`,
+        `  Sell order: ${data.sell_order_id}`,
+        `  Amount: ${data.amount}`,
+        `  Status: ${data.status}`,
+        `  Creator: ${data.creator || "N/A"}`,
+      ];
+      if (data.hex_raw_proposal) {
+        lines.push(`  Has proposal hex: Yes (${String(data.hex_raw_proposal).length} chars)`);
+      }
+      return textResult(lines.join("\n"));
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+}

package/src/tools/wallet/definitions.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+
+export const GetBalanceShape = {};
+export const GetAddressShape = {};
+export const GetWalletStatusShape = {};
+
+export const TransferShape = {
+  address: z.string().describe("Destination address"),
+  amount: z.string().describe("Amount in human-readable units (e.g. '1.5')"),
+  asset_id: z
+    .string()
+    .optional()
+    .describe("Asset ID to send. Omit for ZANO"),
+  payment_id: z.string().optional().describe("Payment ID (optional)"),
+  comment: z.string().optional().describe("Transaction comment (optional)"),
+  fee: z
+    .string()
+    .optional()
+    .describe("Fee in human-readable ZANO (default: 0.01)"),
+  mixin: z
+    .number()
+    .int()
+    .optional()
+    .describe("Mixin count (default: 15 normal, 0 auditable)"),
+};
+
+export const GetRecentTransactionsShape = {
+  offset: z.number().int().min(0).default(0).describe("Offset"),
+  count: z.number().int().min(1).max(100).default(20).describe("Number of transactions"),
+};
+
+export const SearchTransactionsShape = {
+  tx_id: z.string().optional().describe("Transaction hash to search for"),
+  in: z.boolean().optional().describe("Include incoming transactions"),
+  out: z.boolean().optional().describe("Include outgoing transactions"),
+  pool: z.boolean().optional().describe("Include pool transactions"),
+  filter_by_height: z.boolean().optional(),
+  min_height: z.number().int().optional(),
+  max_height: z.number().int().optional(),
+};
+
+export const SignMessageShape = {
+  message: z.string().describe("Message to sign"),
+};
+
+export const SaveWalletShape = {};
+
+export const MakeIntegratedAddressShape = {
+  payment_id: z
+    .string()
+    .optional()
+    .describe("Payment ID (auto-generated if omitted)"),
+};
+
+export const SplitIntegratedAddressShape = {
+  integrated_address: z.string().describe("Integrated address to decode"),
+};
+
+export const GetMiningHistoryShape = {
+  v: z.number().int().default(0).describe("Version (0)"),
+};
+
+export const SweepBelowShape = {
+  address: z.string().describe("Address to sweep to"),
+  amount: z
+    .string()
+    .describe("Threshold in human-readable ZANO - sweep outputs below this"),
+  mixin: z.number().int().optional().describe("Mixin count (default: 15)"),
+  fee: z
+    .string()
+    .optional()
+    .describe("Fee in human-readable ZANO (default: 0.01)"),
+};
+
+// Schemas and types
+export const TransferSchema = z.object(TransferShape);
+export const GetRecentTransactionsSchema = z.object(GetRecentTransactionsShape);
+export const SearchTransactionsSchema = z.object(SearchTransactionsShape);
+export const SignMessageSchema = z.object(SignMessageShape);
+export const MakeIntegratedAddressSchema = z.object(MakeIntegratedAddressShape);
+export const SplitIntegratedAddressSchema = z.object(SplitIntegratedAddressShape);
+export const GetMiningHistorySchema = z.object(GetMiningHistoryShape);
+export const SweepBelowSchema = z.object(SweepBelowShape);
+
+export type TransferInput = z.infer<typeof TransferSchema>;
+export type GetRecentTransactionsInput = z.infer<typeof GetRecentTransactionsSchema>;
+export type SearchTransactionsInput = z.infer<typeof SearchTransactionsSchema>;
+export type SignMessageInput = z.infer<typeof SignMessageSchema>;
+export type MakeIntegratedAddressInput = z.infer<typeof MakeIntegratedAddressSchema>;
+export type SplitIntegratedAddressInput = z.infer<typeof SplitIntegratedAddressSchema>;
+export type GetMiningHistoryInput = z.infer<typeof GetMiningHistorySchema>;
+export type SweepBelowInput = z.infer<typeof SweepBelowSchema>;

package/src/tools/wallet/handlers.ts

@@ -0,0 +1,268 @@
+import { WalletClient } from "../../clients/wallet.js";
+import { DaemonClient } from "../../clients/daemon.js";
+import {
+  atomicToHuman,
+  humanToAtomic,
+  formatAssetAmount,
+  formatTimestamp,
+  formatZano,
+  getAssetInfo,
+  registerAsset,
+} from "../../utils/formatting.js";
+import { ZANO_ASSET_ID, ZANO_DECIMALS, DEFAULT_FEE, DEFAULT_MIXIN } from "../../utils/constants.js";
+import type {
+  TransferInput,
+  GetRecentTransactionsInput,
+  SearchTransactionsInput,
+  SignMessageInput,
+  MakeIntegratedAddressInput,
+  SplitIntegratedAddressInput,
+  GetMiningHistoryInput,
+  SweepBelowInput,
+} 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 WalletHandlers {
+  private client: WalletClient;
+  private daemon: DaemonClient;
+
+  constructor(client: WalletClient, daemon: DaemonClient) {
+    this.client = client;
+    this.daemon = daemon;
+  }
+
+  async getBalance(): Promise<ToolResult> {
+    try {
+      const res = await this.client.call<Record<string, unknown>>("getbalance");
+      const lines = ["Wallet Balance:"];
+
+      const balance = BigInt(String(res.balance || 0));
+      const unlocked = BigInt(String(res.unlocked_balance || 0));
+      lines.push(`  ZANO: ${atomicToHuman(unlocked, ZANO_DECIMALS)} (locked: ${atomicToHuman(balance - unlocked, ZANO_DECIMALS)})`);
+
+      const balances = res.balances as Array<Record<string, unknown>> | undefined;
+      if (balances && balances.length > 0) {
+        for (const b of balances) {
+          const assetId = String(b.asset_id || "");
+          if (assetId === ZANO_ASSET_ID) continue;
+          const assetInfo = (b.asset_info as Record<string, unknown>) || {};
+          const ticker = String(assetInfo.ticker || assetId.slice(0, 8));
+          const decimals = Number(assetInfo.decimal_point ?? 12);
+          registerAsset(assetId, ticker, decimals);
+
+          const bal = BigInt(String(b.balance || 0));
+          const ubal = BigInt(String(b.unlocked || 0));
+          lines.push(`  ${ticker}: ${atomicToHuman(ubal, decimals)} (locked: ${atomicToHuman(bal - ubal, decimals)})`);
+        }
+      }
+
+      return textResult(lines.join("\n"));
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async getAddress(): Promise<ToolResult> {
+    try {
+      const res = await this.client.call<Record<string, unknown>>("getaddress");
+      return textResult(`Wallet address: ${res.address}`);
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async getWalletStatus(): Promise<ToolResult> {
+    try {
+      const res = await this.client.call<Record<string, unknown>>("get_wallet_info");
+      const lines = [
+        "Wallet Status:",
+        `  Address: ${res.address || "N/A"}`,
+        `  Current height: ${res.current_height || "N/A"}`,
+        `  Daemon height: ${res.current_daemon_height || "N/A"}`,
+        `  Watch only: ${res.is_whatch_only ? "Yes" : "No"}`,
+        `  In audit: ${res.is_auditable ? "Yes" : "No"}`,
+        `  Min confirmations: ${res.mincounted_transfer_count ?? "N/A"}`,
+        `  Transfer count: ${res.transfer_entries_count ?? "N/A"}`,
+      ];
+      return textResult(lines.join("\n"));
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async transfer(input: TransferInput): Promise<ToolResult> {
+    try {
+      const assetId = input.asset_id || ZANO_ASSET_ID;
+      const info = getAssetInfo(assetId);
+      const decimals = info?.decimals ?? ZANO_DECIMALS;
+      const atomicAmount = humanToAtomic(input.amount, decimals);
+      const mixin = input.mixin ?? DEFAULT_MIXIN;
+      const fee = input.fee ? humanToAtomic(input.fee, ZANO_DECIMALS) : String(DEFAULT_FEE);
+
+      const dest: Record<string, unknown> = {
+        address: input.address,
+        amount: atomicAmount,
+      };
+      if (assetId !== ZANO_ASSET_ID) {
+        dest.asset_id = assetId;
+      }
+
+      const params: Record<string, unknown> = {
+        destinations: [dest],
+        fee: Number(fee),
+        mixin,
+      };
+
+      if (input.payment_id) params.payment_id = input.payment_id;
+      if (input.comment) params.comment = input.comment;
+
+      const res = await this.client.call<Record<string, unknown>>("transfer", params);
+      const ticker = info?.ticker || "ZANO";
+      return textResult(
+        `Transfer sent: ${input.amount} ${ticker} to ${input.address}\nTX hash: ${res.tx_hash}\nTX size: ${res.tx_size || "N/A"} bytes`,
+      );
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async getRecentTransactions(input: GetRecentTransactionsInput): Promise<ToolResult> {
+    try {
+      const res = await this.client.call<Record<string, unknown>>(
+        "get_recent_txs_and_info",
+        { offset: input.offset, count: input.count, update_provision_info: true },
+      );
+      const transfers = (res.transfers || []) as Array<Record<string, unknown>>;
+      if (transfers.length === 0) {
+        return textResult("No recent transactions found.");
+      }
+      const lines = [`Recent Transactions (${transfers.length}):`];
+      for (const tx of transfers) {
+        const dir = tx.is_income ? "IN" : "OUT";
+        const amount = tx.amount ? formatZano(tx.amount as number) : "N/A";
+        const ts = formatTimestamp(Number(tx.timestamp || 0));
+        const hash = String(tx.tx_hash || "").slice(0, 16);
+        const comment = tx.comment ? ` "${tx.comment}"` : "";
+        lines.push(`  [${dir}] ${amount} | ${ts} | ${hash}...${comment}`);
+      }
+      return textResult(lines.join("\n"));
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async searchTransactions(input: SearchTransactionsInput): Promise<ToolResult> {
+    try {
+      const res = await this.client.call<Record<string, unknown>>(
+        "search_for_transactions",
+        input,
+      );
+      return textResult(JSON.stringify(res, null, 2));
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async signMessage(input: SignMessageInput): Promise<ToolResult> {
+    try {
+      // sign_message requires base64 encoded message
+      const b64 = Buffer.from(input.message).toString("base64");
+      const res = await this.client.call<{ sig: string }>("sign_message", { buff: b64 });
+      return textResult(`Signature: ${res.sig}`);
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async saveWallet(): Promise<ToolResult> {
+    try {
+      await this.client.call("store");
+      return textResult("Wallet state saved.");
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async makeIntegratedAddress(input: MakeIntegratedAddressInput): Promise<ToolResult> {
+    try {
+      const params: Record<string, unknown> = {};
+      if (input.payment_id) params.payment_id = input.payment_id;
+      const res = await this.client.call<Record<string, unknown>>(
+        "make_integrated_address",
+        params,
+      );
+      return textResult(
+        `Integrated address: ${res.integrated_address}\nPayment ID: ${res.payment_id}`,
+      );
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async splitIntegratedAddress(input: SplitIntegratedAddressInput): Promise<ToolResult> {
+    try {
+      const res = await this.client.call<Record<string, unknown>>(
+        "split_integrated_address",
+        { integrated_address: input.integrated_address },
+      );
+      return textResult(
+        `Standard address: ${res.standard_address}\nPayment ID: ${res.payment_id}`,
+      );
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async getMiningHistory(input: GetMiningHistoryInput): Promise<ToolResult> {
+    try {
+      const res = await this.client.call<Record<string, unknown>>(
+        "get_mining_history",
+        { v: input.v },
+      );
+      const history = (res.mined_entries || []) as Array<Record<string, unknown>>;
+      if (history.length === 0) {
+        return textResult("No staking history found.");
+      }
+      const lines = [`Staking History (${history.length} entries):`];
+      for (const entry of history) {
+        const amount = entry.a ? formatZano(entry.a as number) : "N/A";
+        const ts = formatTimestamp(Number(entry.t || 0));
+        lines.push(`  ${ts} | ${amount} | Block ${entry.h || "N/A"}`);
+      }
+      return textResult(lines.join("\n"));
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+
+  async sweepBelow(input: SweepBelowInput): Promise<ToolResult> {
+    try {
+      const atomicAmount = humanToAtomic(input.amount, ZANO_DECIMALS);
+      const mixin = input.mixin ?? DEFAULT_MIXIN;
+      const fee = input.fee ? humanToAtomic(input.fee, ZANO_DECIMALS) : String(DEFAULT_FEE);
+
+      const res = await this.client.call<Record<string, unknown>>(
+        "sweep_below",
+        {
+          address: input.address,
+          amount: Number(atomicAmount),
+          mixin,
+          fee: Number(fee),
+        },
+      );
+      return textResult(
+        `Sweep complete.\nTX hash: ${res.tx_hash}\nAmount swept: ${res.amount ? formatZano(res.amount as number) : "N/A"}`,
+      );
+    } catch (e) {
+      return errorResult(e);
+    }
+  }
+}

package/src/utils/constants.ts

@@ -0,0 +1,24 @@
+export const ZANO_ASSET_ID =
+  "d6329b5b1f7c0805b5c345f4957554002a2f557845f64d7645dae0e051a6498a";
+
+export const DEFAULT_PORTS = {
+  mainnet: { daemon: 11211, wallet: 11212 },
+  testnet: { daemon: 12211, wallet: 12212 },
+} as const;
+
+export const PUBLIC_NODES = {
+  mainnet: "http://37.27.100.59:10500/json_rpc",
+  testnet: "http://37.27.100.59:10505/json_rpc",
+} as const;
+
+export const ASSET_WHITELIST_URLS = {
+  mainnet: "https://api.zano.org/assets_whitelist.json",
+  testnet: "https://api.zano.org/assets_whitelist_testnet.json",
+} as const;
+
+export const TRADE_API_URL = "https://api.trade.zano.org";
+
+export const ZANO_DECIMALS = 12;
+export const DEFAULT_MIXIN = 15;
+export const AUDITABLE_MIXIN = 0;
+export const DEFAULT_FEE = 10000000000; // 0.01 ZANO