@t402/mcp 2.4.0 → 2.5.0

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

@@ -1,4 +1,4 @@
-import { M as McpServerConfig } from '../types-CWK2p9_n.js';
+import { M as McpServerConfig } from '../types-CwwW_c2B.js';
 import 'viem';
 
 /**
@@ -9,11 +9,21 @@ import 'viem';
  * t402 MCP Server
  *
  * Provides payment tools for AI agents via the Model Context Protocol.
+ * When a WDK seed phrase is configured, additional wallet management tools are available.
  */
 declare class T402McpServer {
     private server;
     private config;
+    private wdk;
     constructor(config?: McpServerConfig);
+    /**
+     * Initialize the WDK instance from seed phrase
+     */
+    initWdk(): Promise<void>;
+    /**
+     * Get all tool definitions (base + WDK if configured)
+     */
+    private getToolDefinitions;
     /**
      * Set up MCP request handlers
      */
@@ -42,6 +52,26 @@ declare class T402McpServer {
      * Handle t402/bridge
      */
     private handleBridge;
+    /**
+     * Handle wdk/getWallet
+     */
+    private handleWdkGetWallet;
+    /**
+     * Handle wdk/getBalances
+     */
+    private handleWdkGetBalances;
+    /**
+     * Handle wdk/transfer
+     */
+    private handleWdkTransfer;
+    /**
+     * Handle wdk/swap
+     */
+    private handleWdkSwap;
+    /**
+     * Handle t402/autoPay
+     */
+    private handleAutoPay;
     /**
      * Start the server using stdio transport
      */

package/dist/cjs/server/index.js

@@ -1151,6 +1151,289 @@ 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/index.ts
 var TOOL_DEFINITIONS = {
   "t402/getBalance": {
@@ -1351,12 +1634,117 @@ 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);
     this.config = config;
     this.server = new import_server.Server(
       {
@@ -1371,13 +1759,41 @@ 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.");
+    }
+  }
+  /**
+   * Get all tool definitions (base + WDK if configured)
+   */
+  getToolDefinitions() {
+    const tools = { ...TOOL_DEFINITIONS };
+    if (this.wdk || this.config.demoMode) {
+      Object.assign(tools, WDK_TOOL_DEFINITIONS);
+    }
+    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 +1812,17 @@ 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);
           default:
             throw new Error(`Unknown tool: ${name}`);
         }
@@ -1542,10 +1969,62 @@ 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) }]
+    };
+  }
   /**
    * 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 +2047,12 @@ 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());
+  }
   const rpcUrls = {};
   const networks = [
     "ethereum",