@t402/mcp 2.4.0 → 2.6.0

package/dist/cjs/server/index.js

@@ -1151,6 +1151,771 @@ function formatBridgeResult(result) {
   ].join("\n");
 }
 
+// src/tools/wdkGetWallet.ts
+var import_zod7 = require("zod");
+var wdkGetWalletInputSchema = import_zod7.z.object({});
+async function executeWdkGetWallet(_input, wdk) {
+  const signer = await wdk.getSigner("ethereum");
+  const chains6 = wdk.getConfiguredChains();
+  return {
+    evmAddress: signer.address,
+    chains: chains6.length > 0 ? chains6 : ["ethereum"]
+  };
+}
+function executeWdkGetWalletDemo() {
+  return {
+    evmAddress: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
+    chains: ["ethereum", "arbitrum", "base", "optimism"]
+  };
+}
+function formatWdkWalletResult(info) {
+  const lines = [
+    "## WDK Wallet Info",
+    "",
+    `**EVM Address:** \`${info.evmAddress}\``,
+    "",
+    "### Supported Chains",
+    ...info.chains.map((c) => `- ${c}`)
+  ];
+  return lines.join("\n");
+}
+
+// src/tools/wdkGetBalances.ts
+var import_zod8 = require("zod");
+var import_viem6 = require("viem");
+var wdkGetBalancesInputSchema = import_zod8.z.object({
+  chains: import_zod8.z.array(import_zod8.z.string()).optional().describe("Optional list of chains to check. If not provided, checks all configured chains.")
+});
+function findTokenFormatted(tokens, symbol) {
+  return tokens.find((t) => t.symbol === symbol)?.formatted ?? "0";
+}
+async function executeWdkGetBalances(input, wdk) {
+  const balances = await wdk.getAggregatedBalances();
+  const chains6 = balances.chains.filter((c) => !input.chains || input.chains.includes(c.chain)).map((c) => ({
+    chain: c.chain,
+    usdt0: findTokenFormatted(c.tokens, "USDT0"),
+    usdc: findTokenFormatted(c.tokens, "USDC"),
+    native: (0, import_viem6.formatUnits)(c.native, 18)
+  }));
+  return {
+    chains: chains6,
+    totalUsdt0: (0, import_viem6.formatUnits)(balances.totalUsdt0, 6),
+    totalUsdc: (0, import_viem6.formatUnits)(balances.totalUsdc, 6)
+  };
+}
+function executeWdkGetBalancesDemo() {
+  return {
+    chains: [
+      { chain: "ethereum", usdt0: "100.00", usdc: "250.00", native: "0.5" },
+      { chain: "arbitrum", usdt0: "500.00", usdc: "0", native: "0.01" },
+      { chain: "base", usdt0: "200.00", usdc: "100.00", native: "0.02" }
+    ],
+    totalUsdt0: "800.00",
+    totalUsdc: "350.00"
+  };
+}
+function formatWdkBalancesResult(result) {
+  const lines = [
+    "## WDK Multi-Chain Balances",
+    "",
+    `**Total USDT0:** ${result.totalUsdt0}`,
+    `**Total USDC:** ${result.totalUsdc}`,
+    "",
+    "### Per-Chain Breakdown",
+    ""
+  ];
+  for (const chain of result.chains) {
+    lines.push(`**${chain.chain}**`);
+    lines.push(`- USDT0: ${chain.usdt0}`);
+    lines.push(`- USDC: ${chain.usdc}`);
+    lines.push(`- Native: ${chain.native}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/wdkTransfer.ts
+var import_zod9 = require("zod");
+var wdkTransferInputSchema = import_zod9.z.object({
+  to: import_zod9.z.string().describe("Recipient address"),
+  amount: import_zod9.z.string().regex(/^\d+(\.\d+)?$/).describe("Amount to send (e.g., '10.50')"),
+  token: import_zod9.z.enum(["USDC", "USDT", "USDT0"]).describe("Token to transfer"),
+  chain: import_zod9.z.string().describe('Chain to execute transfer on (e.g., "ethereum", "arbitrum")')
+});
+async function executeWdkTransfer(input, wdk) {
+  const signer = await wdk.getSigner(input.chain);
+  const result = await signer.sendTransaction({
+    to: input.to
+  });
+  const txHash = result.hash;
+  const explorerUrl = getExplorerTxUrl(input.chain, txHash);
+  return {
+    txHash,
+    amount: input.amount,
+    token: input.token,
+    chain: input.chain,
+    to: input.to,
+    explorerUrl
+  };
+}
+function executeWdkTransferDemo(input) {
+  const demoTxHash = "0xdemo" + Math.random().toString(16).slice(2, 10);
+  return {
+    txHash: demoTxHash,
+    amount: input.amount,
+    token: input.token,
+    chain: input.chain,
+    to: input.to,
+    explorerUrl: `https://etherscan.io/tx/${demoTxHash}`
+  };
+}
+function formatWdkTransferResult(result) {
+  return [
+    "## WDK Transfer Complete",
+    "",
+    `**Amount:** ${result.amount} ${result.token}`,
+    `**Chain:** ${result.chain}`,
+    `**To:** \`${result.to}\``,
+    `**Tx Hash:** \`${result.txHash}\``,
+    `**Explorer:** [View Transaction](${result.explorerUrl})`
+  ].join("\n");
+}
+
+// src/tools/wdkSwap.ts
+var import_zod10 = require("zod");
+var import_viem7 = require("viem");
+var wdkSwapInputSchema = import_zod10.z.object({
+  fromToken: import_zod10.z.string().describe('Token to swap from (e.g., "ETH", "USDC")'),
+  toToken: import_zod10.z.string().describe('Token to swap to (e.g., "USDT0", "USDC")'),
+  amount: import_zod10.z.string().regex(/^\d+(\.\d+)?$/).describe("Amount to swap (e.g., '1.0')"),
+  chain: import_zod10.z.string().describe('Chain to execute swap on (e.g., "ethereum", "arbitrum")')
+});
+async function executeWdkSwap(input, wdk) {
+  const decimals = ["USDC", "USDT", "USDT0"].includes(input.fromToken.toUpperCase()) ? 6 : 18;
+  const amountBigInt = (0, import_viem7.parseUnits)(input.amount, decimals);
+  const quote = await wdk.getSwapQuote(input.chain, input.fromToken, amountBigInt);
+  const result = await wdk.swapAndPay({
+    chain: input.chain,
+    fromToken: input.fromToken,
+    amount: amountBigInt
+  });
+  const outputDecimals = ["USDC", "USDT", "USDT0"].includes(input.toToken.toUpperCase()) ? 6 : 18;
+  const toAmount = (0, import_viem7.formatUnits)(result?.outputAmount ?? quote.outputAmount, outputDecimals);
+  return {
+    fromAmount: input.amount,
+    fromToken: input.fromToken,
+    toAmount,
+    toToken: input.toToken,
+    chain: input.chain,
+    txHash: result?.txHash
+  };
+}
+function executeWdkSwapDemo(input) {
+  const inputAmount = parseFloat(input.amount);
+  const outputAmount = (inputAmount * 0.997).toFixed(6);
+  return {
+    fromAmount: input.amount,
+    fromToken: input.fromToken,
+    toAmount: outputAmount,
+    toToken: input.toToken,
+    chain: input.chain,
+    txHash: "0xdemo" + Math.random().toString(16).slice(2, 10)
+  };
+}
+function formatWdkSwapResult(result) {
+  const lines = [
+    "## WDK Swap Result",
+    "",
+    `**From:** ${result.fromAmount} ${result.fromToken}`,
+    `**To:** ${result.toAmount} ${result.toToken}`,
+    `**Chain:** ${result.chain}`
+  ];
+  if (result.txHash) {
+    lines.push(`**Tx Hash:** \`${result.txHash}\``);
+  }
+  return lines.join("\n");
+}
+
+// src/tools/autoPay.ts
+var import_zod11 = require("zod");
+var import_wdk_protocol = require("@t402/wdk-protocol");
+var autoPayInputSchema = import_zod11.z.object({
+  url: import_zod11.z.string().url().describe("URL to fetch (may return 402 Payment Required)"),
+  maxAmount: import_zod11.z.string().regex(/^\d+(\.\d+)?$/).optional().describe('Maximum amount willing to pay (e.g., "10.00"). If not set, pays any amount.'),
+  preferredChain: import_zod11.z.string().optional().describe(
+    'Preferred chain for payment (e.g., "arbitrum"). If not specified, uses first available.'
+  )
+});
+async function executeAutoPay(input, wdk) {
+  const chains6 = input.preferredChain ? [input.preferredChain] : ["ethereum", "arbitrum", "base"];
+  const protocol = await import_wdk_protocol.T402Protocol.create(wdk, { chains: chains6 });
+  const { response, receipt } = await protocol.fetch(input.url);
+  if (receipt && input.maxAmount) {
+    const paidAmount = parseFloat(receipt.amount) / 1e6;
+    const maxAmount = parseFloat(input.maxAmount);
+    if (paidAmount > maxAmount) {
+      return {
+        success: false,
+        statusCode: 402,
+        body: "",
+        error: `Payment amount (${paidAmount}) exceeds max allowed (${maxAmount})`
+      };
+    }
+  }
+  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,
+    payment: receipt ? {
+      network: receipt.network,
+      scheme: receipt.scheme,
+      amount: receipt.amount,
+      payTo: receipt.payTo
+    } : void 0
+  };
+}
+function executeAutoPayDemo(input) {
+  return {
+    success: true,
+    statusCode: 200,
+    body: `[Demo] Premium content from ${input.url}
+
+This is simulated content that would be returned after payment.`,
+    contentType: "text/plain",
+    payment: {
+      network: "eip155:42161",
+      scheme: "exact",
+      amount: "1000000",
+      payTo: "0xC88f67e776f16DcFBf42e6bDda1B82604448899B"
+    }
+  };
+}
+function formatAutoPayResult(result) {
+  const lines = ["## AutoPay Result", ""];
+  if (result.success) {
+    lines.push(`**Status:** Success (${result.statusCode})`);
+  } else {
+    lines.push(`**Status:** Failed (${result.statusCode})`);
+  }
+  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");
+}
+
+// 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": {
@@ -1351,12 +2116,119 @@ var TOOL_DEFINITIONS = {
     }
   }
 };
+var WDK_TOOL_DEFINITIONS = {
+  "wdk/getWallet": {
+    name: "wdk/getWallet",
+    description: "Get wallet information from the configured WDK wallet. Returns EVM address and supported chains. No parameters needed.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  "wdk/getBalances": {
+    name: "wdk/getBalances",
+    description: "Get multi-chain token balances from the WDK wallet. Returns USDT0, USDC, and native token balances per chain plus aggregated totals.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        chains: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Optional list of chains to check (e.g., ["ethereum", "arbitrum"]). If not provided, checks all configured chains.'
+        }
+      },
+      required: []
+    }
+  },
+  "wdk/transfer": {
+    name: "wdk/transfer",
+    description: "Send stablecoins (USDC, USDT, USDT0) from the WDK wallet to a recipient address on a specific chain.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        to: {
+          type: "string",
+          description: "Recipient address"
+        },
+        amount: {
+          type: "string",
+          pattern: "^\\d+(\\.\\d+)?$",
+          description: "Amount to send (e.g., '10.50')"
+        },
+        token: {
+          type: "string",
+          enum: ["USDC", "USDT", "USDT0"],
+          description: "Token to transfer"
+        },
+        chain: {
+          type: "string",
+          description: 'Chain to execute transfer on (e.g., "ethereum", "arbitrum")'
+        }
+      },
+      required: ["to", "amount", "token", "chain"]
+    }
+  },
+  "wdk/swap": {
+    name: "wdk/swap",
+    description: "Swap tokens using the WDK Velora protocol. Supports swapping between stablecoins and native tokens.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        fromToken: {
+          type: "string",
+          description: 'Token to swap from (e.g., "ETH", "USDC")'
+        },
+        toToken: {
+          type: "string",
+          description: 'Token to swap to (e.g., "USDT0", "USDC")'
+        },
+        amount: {
+          type: "string",
+          pattern: "^\\d+(\\.\\d+)?$",
+          description: "Amount to swap (e.g., '1.0')"
+        },
+        chain: {
+          type: "string",
+          description: 'Chain to execute swap on (e.g., "ethereum", "arbitrum")'
+        }
+      },
+      required: ["fromToken", "toToken", "amount", "chain"]
+    }
+  },
+  "t402/autoPay": {
+    name: "t402/autoPay",
+    description: "Smart payment orchestrator. Fetches a URL, automatically handles HTTP 402 Payment Required responses by signing and submitting payment using the WDK wallet, and returns the paid content. The killer tool for AI agents.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "URL to fetch (may return 402 Payment Required)"
+        },
+        maxAmount: {
+          type: "string",
+          pattern: "^\\d+(\\.\\d+)?$",
+          description: 'Maximum amount willing to pay (e.g., "10.00"). If not set, pays any amount.'
+        },
+        preferredChain: {
+          type: "string",
+          description: 'Preferred chain for payment (e.g., "arbitrum"). If not specified, uses first available.'
+        }
+      },
+      required: ["url"]
+    }
+  }
+};
 
 // src/server/t402Server.ts
 var T402McpServer = class {
   constructor(config = {}) {
     __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(
       {
@@ -1371,13 +2243,55 @@ var T402McpServer = class {
     );
     this.setupHandlers();
   }
+  /**
+   * Initialize the WDK instance from seed phrase
+   */
+  async initWdk() {
+    if (!this.config.seedPhrase) return;
+    try {
+      const { T402WDK } = await import("@t402/wdk");
+      const rpcUrls = {};
+      if (this.config.rpcUrls) {
+        for (const [network, url] of Object.entries(this.config.rpcUrls)) {
+          if (url) rpcUrls[network] = url;
+        }
+      }
+      this.wdk = new T402WDK(this.config.seedPhrase, rpcUrls);
+    } catch {
+      console.error("Warning: Failed to initialize WDK. WDK tools will not be available.");
+    }
+  }
+  /**
+   * 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;
+  }
   /**
    * Set up MCP request handlers
    */
   setupHandlers() {
     this.server.setRequestHandler(import_types.ListToolsRequestSchema, async () => {
       return {
-        tools: Object.values(TOOL_DEFINITIONS)
+        tools: Object.values(this.getToolDefinitions())
       };
     });
     this.server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
@@ -1396,6 +2310,29 @@ var T402McpServer = class {
             return await this.handleGetBridgeFee(args);
           case "t402/bridge":
             return await this.handleBridge(args);
+          // WDK tools
+          case "wdk/getWallet":
+            return await this.handleWdkGetWallet(args);
+          case "wdk/getBalances":
+            return await this.handleWdkGetBalances(args);
+          case "wdk/transfer":
+            return await this.handleWdkTransfer(args);
+          case "wdk/swap":
+            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}`);
         }
@@ -1542,10 +2479,93 @@ var T402McpServer = class {
       ]
     };
   }
+  // ---- WDK Tool Handlers ----
+  /**
+   * Handle wdk/getWallet
+   */
+  async handleWdkGetWallet(args) {
+    wdkGetWalletInputSchema.parse(args);
+    const result = this.config.demoMode || !this.wdk ? executeWdkGetWalletDemo() : await executeWdkGetWallet({}, this.wdk);
+    return {
+      content: [{ type: "text", text: formatWdkWalletResult(result) }]
+    };
+  }
+  /**
+   * Handle wdk/getBalances
+   */
+  async handleWdkGetBalances(args) {
+    const input = wdkGetBalancesInputSchema.parse(args);
+    const result = this.config.demoMode || !this.wdk ? executeWdkGetBalancesDemo() : await executeWdkGetBalances(input, this.wdk);
+    return {
+      content: [{ type: "text", text: formatWdkBalancesResult(result) }]
+    };
+  }
+  /**
+   * Handle wdk/transfer
+   */
+  async handleWdkTransfer(args) {
+    const input = wdkTransferInputSchema.parse(args);
+    const result = this.config.demoMode || !this.wdk ? executeWdkTransferDemo(input) : await executeWdkTransfer(input, this.wdk);
+    return {
+      content: [{ type: "text", text: formatWdkTransferResult(result) }]
+    };
+  }
+  /**
+   * Handle wdk/swap
+   */
+  async handleWdkSwap(args) {
+    const input = wdkSwapInputSchema.parse(args);
+    const result = this.config.demoMode || !this.wdk ? executeWdkSwapDemo(input) : await executeWdkSwap(input, this.wdk);
+    return {
+      content: [{ type: "text", text: formatWdkSwapResult(result) }]
+    };
+  }
+  /**
+   * Handle t402/autoPay
+   */
+  async handleAutoPay(args) {
+    const input = autoPayInputSchema.parse(args);
+    const result = this.config.demoMode || !this.wdk ? executeAutoPayDemo(input) : await executeAutoPay(input, this.wdk);
+    return {
+      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
    */
   async run() {
+    await this.initWdk();
     const transport = new import_stdio.StdioServerTransport();
     await this.server.connect(transport);
     console.error("t402 MCP Server running on stdio");
@@ -1568,6 +2588,15 @@ function loadConfigFromEnv() {
   if (process.env.T402_PAYMASTER_URL) {
     config.paymasterUrl = process.env.T402_PAYMASTER_URL;
   }
+  if (process.env.T402_WDK_SEED_PHRASE) {
+    config.seedPhrase = process.env.T402_WDK_SEED_PHRASE;
+  }
+  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",
@@ -1589,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: