@t402/mcp 2.5.0 → 2.6.0

package/dist/cjs/server/index.d.ts

@@ -1,4 +1,4 @@
-import { M as McpServerConfig } from '../types-CwwW_c2B.js';
+import { M as McpServerConfig, e as TonMcpBridgeConfig } from '../ton-bridge-BN3RKhNy.js';
 import 'viem';
 
 /**
@@ -20,8 +20,16 @@ declare class T402McpServer {
      * Initialize the WDK instance from seed phrase
      */
     initWdk(): Promise<void>;
+    /** TON MCP bridge configuration */
+    private tonBridgeConfig;
     /**
-     * Get all tool definitions (base + WDK if configured)
+     * Register TON bridge tools
+     *
+     * Enables AI agents to use @ton/mcp tools through the t402 MCP server.
+     */
+    registerTonBridge(config: TonMcpBridgeConfig): void;
+    /**
+     * Get all tool definitions (base + WDK if configured + unified if enabled + TON bridge if registered)
      */
     private getToolDefinitions;
     /**
@@ -72,6 +80,18 @@ declare class T402McpServer {
      * Handle t402/autoPay
      */
     private handleAutoPay;
+    /**
+     * Handle t402/smartPay
+     */
+    private handleSmartPay;
+    /**
+     * Handle t402/paymentPlan
+     */
+    private handlePaymentPlan;
+    /**
+     * Handle TON bridge tool calls
+     */
+    private handleTonBridgeTool;
     /**
      * Start the server using stdio transport
      */

package/dist/cjs/server/index.js

@@ -1434,6 +1434,488 @@ function formatAutoPayResult(result) {
   return lines.join("\n");
 }
 
+// src/tools/ton-bridge.ts
+var TON_BRIDGE_TOOLS = {
+  "ton/getBalance": {
+    name: "ton/getBalance",
+    description: "Get TON and Jetton balances for a wallet address on the TON blockchain.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        address: {
+          type: "string",
+          description: "TON wallet address (friendly or raw format)"
+        }
+      },
+      required: ["address"]
+    }
+  },
+  "ton/transfer": {
+    name: "ton/transfer",
+    description: "Send TON to a recipient address on the TON blockchain.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        to: {
+          type: "string",
+          description: "Recipient TON address"
+        },
+        amount: {
+          type: "string",
+          description: 'Amount of TON to send (e.g., "1.5")'
+        },
+        memo: {
+          type: "string",
+          description: "Optional memo/comment for the transfer"
+        }
+      },
+      required: ["to", "amount"]
+    }
+  },
+  "ton/getJettonBalance": {
+    name: "ton/getJettonBalance",
+    description: "Get the balance of a specific Jetton (TON token) for a wallet address.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        address: {
+          type: "string",
+          description: "TON wallet address"
+        },
+        jettonMaster: {
+          type: "string",
+          description: "Jetton master contract address"
+        }
+      },
+      required: ["address", "jettonMaster"]
+    }
+  },
+  "ton/swapJettons": {
+    name: "ton/swapJettons",
+    description: "Swap Jettons (TON tokens) using DEX aggregation on the TON network. Returns a raw transaction JSON to be sent via sendTransaction.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        from: {
+          type: "string",
+          description: 'Source Jetton master address (or "TON" for native TON)'
+        },
+        to: {
+          type: "string",
+          description: 'Destination Jetton master address (or "TON" for native TON)'
+        },
+        amount: {
+          type: "string",
+          description: 'Amount to swap in human-readable format (e.g., "1.5")'
+        },
+        slippage: {
+          type: "string",
+          description: 'Slippage tolerance (e.g., "0.5" for 0.5%)'
+        }
+      },
+      required: ["from", "to", "amount"]
+    }
+  },
+  "ton/getTransactionStatus": {
+    name: "ton/getTransactionStatus",
+    description: "Check the status and details of a TON transaction by its hash.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        txHash: {
+          type: "string",
+          description: "Transaction hash (BOC hash or message hash)"
+        }
+      },
+      required: ["txHash"]
+    }
+  }
+};
+async function executeTonBridgeTool(toolName, args, config) {
+  if (config.demoMode) {
+    return executeTonBridgeToolDemo(toolName, args);
+  }
+  if (config.tonMcpEndpoint) {
+    return proxyToTonMcp(toolName, args, config.tonMcpEndpoint);
+  }
+  if (config.tonApiKey) {
+    return executeTonBridgeToolDirect(toolName, args, config.tonApiKey);
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Error: TON MCP bridge not configured. Set tonMcpEndpoint or tonApiKey.`
+      }
+    ],
+    isError: true
+  };
+}
+function executeTonBridgeToolDemo(toolName, args) {
+  const responses = {
+    "ton/getBalance": `[DEMO] TON Balance for ${args.address ?? "unknown"}:
+- TON: 5.25
+- USDT0: 100.00`,
+    "ton/transfer": `[DEMO] Transfer sent:
+- To: ${args.to ?? "unknown"}
+- Amount: ${args.amount ?? "0"} TON
+- TX: demo-ton-tx-hash-${Date.now().toString(36)}`,
+    "ton/getJettonBalance": `[DEMO] Jetton Balance:
+- Address: ${args.address ?? "unknown"}
+- Jetton: ${args.jettonMaster ?? "unknown"}
+- Balance: 50.00`,
+    "ton/swapJettons": `[DEMO] Swap quote received:
+- From: ${args.from ?? "unknown"}
+- To: ${args.to ?? "unknown"}
+- Amount: ${args.amount ?? "0"}
+- Transaction: {"validUntil":${Math.floor(Date.now() / 1e3) + 300},"messages":[{"address":"EQDemo...","amount":"${args.amount ?? "0"}","payload":"base64..."}]}`,
+    "ton/getTransactionStatus": `[DEMO] Transaction Status:
+- Hash: ${args.txHash ?? "unknown"}
+- Status: Confirmed
+- Block: 12345678`
+  };
+  return {
+    content: [
+      {
+        type: "text",
+        text: responses[toolName] ?? `[DEMO] Unknown TON tool: ${toolName}`
+      }
+    ]
+  };
+}
+async function proxyToTonMcp(toolName, args, endpoint) {
+  try {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name: toolName, arguments: args }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`TON MCP server returned ${response.status}`);
+    }
+    const result = await response.json();
+    if (result.error) {
+      throw new Error(result.error.message);
+    }
+    return result.result ?? { content: [{ type: "text", text: "No result" }] };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: "text", text: `Error proxying to @ton/mcp: ${message}` }],
+      isError: true
+    };
+  }
+}
+async function executeTonBridgeToolDirect(toolName, args, apiKey) {
+  const baseUrl = "https://toncenter.com/api/v2";
+  try {
+    switch (toolName) {
+      case "ton/getBalance": {
+        const response = await fetch(
+          `${baseUrl}/getAddressBalance?address=${encodeURIComponent(String(args.address))}&api_key=${apiKey}`
+        );
+        const data = await response.json();
+        const balanceNano = BigInt(data.result);
+        const balanceTon = Number(balanceNano) / 1e9;
+        return {
+          content: [{ type: "text", text: `TON Balance: ${balanceTon.toFixed(4)} TON` }]
+        };
+      }
+      case "ton/getTransactionStatus": {
+        const response = await fetch(
+          `${baseUrl}/getTransactions?hash=${encodeURIComponent(String(args.txHash))}&limit=1&api_key=${apiKey}`
+        );
+        const data = await response.json();
+        if (data.result.length === 0) {
+          return {
+            content: [{ type: "text", text: "Transaction not found" }]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Transaction found:
+${JSON.stringify(data.result[0], null, 2)}`
+            }
+          ]
+        };
+      }
+      default:
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Direct execution of ${toolName} is not supported. Configure tonMcpEndpoint to proxy to @ton/mcp.`
+            }
+          ],
+          isError: true
+        };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: "text", text: `Error executing TON API call: ${message}` }],
+      isError: true
+    };
+  }
+}
+
+// src/tools/unified.ts
+var import_zod12 = require("zod");
+var import_wdk_protocol2 = require("@t402/wdk-protocol");
+var smartPayInputSchema = import_zod12.z.object({
+  url: import_zod12.z.string().url().describe("URL of the 402-protected resource"),
+  maxBridgeFee: import_zod12.z.string().regex(/^\d+(\.\d+)?$/).optional().describe("Maximum acceptable bridge fee in native token (optional)"),
+  preferredNetwork: import_zod12.z.string().optional().describe("Preferred network for payment (optional)")
+});
+var paymentPlanInputSchema = import_zod12.z.object({
+  paymentRequired: import_zod12.z.object({
+    scheme: import_zod12.z.string().optional(),
+    network: import_zod12.z.string().optional(),
+    maxAmountRequired: import_zod12.z.string().optional(),
+    resource: import_zod12.z.string().optional(),
+    description: import_zod12.z.string().optional(),
+    payTo: import_zod12.z.string().optional(),
+    maxDeadline: import_zod12.z.number().optional()
+  }).passthrough().describe("The 402 PaymentRequired response")
+});
+var UNIFIED_TOOL_DEFINITIONS = {
+  "t402/smartPay": {
+    name: "t402/smartPay",
+    description: "Intelligent payment that automatically checks balance, bridges if needed, and pays. Handles the entire payment flow for 402-protected resources.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "URL of the 402-protected resource" },
+        maxBridgeFee: {
+          type: "string",
+          description: "Maximum acceptable bridge fee in native token (optional)"
+        },
+        preferredNetwork: {
+          type: "string",
+          description: "Preferred network for payment (optional)"
+        }
+      },
+      required: ["url"]
+    }
+  },
+  "t402/paymentPlan": {
+    name: "t402/paymentPlan",
+    description: "Analyze a 402 response and create an optimal payment plan considering balances across all chains. Returns recommended network, bridge requirements, and balance overview.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        paymentRequired: {
+          type: "object",
+          description: "The 402 PaymentRequired response"
+        }
+      },
+      required: ["paymentRequired"]
+    }
+  }
+};
+async function executeSmartPay(input, wdk) {
+  const steps = [];
+  const chains6 = input.preferredNetwork ? [input.preferredNetwork] : ["ethereum", "arbitrum", "base"];
+  steps.push({
+    action: "check_balance",
+    status: "success",
+    detail: `Checking balances on ${chains6.join(", ")}`
+  });
+  const protocol = await import_wdk_protocol2.T402Protocol.create(wdk, { chains: chains6 });
+  steps.push({
+    action: "fetch",
+    status: "success",
+    detail: `Fetching ${input.url}`
+  });
+  const { response, receipt } = await protocol.fetch(input.url);
+  if (receipt) {
+    steps.push({
+      action: "pay",
+      status: "success",
+      detail: `Payment made: ${receipt.amount} on ${receipt.network}`
+    });
+  }
+  const contentType = response.headers.get("content-type") ?? void 0;
+  let body = "";
+  try {
+    body = await response.text();
+    if (body.length > 1e4) {
+      body = body.slice(0, 1e4) + "\n... (truncated)";
+    }
+  } catch {
+    body = "[Could not read response body]";
+  }
+  return {
+    success: response.ok,
+    statusCode: response.status,
+    body,
+    contentType,
+    steps,
+    payment: receipt ? {
+      network: receipt.network,
+      scheme: receipt.scheme,
+      amount: receipt.amount,
+      payTo: receipt.payTo
+    } : void 0
+  };
+}
+function executeSmartPayDemo(input) {
+  const network = input.preferredNetwork ?? "arbitrum";
+  return {
+    success: true,
+    statusCode: 200,
+    body: `[Demo] Premium content from ${input.url}
+
+This is simulated content returned after smart payment.`,
+    contentType: "text/plain",
+    steps: [
+      { action: "check_balance", status: "success", detail: `Checked balances on ${network}` },
+      { action: "check_price", status: "success", detail: "Resource costs 1.00 USDT0" },
+      { action: "pay", status: "success", detail: `Paid 1000000 USDT0 on eip155:42161` },
+      { action: "fetch", status: "success", detail: `Fetched ${input.url}` }
+    ],
+    payment: {
+      network: "eip155:42161",
+      scheme: "exact",
+      amount: "1000000",
+      payTo: "0xC88f67e776f16DcFBf42e6bDda1B82604448899B"
+    }
+  };
+}
+async function executePaymentPlan(input, wdk) {
+  const targetNetwork = input.paymentRequired.network;
+  const requiredAmount = input.paymentRequired.maxAmountRequired;
+  const aggregated = await wdk.getAggregatedBalances();
+  const balances = aggregated.chains.map((chain) => {
+    const usdt0 = chain.tokens.find((t) => t.symbol === "USDT0");
+    const usdc = chain.tokens.find((t) => t.symbol === "USDC");
+    return {
+      chain: chain.chain,
+      usdt0: usdt0?.formatted ?? "0",
+      usdc: usdc?.formatted ?? "0"
+    };
+  });
+  const requiredBigint = requiredAmount ? BigInt(requiredAmount) : 0n;
+  const bestChain = await wdk.findBestChainForPayment(requiredBigint);
+  if (bestChain) {
+    const needsBridge = targetNetwork ? !bestChain.chain.includes(targetNetwork) : false;
+    return {
+      viable: true,
+      recommendedNetwork: bestChain.chain,
+      availableBalance: bestChain.balance.toString(),
+      bridgeRequired: needsBridge,
+      bridgeDetails: needsBridge ? {
+        fromChain: bestChain.chain,
+        toChain: targetNetwork ?? bestChain.chain,
+        amount: requiredAmount ?? "0",
+        estimatedFee: "0.001"
+      } : void 0,
+      balances
+    };
+  }
+  return {
+    viable: false,
+    bridgeRequired: false,
+    balances,
+    reason: "Insufficient balance across all chains"
+  };
+}
+function executePaymentPlanDemo(_input) {
+  return {
+    viable: true,
+    recommendedNetwork: "arbitrum",
+    availableBalance: "500000000",
+    bridgeRequired: false,
+    balances: [
+      { chain: "ethereum", usdt0: "100.00", usdc: "250.00" },
+      { chain: "arbitrum", usdt0: "500.00", usdc: "0" },
+      { chain: "base", usdt0: "50.00", usdc: "100.00" }
+    ]
+  };
+}
+function formatSmartPayResult(result) {
+  const lines = ["## SmartPay Result", ""];
+  if (result.success) {
+    lines.push(`**Status:** Success (${result.statusCode})`);
+  } else {
+    lines.push(`**Status:** Failed (${result.statusCode})`);
+  }
+  if (result.steps.length > 0) {
+    lines.push("");
+    lines.push("### Steps");
+    for (const step of result.steps) {
+      const icon = step.status === "success" ? "[OK]" : step.status === "skipped" ? "[SKIP]" : "[FAIL]";
+      lines.push(`- ${icon} **${step.action}**: ${step.detail}`);
+    }
+  }
+  if (result.payment) {
+    lines.push("");
+    lines.push("### Payment Details");
+    lines.push(`- **Network:** ${result.payment.network}`);
+    lines.push(`- **Scheme:** ${result.payment.scheme}`);
+    lines.push(`- **Amount:** ${result.payment.amount}`);
+    lines.push(`- **Pay To:** \`${result.payment.payTo}\``);
+  }
+  if (result.error) {
+    lines.push("");
+    lines.push(`**Error:** ${result.error}`);
+  }
+  if (result.body) {
+    lines.push("");
+    lines.push("### Response Content");
+    if (result.contentType) {
+      lines.push(`_Content-Type: ${result.contentType}_`);
+    }
+    lines.push("");
+    lines.push("```");
+    lines.push(result.body);
+    lines.push("```");
+  }
+  return lines.join("\n");
+}
+function formatPaymentPlanResult(result) {
+  const lines = ["## Payment Plan", ""];
+  if (result.viable) {
+    lines.push(`**Viable:** Yes`);
+    if (result.recommendedNetwork) {
+      lines.push(`**Recommended Network:** ${result.recommendedNetwork}`);
+    }
+    if (result.availableBalance) {
+      lines.push(`**Available Balance:** ${result.availableBalance}`);
+    }
+  } else {
+    lines.push(`**Viable:** No`);
+    if (result.reason) {
+      lines.push(`**Reason:** ${result.reason}`);
+    }
+  }
+  if (result.bridgeRequired && result.bridgeDetails) {
+    lines.push("");
+    lines.push("### Bridge Required");
+    lines.push(`- **From:** ${result.bridgeDetails.fromChain}`);
+    lines.push(`- **To:** ${result.bridgeDetails.toChain}`);
+    lines.push(`- **Amount:** ${result.bridgeDetails.amount}`);
+    lines.push(`- **Estimated Fee:** ${result.bridgeDetails.estimatedFee}`);
+  }
+  if (result.balances.length > 0) {
+    lines.push("");
+    lines.push("### Chain Balances");
+    lines.push("| Chain | USDT0 | USDC |");
+    lines.push("|-------|-------|------|");
+    for (const b of result.balances) {
+      lines.push(`| ${b.chain} | ${b.usdt0} | ${b.usdc} |`);
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/tools/index.ts
 var TOOL_DEFINITIONS = {
   "t402/getBalance": {
@@ -1745,6 +2227,8 @@ var T402McpServer = class {
     __publicField(this, "server");
     __publicField(this, "config");
     __publicField(this, "wdk", null);
+    /** TON MCP bridge configuration */
+    __publicField(this, "tonBridgeConfig", null);
     this.config = config;
     this.server = new import_server.Server(
       {
@@ -1778,13 +2262,27 @@ var T402McpServer = class {
     }
   }
   /**
-   * Get all tool definitions (base + WDK if configured)
+   * Register TON bridge tools
+   *
+   * Enables AI agents to use @ton/mcp tools through the t402 MCP server.
+   */
+  registerTonBridge(config) {
+    this.tonBridgeConfig = config;
+  }
+  /**
+   * Get all tool definitions (base + WDK if configured + unified if enabled + TON bridge if registered)
    */
   getToolDefinitions() {
     const tools = { ...TOOL_DEFINITIONS };
     if (this.wdk || this.config.demoMode) {
       Object.assign(tools, WDK_TOOL_DEFINITIONS);
     }
+    if (this.config.unifiedMode && (this.wdk || this.config.demoMode)) {
+      Object.assign(tools, UNIFIED_TOOL_DEFINITIONS);
+    }
+    if (this.tonBridgeConfig) {
+      Object.assign(tools, TON_BRIDGE_TOOLS);
+    }
     return tools;
   }
   /**
@@ -1823,6 +2321,18 @@ var T402McpServer = class {
             return await this.handleWdkSwap(args);
           case "t402/autoPay":
             return await this.handleAutoPay(args);
+          // Unified tools
+          case "t402/smartPay":
+            return await this.handleSmartPay(args);
+          case "t402/paymentPlan":
+            return await this.handlePaymentPlan(args);
+          // TON bridge tools
+          case "ton/getBalance":
+          case "ton/transfer":
+          case "ton/getJettonBalance":
+          case "ton/swapJettons":
+          case "ton/getTransactionStatus":
+            return await this.handleTonBridgeTool(name, args);
           default:
             throw new Error(`Unknown tool: ${name}`);
         }
@@ -2020,6 +2530,37 @@ var T402McpServer = class {
       content: [{ type: "text", text: formatAutoPayResult(result) }]
     };
   }
+  // ---- Unified Tool Handlers ----
+  /**
+   * Handle t402/smartPay
+   */
+  async handleSmartPay(args) {
+    const input = smartPayInputSchema.parse(args);
+    const result = this.config.demoMode || !this.wdk ? executeSmartPayDemo(input) : await executeSmartPay(input, this.wdk);
+    return {
+      content: [{ type: "text", text: formatSmartPayResult(result) }]
+    };
+  }
+  /**
+   * Handle t402/paymentPlan
+   */
+  async handlePaymentPlan(args) {
+    const input = paymentPlanInputSchema.parse(args);
+    const result = this.config.demoMode || !this.wdk ? executePaymentPlanDemo(input) : await executePaymentPlan(input, this.wdk);
+    return {
+      content: [{ type: "text", text: formatPaymentPlanResult(result) }]
+    };
+  }
+  // ---- TON Bridge Tool Handler ----
+  /**
+   * Handle TON bridge tool calls
+   */
+  async handleTonBridgeTool(name, args) {
+    if (!this.tonBridgeConfig) {
+      throw new Error("TON bridge not configured. Call registerTonBridge() to enable TON tools.");
+    }
+    return executeTonBridgeTool(name, args ?? {}, this.tonBridgeConfig);
+  }
   /**
    * Start the server using stdio transport
    */
@@ -2053,6 +2594,9 @@ function loadConfigFromEnv() {
   if (process.env.T402_WDK_CHAINS) {
     config.wdkChains = process.env.T402_WDK_CHAINS.split(",").map((c) => c.trim());
   }
+  if (process.env.T402_UNIFIED_MODE === "true") {
+    config.unifiedMode = true;
+  }
   const rpcUrls = {};
   const networks = [
     "ethereum",
@@ -2074,6 +2618,12 @@ function loadConfigFromEnv() {
   if (Object.keys(rpcUrls).length > 0) {
     config.rpcUrls = rpcUrls;
   }
+  if (process.env.T402_TON_MCP_ENDPOINT) {
+    config.tonMcpEndpoint = process.env.T402_TON_MCP_ENDPOINT;
+  }
+  if (process.env.T402_TON_API_KEY) {
+    config.tonApiKey = process.env.T402_TON_API_KEY;
+  }
   return config;
 }
 // Annotate the CommonJS export names for ESM import in node: