@t402/mcp 2.4.0 → 2.5.0

package/dist/esm/{chunk-5IVOABVF.mjs → chunk-5UOBQKXW.mjs}

@@ -1127,6 +1127,289 @@ function formatBridgeResult(result) {
   ].join("\n");
 }
 
+// src/tools/wdkGetWallet.ts
+import { z as z7 } from "zod";
+var wdkGetWalletInputSchema = z7.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
+import { z as z8 } from "zod";
+import { formatUnits as formatUnits2 } from "viem";
+var wdkGetBalancesInputSchema = z8.object({
+  chains: z8.array(z8.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: formatUnits2(c.native, 18)
+  }));
+  return {
+    chains: chains6,
+    totalUsdt0: formatUnits2(balances.totalUsdt0, 6),
+    totalUsdc: formatUnits2(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
+import { z as z9 } from "zod";
+var wdkTransferInputSchema = z9.object({
+  to: z9.string().describe("Recipient address"),
+  amount: z9.string().regex(/^\d+(\.\d+)?$/).describe("Amount to send (e.g., '10.50')"),
+  token: z9.enum(["USDC", "USDT", "USDT0"]).describe("Token to transfer"),
+  chain: z9.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
+import { z as z10 } from "zod";
+import { formatUnits as formatUnits3, parseUnits as parseUnits3 } from "viem";
+var wdkSwapInputSchema = z10.object({
+  fromToken: z10.string().describe('Token to swap from (e.g., "ETH", "USDC")'),
+  toToken: z10.string().describe('Token to swap to (e.g., "USDT0", "USDC")'),
+  amount: z10.string().regex(/^\d+(\.\d+)?$/).describe("Amount to swap (e.g., '1.0')"),
+  chain: z10.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 = parseUnits3(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 = formatUnits3(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
+import { z as z11 } from "zod";
+import { T402Protocol } from "@t402/wdk-protocol";
+var autoPayInputSchema = z11.object({
+  url: z11.string().url().describe("URL to fetch (may return 402 Payment Required)"),
+  maxAmount: z11.string().regex(/^\d+(\.\d+)?$/).optional().describe('Maximum amount willing to pay (e.g., "10.00"). If not set, pays any amount.'),
+  preferredChain: z11.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 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": {
@@ -1327,6 +1610,110 @@ 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"]
+    }
+  }
+};
 
 export {
   __publicField,
@@ -1363,6 +1750,27 @@ export {
   bridgeInputSchema,
   executeBridge,
   formatBridgeResult,
-  TOOL_DEFINITIONS
+  wdkGetWalletInputSchema,
+  executeWdkGetWallet,
+  executeWdkGetWalletDemo,
+  formatWdkWalletResult,
+  wdkGetBalancesInputSchema,
+  executeWdkGetBalances,
+  executeWdkGetBalancesDemo,
+  formatWdkBalancesResult,
+  wdkTransferInputSchema,
+  executeWdkTransfer,
+  executeWdkTransferDemo,
+  formatWdkTransferResult,
+  wdkSwapInputSchema,
+  executeWdkSwap,
+  executeWdkSwapDemo,
+  formatWdkSwapResult,
+  autoPayInputSchema,
+  executeAutoPay,
+  executeAutoPayDemo,
+  formatAutoPayResult,
+  TOOL_DEFINITIONS,
+  WDK_TOOL_DEFINITIONS
 };
-//# sourceMappingURL=chunk-5IVOABVF.mjs.map
+//# sourceMappingURL=chunk-5UOBQKXW.mjs.map