@t402/mcp 2.7.1 → 2.8.1

package/dist/cjs/server/index.js

@@ -465,7 +465,8 @@ var payInputSchema = import_zod3.z.object({
     "berachain",
     "unichain"
   ]).describe("Network to execute payment on"),
-  memo: import_zod3.z.string().optional().describe("Optional memo/reference for the payment")
+  memo: import_zod3.z.string().optional().describe("Optional memo/reference for the payment"),
+  confirmed: import_zod3.z.boolean().optional().describe("Set to true to confirm and execute this payment")
 });
 function getViemChain2(network) {
   switch (network) {
@@ -494,6 +495,13 @@ function getViemChain2(network) {
 async function executePay(input, options) {
   const { to, amount, token, network, memo: _memo } = input;
   const { privateKey, rpcUrl, demoMode } = options;
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Send ${amount} ${token} on ${network} to ${to}`,
+      details: { to, amount, token, network }
+    };
+  }
   if (!supportsToken(network, token)) {
     throw new Error(`Token ${token} is not supported on ${network}`);
   }
@@ -578,7 +586,8 @@ var payGaslessInputSchema = import_zod4.z.object({
   to: import_zod4.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("Recipient address"),
   amount: import_zod4.z.string().regex(/^\d+(\.\d+)?$/).describe("Amount to pay (e.g., '10.50' for 10.50 USDC)"),
   token: import_zod4.z.enum(["USDC", "USDT", "USDT0"]).describe("Token to use for payment"),
-  network: import_zod4.z.enum(["ethereum", "base", "arbitrum", "optimism", "polygon", "avalanche"]).describe("Network to execute gasless payment on (must support ERC-4337)")
+  network: import_zod4.z.enum(["ethereum", "base", "arbitrum", "optimism", "polygon", "avalanche"]).describe("Network to execute gasless payment on (must support ERC-4337)"),
+  confirmed: import_zod4.z.boolean().optional().describe("Set to true to confirm and execute this payment")
 });
 var GASLESS_SUPPORTED_NETWORKS = [
   "ethereum",
@@ -615,6 +624,13 @@ function getViemChain3(network) {
 async function executePayGasless(input, options) {
   const { to, amount, token, network } = input;
   const { privateKey, bundlerUrl, paymasterUrl: _paymasterUrl, rpcUrl, demoMode } = options;
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Send ${amount} ${token} gasless on ${network} to ${to}`,
+      details: { to, amount, token, network }
+    };
+  }
   if (!GASLESS_SUPPORTED_NETWORKS.includes(network)) {
     throw new Error(
       `Network ${network} does not support ERC-4337 gasless transactions. Supported: ${GASLESS_SUPPORTED_NETWORKS.join(", ")}`
@@ -900,7 +916,8 @@ var bridgeInputSchema = import_zod6.z.object({
   fromChain: import_zod6.z.enum(["ethereum", "arbitrum", "ink", "berachain", "unichain"]).describe("Source chain to bridge from"),
   toChain: import_zod6.z.enum(["ethereum", "arbitrum", "ink", "berachain", "unichain"]).describe("Destination chain to bridge to"),
   amount: import_zod6.z.string().regex(/^\d+(\.\d+)?$/).describe("Amount of USDT0 to bridge (e.g., '100' for 100 USDT0)"),
-  recipient: import_zod6.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("Recipient address on destination chain")
+  recipient: import_zod6.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("Recipient address on destination chain"),
+  confirmed: import_zod6.z.boolean().optional().describe("Set to true to confirm and execute this bridge")
 });
 var LAYERZERO_ENDPOINT_IDS2 = {
   ethereum: 30101,
@@ -1027,6 +1044,13 @@ function addressToBytes322(address) {
 async function executeBridge(input, options) {
   const { fromChain, toChain, amount, recipient } = input;
   const { privateKey, rpcUrl, demoMode, slippageTolerance = 0.5 } = options;
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Bridge ${amount} USDT0 from ${fromChain} to ${toChain}`,
+      details: { fromChain, toChain, amount, recipient }
+    };
+  }
   if (fromChain === toChain) {
     throw new Error("Source and destination chains must be different");
   }
@@ -1156,10 +1180,10 @@ var import_zod7 = require("zod");
 var wdkGetWalletInputSchema = import_zod7.z.object({});
 async function executeWdkGetWallet(_input, wdk) {
   const signer = await wdk.getSigner("ethereum");
-  const chains7 = wdk.getConfiguredChains();
+  const chains10 = wdk.getConfiguredChains();
   return {
     evmAddress: signer.address,
-    chains: chains7.length > 0 ? chains7 : ["ethereum"]
+    chains: chains10.length > 0 ? chains10 : ["ethereum"]
   };
 }
 function executeWdkGetWalletDemo() {
@@ -1191,14 +1215,14 @@ function findTokenFormatted(tokens, symbol) {
 }
 async function executeWdkGetBalances(input, wdk) {
   const balances = await wdk.getAggregatedBalances();
-  const chains7 = balances.chains.filter((c) => !input.chains || input.chains.includes(c.chain)).map((c) => ({
+  const chains10 = 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: chains7,
+    chains: chains10,
     totalUsdt0: (0, import_viem6.formatUnits)(balances.totalUsdt0, 6),
     totalUsdc: (0, import_viem6.formatUnits)(balances.totalUsdc, 6)
   };
@@ -1240,9 +1264,17 @@ 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")')
+  chain: import_zod9.z.string().describe('Chain to execute transfer on (e.g., "ethereum", "arbitrum")'),
+  confirmed: import_zod9.z.boolean().optional().describe("Set to true to confirm and execute this transfer")
 });
 async function executeWdkTransfer(input, wdk) {
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Transfer ${input.amount} ${input.token} on ${input.chain} to ${input.to}`,
+      details: { to: input.to, amount: input.amount, token: input.token, chain: input.chain }
+    };
+  }
   const signer = await wdk.getSigner(input.chain);
   const result = await signer.sendTransaction({
     to: input.to
@@ -1259,6 +1291,13 @@ async function executeWdkTransfer(input, wdk) {
   };
 }
 function executeWdkTransferDemo(input) {
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Transfer ${input.amount} ${input.token} on ${input.chain} to ${input.to}`,
+      details: { to: input.to, amount: input.amount, token: input.token, chain: input.chain }
+    };
+  }
   const demoTxHash = "0xdemo" + Math.random().toString(16).slice(2, 10);
   return {
     txHash: demoTxHash,
@@ -1288,9 +1327,22 @@ 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")')
+  chain: import_zod10.z.string().describe('Chain to execute swap on (e.g., "ethereum", "arbitrum")'),
+  confirmed: import_zod10.z.boolean().optional().describe("Set to true to confirm and execute this swap")
 });
 async function executeWdkSwap(input, wdk) {
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Swap ${input.amount} ${input.fromToken} to ${input.toToken} on ${input.chain}`,
+      details: {
+        fromToken: input.fromToken,
+        toToken: input.toToken,
+        amount: input.amount,
+        chain: input.chain
+      }
+    };
+  }
   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);
@@ -1311,6 +1363,18 @@ async function executeWdkSwap(input, wdk) {
   };
 }
 function executeWdkSwapDemo(input) {
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Swap ${input.amount} ${input.fromToken} to ${input.toToken} on ${input.chain}`,
+      details: {
+        fromToken: input.fromToken,
+        toToken: input.toToken,
+        amount: input.amount,
+        chain: input.chain
+      }
+    };
+  }
   const inputAmount = parseFloat(input.amount);
   const outputAmount = (inputAmount * 0.997).toFixed(6);
   return {
@@ -1343,25 +1407,52 @@ var autoPayInputSchema = import_zod11.z.object({
   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.'
-  )
+  ),
+  confirmed: import_zod11.z.boolean().optional().describe("Set to true to confirm and execute this payment")
 });
 async function executeAutoPay(input, wdk) {
-  const chains7 = input.preferredChain ? [input.preferredChain] : ["ethereum", "arbitrum", "base"];
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Auto-pay for ${input.url}${input.maxAmount ? ` (max ${input.maxAmount})` : ""}`,
+      details: {
+        url: input.url,
+        ...input.maxAmount ? { maxAmount: input.maxAmount } : {},
+        ...input.preferredChain ? { preferredChain: input.preferredChain } : {}
+      }
+    };
+  }
+  const chains10 = input.preferredChain ? [input.preferredChain] : ["ethereum", "arbitrum", "base"];
   const { T402Protocol } = await import("@t402/wdk-protocol");
-  const protocol = await T402Protocol.create(wdk, { chains: chains7 });
-  const { response, receipt } = await protocol.fetch(input.url);
-  if (receipt && input.maxAmount) {
-    const paidAmount = parseFloat(receipt.amount) / 1e6;
+  const protocol = await T402Protocol.create(wdk, { chains: chains10 });
+  if (input.maxAmount) {
     const maxAmount = parseFloat(input.maxAmount);
-    if (paidAmount > maxAmount) {
-      return {
-        success: false,
-        statusCode: 402,
-        body: "",
-        error: `Payment amount (${paidAmount}) exceeds max allowed (${maxAmount})`
-      };
+    const preflightResponse = await fetch(input.url);
+    if (preflightResponse.status === 402) {
+      const requirementsHeader = preflightResponse.headers.get("x-payment") || preflightResponse.headers.get("x-payment-requirements");
+      if (requirementsHeader) {
+        try {
+          const requirements = JSON.parse(requirementsHeader);
+          const reqArray = Array.isArray(requirements) ? requirements : [requirements];
+          for (const req of reqArray) {
+            if (req.amount) {
+              const reqAmount = parseFloat(req.amount) / 1e6;
+              if (reqAmount > maxAmount) {
+                return {
+                  success: false,
+                  statusCode: 402,
+                  body: "",
+                  error: `Required payment amount (${reqAmount}) exceeds max allowed (${maxAmount})`
+                };
+              }
+            }
+          }
+        } catch {
+        }
+      }
     }
   }
+  const { response, receipt } = await protocol.fetch(input.url);
   const contentType = response.headers.get("content-type") ?? void 0;
   let body = "";
   try {
@@ -1386,6 +1477,17 @@ async function executeAutoPay(input, wdk) {
   };
 }
 function executeAutoPayDemo(input) {
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Auto-pay for ${input.url}${input.maxAmount ? ` (max ${input.maxAmount})` : ""}`,
+      details: {
+        url: input.url,
+        ...input.maxAmount ? { maxAmount: input.maxAmount } : {},
+        ...input.preferredChain ? { preferredChain: input.preferredChain } : {}
+      }
+    };
+  }
   return {
     success: true,
     statusCode: 200,
@@ -1829,174 +1931,981 @@ function formatErc8004VerifyWalletResult(result) {
   return lines.join("\n");
 }
 
-// src/tools/unified.ts
+// src/tools/priceService.ts
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var COINGECKO_API = "https://api.coingecko.com/api/v3/simple/price";
+var TOKEN_TO_COINGECKO_ID = {
+  ETH: "ethereum",
+  MATIC: "matic-network",
+  AVAX: "avalanche-2",
+  BERA: "berachain-bera",
+  USDC: "usd-coin",
+  USDT: "tether",
+  USDT0: "tether"
+};
+var cache = /* @__PURE__ */ new Map();
+async function getTokenPrices(tokens, currency = "usd") {
+  const cacheKey = `${currency}:${tokens.sort().join(",")}`;
+  const cached = cache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+    return cached.prices;
+  }
+  const coinIds = /* @__PURE__ */ new Set();
+  const tokenToCoinId = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const coinId = TOKEN_TO_COINGECKO_ID[token.toUpperCase()] ?? token.toLowerCase();
+    coinIds.add(coinId);
+    tokenToCoinId.set(token.toUpperCase(), coinId);
+  }
+  const url = `${COINGECKO_API}?ids=${[...coinIds].join(",")}&vs_currencies=${currency}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`CoinGecko API error: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  const prices = {};
+  for (const token of tokens) {
+    const coinId = tokenToCoinId.get(token.toUpperCase()) ?? token.toLowerCase();
+    prices[token.toUpperCase()] = data[coinId]?.[currency] ?? 0;
+  }
+  cache.set(cacheKey, { prices, timestamp: Date.now() });
+  return prices;
+}
+function getTokenPricesDemo(tokens) {
+  const demoPrices = {
+    ETH: 3250.42,
+    MATIC: 0.58,
+    AVAX: 24.15,
+    BERA: 3.82,
+    USDC: 1,
+    USDT: 1,
+    USDT0: 1
+  };
+  const prices = {};
+  for (const token of tokens) {
+    prices[token.toUpperCase()] = demoPrices[token.toUpperCase()] ?? 0;
+  }
+  return prices;
+}
+
+// src/tools/getTokenPrice.ts
 var import_zod15 = require("zod");
-var smartPayInputSchema = import_zod15.z.object({
-  url: import_zod15.z.string().url().describe("URL of the 402-protected resource"),
-  maxBridgeFee: import_zod15.z.string().regex(/^\d+(\.\d+)?$/).optional().describe("Maximum acceptable bridge fee in native token (optional)"),
-  preferredNetwork: import_zod15.z.string().optional().describe("Preferred network for payment (optional)")
+var getTokenPriceInputSchema = import_zod15.z.object({
+  tokens: import_zod15.z.array(import_zod15.z.string()).min(1).describe('Token symbols to get prices for (e.g., ["ETH", "MATIC", "USDC"])'),
+  currency: import_zod15.z.string().optional().describe('Target currency (default: "usd"). Supports: usd, eur, gbp, etc.')
 });
-var paymentPlanInputSchema = import_zod15.z.object({
-  paymentRequired: import_zod15.z.object({
-    scheme: import_zod15.z.string().optional(),
-    network: import_zod15.z.string().optional(),
-    maxAmountRequired: import_zod15.z.string().optional(),
-    resource: import_zod15.z.string().optional(),
-    description: import_zod15.z.string().optional(),
-    payTo: import_zod15.z.string().optional(),
-    maxDeadline: import_zod15.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 executeGetTokenPrice(input, options) {
+  const currency = input.currency ?? "usd";
+  const prices = options.demoMode ? getTokenPricesDemo(input.tokens) : await getTokenPrices(input.tokens, currency);
+  return { prices, currency };
+}
+function formatTokenPriceResult(result) {
+  const lines = ["## Token Prices", ""];
+  const currencyUpper = result.currency.toUpperCase();
+  for (const [token, price] of Object.entries(result.prices)) {
+    if (price > 0) {
+      lines.push(`- **${token}:** ${price.toLocaleString()} ${currencyUpper}`);
+    } else {
+      lines.push(`- **${token}:** Price unavailable`);
     }
   }
-};
-async function executeSmartPay(input, wdk) {
-  const steps = [];
-  const chains7 = input.preferredNetwork ? [input.preferredNetwork] : ["ethereum", "arbitrum", "base"];
-  steps.push({
-    action: "check_balance",
-    status: "success",
-    detail: `Checking balances on ${chains7.join(", ")}`
-  });
-  const { T402Protocol } = await import("@t402/wdk-protocol");
-  const protocol = await T402Protocol.create(wdk, { chains: chains7 });
-  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}`
-    });
+  return lines.join("\n");
+}
+
+// src/tools/getGasPrice.ts
+var import_zod16 = require("zod");
+var import_viem9 = require("viem");
+var chains7 = __toESM(require("viem/chains"));
+var getGasPriceInputSchema = import_zod16.z.object({
+  network: import_zod16.z.enum([
+    "ethereum",
+    "base",
+    "arbitrum",
+    "optimism",
+    "polygon",
+    "avalanche",
+    "ink",
+    "berachain",
+    "unichain"
+  ]).describe("Blockchain network to check gas price on")
+});
+function getViemChain6(network) {
+  switch (network) {
+    case "ethereum":
+      return chains7.mainnet;
+    case "base":
+      return chains7.base;
+    case "arbitrum":
+      return chains7.arbitrum;
+    case "optimism":
+      return chains7.optimism;
+    case "polygon":
+      return chains7.polygon;
+    case "avalanche":
+      return chains7.avalanche;
+    case "ink":
+      return chains7.ink;
+    case "berachain":
+      return chains7.berachain;
+    case "unichain":
+      return chains7.unichain;
+    default:
+      return chains7.mainnet;
   }
-  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]";
+}
+async function executeGetGasPrice(input, options) {
+  const { network } = input;
+  if (options.demoMode) {
+    const demoGasPrices = {
+      ethereum: 25000000000n,
+      // 25 gwei
+      base: 50000000n,
+      // 0.05 gwei
+      arbitrum: 100000000n,
+      // 0.1 gwei
+      optimism: 50000000n,
+      // 0.05 gwei
+      polygon: 30000000000n,
+      // 30 gwei
+      avalanche: 25000000000n,
+      // 25 nAVAX
+      ink: 50000000n,
+      // 0.05 gwei
+      berachain: 1000000000n,
+      // 1 gwei
+      unichain: 50000000n
+      // 0.05 gwei
+    };
+    const gasPrice2 = demoGasPrices[network] ?? 1000000000n;
+    return {
+      network,
+      gasPriceWei: gasPrice2.toString(),
+      gasPriceGwei: (0, import_viem9.formatGwei)(gasPrice2),
+      nativeSymbol: NATIVE_SYMBOLS[network]
+    };
   }
+  const chain = getViemChain6(network);
+  const transport = (0, import_viem9.http)(options.rpcUrl ?? DEFAULT_RPC_URLS[network]);
+  const client = (0, import_viem9.createPublicClient)({ chain, transport });
+  const gasPrice = await client.getGasPrice();
   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
+    network,
+    gasPriceWei: gasPrice.toString(),
+    gasPriceGwei: (0, import_viem9.formatGwei)(gasPrice),
+    nativeSymbol: NATIVE_SYMBOLS[network]
   };
 }
-function executeSmartPayDemo(input) {
-  const network = input.preferredNetwork ?? "arbitrum";
-  return {
-    success: true,
-    statusCode: 200,
-    body: `[Demo] Premium content from ${input.url}
+function formatGasPriceResult(result) {
+  return [
+    "## Gas Price",
+    "",
+    `- **Network:** ${result.network}`,
+    `- **Gas Price:** ${result.gasPriceGwei} gwei`,
+    `- **Native Token:** ${result.nativeSymbol}`
+  ].join("\n");
+}
 
-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"
-    }
-  };
+// src/tools/estimatePaymentFee.ts
+var import_zod17 = require("zod");
+var import_viem10 = require("viem");
+var chains8 = __toESM(require("viem/chains"));
+var estimatePaymentFeeInputSchema = import_zod17.z.object({
+  network: import_zod17.z.enum([
+    "ethereum",
+    "base",
+    "arbitrum",
+    "optimism",
+    "polygon",
+    "avalanche",
+    "ink",
+    "berachain",
+    "unichain"
+  ]).describe("Network to estimate fee on"),
+  amount: import_zod17.z.string().regex(/^\d+(\.\d+)?$/).describe("Payment amount (e.g., '100')"),
+  token: import_zod17.z.enum(["USDC", "USDT", "USDT0"]).describe("Token to use for payment")
+});
+function getViemChain7(network) {
+  switch (network) {
+    case "ethereum":
+      return chains8.mainnet;
+    case "base":
+      return chains8.base;
+    case "arbitrum":
+      return chains8.arbitrum;
+    case "optimism":
+      return chains8.optimism;
+    case "polygon":
+      return chains8.polygon;
+    case "avalanche":
+      return chains8.avalanche;
+    case "ink":
+      return chains8.ink;
+    case "berachain":
+      return chains8.berachain;
+    case "unichain":
+      return chains8.unichain;
+    default:
+      return chains8.mainnet;
+  }
 }
-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"
+async function executeEstimatePaymentFee(input, options) {
+  const { network, amount, token } = input;
+  const nativeSymbol = NATIVE_SYMBOLS[network];
+  if (options.demoMode) {
+    const demoEstimates = {
+      ethereum: { gasLimit: 65000n, gasPrice: 25000000000n, nativePrice: 3250.42 },
+      base: { gasLimit: 65000n, gasPrice: 50000000n, nativePrice: 3250.42 },
+      arbitrum: { gasLimit: 65000n, gasPrice: 100000000n, nativePrice: 3250.42 },
+      optimism: { gasLimit: 65000n, gasPrice: 50000000n, nativePrice: 3250.42 },
+      polygon: { gasLimit: 65000n, gasPrice: 30000000000n, nativePrice: 0.58 },
+      avalanche: { gasLimit: 65000n, gasPrice: 25000000000n, nativePrice: 24.15 },
+      ink: { gasLimit: 65000n, gasPrice: 50000000n, nativePrice: 3250.42 },
+      berachain: { gasLimit: 65000n, gasPrice: 1000000000n, nativePrice: 3.82 },
+      unichain: { gasLimit: 65000n, gasPrice: 50000000n, nativePrice: 3250.42 }
     };
-  });
-  const requiredBigint = requiredAmount ? BigInt(requiredAmount) : 0n;
-  const bestChain = await wdk.findBestChainForPayment(requiredBigint);
-  if (bestChain) {
-    const needsBridge = targetNetwork ? !bestChain.chain.includes(targetNetwork) : false;
+    const est = demoEstimates[network] ?? demoEstimates["ethereum"];
+    const nativeCost2 = est.gasLimit * est.gasPrice;
+    const usdCost2 = Number(nativeCost2) / 1e18 * est.nativePrice;
     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
+      network,
+      gasLimit: est.gasLimit.toString(),
+      gasPriceGwei: (0, import_viem10.formatGwei)(est.gasPrice),
+      nativeCost: (0, import_viem10.formatEther)(nativeCost2),
+      nativeSymbol,
+      usdCost: `$${usdCost2.toFixed(4)}`
     };
   }
+  const tokenAddress = getTokenAddress(network, token);
+  if (!tokenAddress) {
+    throw new Error(`Token ${token} is not supported on ${network}`);
+  }
+  const chain = getViemChain7(network);
+  const transport = (0, import_viem10.http)(options.rpcUrl ?? DEFAULT_RPC_URLS[network]);
+  const client = (0, import_viem10.createPublicClient)({ chain, transport });
+  const amountBigInt = (0, import_viem10.parseUnits)(amount, 6);
+  const dummyTo = "0x000000000000000000000000000000000000dEaD";
+  let gasLimit;
+  try {
+    gasLimit = await client.estimateGas({
+      to: tokenAddress,
+      data: `0xa9059cbb${dummyTo.slice(2).padStart(64, "0")}${amountBigInt.toString(16).padStart(64, "0")}`
+    });
+  } catch {
+    gasLimit = 65000n;
+  }
+  const gasPrice = await client.getGasPrice();
+  const nativeCost = gasLimit * gasPrice;
+  let usdCost;
+  try {
+    const prices = await getTokenPrices([nativeSymbol]);
+    const nativePrice = prices[nativeSymbol] ?? 0;
+    const cost = Number(nativeCost) / 1e18 * nativePrice;
+    usdCost = `$${cost.toFixed(4)}`;
+  } catch {
+    usdCost = "N/A";
+  }
   return {
-    viable: false,
-    bridgeRequired: false,
-    balances,
-    reason: "Insufficient balance across all chains"
+    network,
+    gasLimit: gasLimit.toString(),
+    gasPriceGwei: (0, import_viem10.formatGwei)(gasPrice),
+    nativeCost: (0, import_viem10.formatEther)(nativeCost),
+    nativeSymbol,
+    usdCost
   };
 }
-function executePaymentPlanDemo(_input) {
-  return {
-    viable: true,
-    recommendedNetwork: "arbitrum",
-    availableBalance: "500000000",
-    bridgeRequired: false,
-    balances: [
+function formatPaymentFeeEstimate(result) {
+  return [
+    "## Payment Fee Estimate",
+    "",
+    `- **Network:** ${result.network}`,
+    `- **Estimated Gas:** ${result.gasLimit}`,
+    `- **Gas Price:** ${result.gasPriceGwei} gwei`,
+    `- **Native Cost:** ${result.nativeCost} ${result.nativeSymbol}`,
+    `- **USD Cost:** ${result.usdCost}`
+  ].join("\n");
+}
+
+// src/tools/compareNetworkFees.ts
+var import_zod18 = require("zod");
+var compareNetworkFeesInputSchema = import_zod18.z.object({
+  amount: import_zod18.z.string().regex(/^\d+(\.\d+)?$/).describe("Payment amount (e.g., '100')"),
+  token: import_zod18.z.enum(["USDC", "USDT", "USDT0"]).describe("Token to use for payment"),
+  networks: import_zod18.z.array(import_zod18.z.string()).optional().describe(
+    "Networks to compare. If not provided, compares all networks that support the token."
+  )
+});
+var ALL_NETWORKS2 = [
+  "ethereum",
+  "base",
+  "arbitrum",
+  "optimism",
+  "polygon",
+  "avalanche",
+  "ink",
+  "berachain",
+  "unichain"
+];
+async function executeCompareNetworkFees(input, options) {
+  const { amount, token } = input;
+  const requestedNetworks = input.networks ? input.networks : ALL_NETWORKS2;
+  const networks = requestedNetworks.filter((n) => supportsToken(n, token));
+  if (networks.length === 0) {
+    throw new Error(`No supported networks found for token ${token}`);
+  }
+  const results = await Promise.allSettled(
+    networks.map(
+      (network) => executeEstimatePaymentFee(
+        { network, amount, token },
+        {
+          rpcUrl: options.rpcUrls?.[network],
+          demoMode: options.demoMode
+        }
+      )
+    )
+  );
+  const fees = [];
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      fees.push(result.value);
+    }
+  }
+  if (fees.length === 0) {
+    throw new Error("Failed to estimate fees on any network");
+  }
+  fees.sort((a, b) => {
+    const costA = parseFloat(a.nativeCost) || Infinity;
+    const costB = parseFloat(b.nativeCost) || Infinity;
+    const usdA = parseFloat(a.usdCost.replace("$", "")) || Infinity;
+    const usdB = parseFloat(b.usdCost.replace("$", "")) || Infinity;
+    return usdA - usdB || costA - costB;
+  });
+  return {
+    token,
+    amount,
+    fees,
+    cheapest: fees[0].network
+  };
+}
+function formatNetworkFeeComparison(result) {
+  const lines = [
+    "## Network Fee Comparison",
+    "",
+    `**Token:** ${result.token} | **Amount:** ${result.amount}`,
+    `**Cheapest:** ${result.cheapest}`,
+    "",
+    "| Network | Gas Price | Native Cost | USD Cost |",
+    "|---------|----------|-------------|----------|"
+  ];
+  for (const fee of result.fees) {
+    const marker = fee.network === result.cheapest ? " *" : "";
+    lines.push(
+      `| ${fee.network}${marker} | ${fee.gasPriceGwei} gwei | ${fee.nativeCost} ${fee.nativeSymbol} | ${fee.usdCost} |`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/tools/signMessage.ts
+var import_zod19 = require("zod");
+var signMessageInputSchema = import_zod19.z.object({
+  chain: import_zod19.z.enum([
+    "ethereum",
+    "base",
+    "arbitrum",
+    "optimism",
+    "polygon",
+    "avalanche",
+    "ink",
+    "berachain",
+    "unichain"
+  ]).describe("Blockchain network context for signing"),
+  message: import_zod19.z.string().min(1).describe("Message to sign")
+});
+
+// src/tools/verifySignature.ts
+var import_zod20 = require("zod");
+var import_viem11 = require("viem");
+var verifySignatureInputSchema = import_zod20.z.object({
+  chain: import_zod20.z.enum([
+    "ethereum",
+    "base",
+    "arbitrum",
+    "optimism",
+    "polygon",
+    "avalanche",
+    "ink",
+    "berachain",
+    "unichain"
+  ]).describe("Blockchain network context for verification"),
+  message: import_zod20.z.string().min(1).describe("The original message that was signed"),
+  signature: import_zod20.z.string().regex(/^0x[a-fA-F0-9]+$/).describe("The signature to verify (hex string)"),
+  address: import_zod20.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("The expected signer address")
+});
+
+// src/tools/getTransferHistory.ts
+var import_zod21 = require("zod");
+var import_viem12 = require("viem");
+var chains9 = __toESM(require("viem/chains"));
+var getTransferHistoryInputSchema = import_zod21.z.object({
+  network: import_zod21.z.enum([
+    "ethereum",
+    "base",
+    "arbitrum",
+    "optimism",
+    "polygon",
+    "avalanche",
+    "ink",
+    "berachain",
+    "unichain"
+  ]).describe("Blockchain network to query"),
+  address: import_zod21.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("Wallet address to get transfer history for"),
+  token: import_zod21.z.enum(["USDC", "USDT", "USDT0"]).optional().describe("Filter by specific token. If not provided, queries all supported stablecoins."),
+  limit: import_zod21.z.number().int().min(1).max(100).optional().describe("Maximum number of transfers to return (default: 10, max: 100)")
+});
+
+// src/tools/getHistoricalPrice.ts
+var import_zod22 = require("zod");
+var getHistoricalPriceInputSchema = import_zod22.z.object({
+  token: import_zod22.z.string().min(1).describe('Token symbol (e.g., "ETH", "USDC", "USDT", "MATIC", "AVAX")'),
+  days: import_zod22.z.number().int().min(1).max(365).optional().describe("Number of days of history to retrieve (default: 7, max: 365)")
+});
+
+// src/tools/quoteStore.ts
+var import_crypto = require("crypto");
+var DEFAULT_TTL_MS = 5 * 60 * 1e3;
+var quotes = /* @__PURE__ */ new Map();
+var cleanupInterval = null;
+function ensureCleanup() {
+  if (cleanupInterval) return;
+  cleanupInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [id, quote] of quotes) {
+      if (now > quote.expiresAt) {
+        quotes.delete(id);
+      }
+    }
+  }, 6e4);
+  if (cleanupInterval.unref) {
+    cleanupInterval.unref();
+  }
+}
+function createQuote(type, data, ttlMs = DEFAULT_TTL_MS) {
+  ensureCleanup();
+  const id = (0, import_crypto.randomUUID)();
+  const now = Date.now();
+  quotes.set(id, {
+    id,
+    type,
+    createdAt: now,
+    expiresAt: now + ttlMs,
+    data
+  });
+  return id;
+}
+function getQuote(quoteId) {
+  const quote = quotes.get(quoteId);
+  if (!quote) return null;
+  if (Date.now() > quote.expiresAt) {
+    quotes.delete(quoteId);
+    return null;
+  }
+  return quote;
+}
+function deleteQuote(quoteId) {
+  quotes.delete(quoteId);
+}
+
+// src/tools/wdkQuoteSwap.ts
+var import_zod23 = require("zod");
+var import_viem13 = require("viem");
+var wdkQuoteSwapInputSchema = import_zod23.z.object({
+  fromToken: import_zod23.z.string().describe('Token to swap from (e.g., "ETH", "USDC")'),
+  toToken: import_zod23.z.string().describe('Token to swap to (e.g., "USDT0", "USDC")'),
+  amount: import_zod23.z.string().regex(/^\d+(\.\d+)?$/).describe("Amount to swap (e.g., '1.0')"),
+  chain: import_zod23.z.string().describe('Chain to execute swap on (e.g., "ethereum", "arbitrum")')
+});
+async function executeWdkQuoteSwap(input, wdk) {
+  const decimals = ["USDC", "USDT", "USDT0"].includes(input.fromToken.toUpperCase()) ? 6 : 18;
+  const amountBigInt = (0, import_viem13.parseUnits)(input.amount, decimals);
+  const quote = await wdk.getSwapQuote(input.chain, input.fromToken, amountBigInt);
+  const outputDecimals = ["USDC", "USDT", "USDT0"].includes(input.toToken.toUpperCase()) ? 6 : 18;
+  const outputDivisor = 10 ** outputDecimals;
+  const toAmount = (Number(quote.outputAmount) / outputDivisor).toFixed(outputDecimals === 6 ? 6 : 8);
+  const inputAmount = parseFloat(input.amount);
+  const outputAmount = parseFloat(toAmount);
+  const exchangeRate = inputAmount > 0 ? (outputAmount / inputAmount).toFixed(6) : "0";
+  const expiresAt = new Date(Date.now() + 5 * 60 * 1e3).toISOString();
+  const quoteId = createQuote("swap", {
+    fromToken: input.fromToken,
+    toToken: input.toToken,
+    fromAmount: input.amount,
+    toAmount,
+    chain: input.chain,
+    exchangeRate
+  });
+  return {
+    quoteId,
+    fromToken: input.fromToken,
+    toToken: input.toToken,
+    fromAmount: input.amount,
+    toAmount,
+    exchangeRate,
+    fee: "0.3%",
+    priceImpact: "< 0.1%",
+    expiresAt,
+    chain: input.chain
+  };
+}
+function executeWdkQuoteSwapDemo(input) {
+  const inputAmount = parseFloat(input.amount);
+  const toAmount = (inputAmount * 0.997).toFixed(6);
+  const exchangeRate = 0.997.toFixed(6);
+  const expiresAt = new Date(Date.now() + 5 * 60 * 1e3).toISOString();
+  const quoteId = createQuote("swap", {
+    fromToken: input.fromToken,
+    toToken: input.toToken,
+    fromAmount: input.amount,
+    toAmount,
+    chain: input.chain,
+    exchangeRate
+  });
+  return {
+    quoteId,
+    fromToken: input.fromToken,
+    toToken: input.toToken,
+    fromAmount: input.amount,
+    toAmount,
+    exchangeRate,
+    fee: "0.3%",
+    priceImpact: "< 0.1%",
+    expiresAt,
+    chain: input.chain
+  };
+}
+function formatSwapQuoteResult(result) {
+  return [
+    "## Swap Quote",
+    "",
+    `- **Quote ID:** \`${result.quoteId}\``,
+    `- **From:** ${result.fromAmount} ${result.fromToken}`,
+    `- **To:** ${result.toAmount} ${result.toToken}`,
+    `- **Exchange Rate:** ${result.exchangeRate}`,
+    `- **Fee:** ${result.fee}`,
+    `- **Price Impact:** ${result.priceImpact}`,
+    `- **Chain:** ${result.chain}`,
+    `- **Expires:** ${result.expiresAt}`,
+    "",
+    "_Call `wdk/executeSwap` with the quoteId to execute this swap._"
+  ].join("\n");
+}
+
+// src/tools/wdkExecuteSwap.ts
+var import_zod24 = require("zod");
+var import_viem14 = require("viem");
+var wdkExecuteSwapInputSchema = import_zod24.z.object({
+  quoteId: import_zod24.z.string().uuid().describe("Quote ID from wdk/quoteSwap"),
+  confirmed: import_zod24.z.boolean().optional().describe("Set to true to confirm and execute this swap")
+});
+async function executeWdkExecuteSwap(input, wdk) {
+  const quote = getQuote(input.quoteId);
+  if (!quote) {
+    throw new Error("Quote not found or expired. Please request a new quote.");
+  }
+  if (quote.type !== "swap") {
+    throw new Error("Invalid quote type. Expected a swap quote.");
+  }
+  const { fromToken, toToken, fromAmount, toAmount, chain } = quote.data;
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Swap ${fromAmount} ${fromToken} to ${toAmount} ${toToken} on ${chain}`,
+      details: { fromToken, toToken, fromAmount, toAmount, chain, quoteId: input.quoteId }
+    };
+  }
+  const decimals = ["USDC", "USDT", "USDT0"].includes(fromToken.toUpperCase()) ? 6 : 18;
+  const amountBigInt = (0, import_viem14.parseUnits)(fromAmount, decimals);
+  const result = await wdk.swapAndPay({
+    chain,
+    fromToken,
+    amount: amountBigInt
+  });
+  deleteQuote(input.quoteId);
+  return {
+    fromAmount,
+    fromToken,
+    toAmount,
+    toToken,
+    chain,
+    txHash: result?.txHash ?? "0x"
+  };
+}
+function executeWdkExecuteSwapDemo(input) {
+  const quote = getQuote(input.quoteId);
+  if (!quote) {
+    throw new Error("Quote not found or expired. Please request a new quote.");
+  }
+  if (quote.type !== "swap") {
+    throw new Error("Invalid quote type. Expected a swap quote.");
+  }
+  const { fromToken, toToken, fromAmount, toAmount, chain } = quote.data;
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Swap ${fromAmount} ${fromToken} to ${toAmount} ${toToken} on ${chain}`,
+      details: { fromToken, toToken, fromAmount, toAmount, chain, quoteId: input.quoteId }
+    };
+  }
+  deleteQuote(input.quoteId);
+  return {
+    fromAmount,
+    fromToken,
+    toAmount,
+    toToken,
+    chain,
+    txHash: "0xdemo" + Math.random().toString(16).slice(2, 10)
+  };
+}
+function formatExecuteSwapResult(result) {
+  return [
+    "## Swap Executed",
+    "",
+    `- **From:** ${result.fromAmount} ${result.fromToken}`,
+    `- **To:** ${result.toAmount} ${result.toToken}`,
+    `- **Chain:** ${result.chain}`,
+    `- **Tx Hash:** \`${result.txHash}\``
+  ].join("\n");
+}
+
+// src/tools/quoteBridge.ts
+var import_zod25 = require("zod");
+var quoteBridgeInputSchema = import_zod25.z.object({
+  fromChain: import_zod25.z.enum(["ethereum", "arbitrum", "ink", "berachain", "unichain"]).describe("Source chain to bridge from"),
+  toChain: import_zod25.z.enum(["ethereum", "arbitrum", "ink", "berachain", "unichain"]).describe("Destination chain to bridge to"),
+  amount: import_zod25.z.string().regex(/^\d+(\.\d+)?$/).describe("Amount of USDT0 to bridge (e.g., '100' for 100 USDT0)"),
+  recipient: import_zod25.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("Recipient address on destination chain")
+});
+async function executeQuoteBridge(input, rpcUrls) {
+  const feeResult = await executeGetBridgeFee(input, rpcUrls);
+  const expiresAt = new Date(Date.now() + 5 * 60 * 1e3).toISOString();
+  const quoteId = createQuote("bridge", {
+    fromChain: input.fromChain,
+    toChain: input.toChain,
+    amount: input.amount,
+    recipient: input.recipient,
+    nativeFee: feeResult.nativeFee,
+    nativeFeeFormatted: feeResult.nativeFeeFormatted,
+    estimatedTime: feeResult.estimatedTime
+  });
+  return {
+    quoteId,
+    fromChain: input.fromChain,
+    toChain: input.toChain,
+    amount: input.amount,
+    recipient: input.recipient,
+    nativeFee: feeResult.nativeFee,
+    nativeFeeFormatted: feeResult.nativeFeeFormatted,
+    estimatedTime: feeResult.estimatedTime,
+    expiresAt
+  };
+}
+function executeQuoteBridgeDemo(input) {
+  const expiresAt = new Date(Date.now() + 5 * 60 * 1e3).toISOString();
+  const estimatedTime = input.toChain === "ethereum" ? 900 : 300;
+  const quoteId = createQuote("bridge", {
+    fromChain: input.fromChain,
+    toChain: input.toChain,
+    amount: input.amount,
+    recipient: input.recipient,
+    nativeFee: "1000000000000000",
+    nativeFeeFormatted: "0.001 ETH",
+    estimatedTime
+  });
+  return {
+    quoteId,
+    fromChain: input.fromChain,
+    toChain: input.toChain,
+    amount: input.amount,
+    recipient: input.recipient,
+    nativeFee: "1000000000000000",
+    nativeFeeFormatted: "0.001 ETH",
+    estimatedTime,
+    expiresAt
+  };
+}
+function formatBridgeQuoteResult(result) {
+  const minutes = Math.ceil(result.estimatedTime / 60);
+  return [
+    "## Bridge Quote",
+    "",
+    `- **Quote ID:** \`${result.quoteId}\``,
+    `- **Route:** ${result.fromChain} -> ${result.toChain}`,
+    `- **Amount:** ${result.amount} USDT0`,
+    `- **Recipient:** \`${result.recipient}\``,
+    `- **Fee:** ${result.nativeFeeFormatted}`,
+    `- **Estimated Time:** ~${minutes} minutes`,
+    `- **Expires:** ${result.expiresAt}`,
+    "",
+    "_Call `t402/executeBridge` with the quoteId to execute this bridge._"
+  ].join("\n");
+}
+
+// src/tools/executeBridgeFromQuote.ts
+var import_zod26 = require("zod");
+var executeBridgeFromQuoteInputSchema = import_zod26.z.object({
+  quoteId: import_zod26.z.string().uuid().describe("Quote ID from t402/quoteBridge"),
+  confirmed: import_zod26.z.boolean().optional().describe("Set to true to confirm and execute this bridge")
+});
+async function executeExecuteBridgeFromQuote(input, options) {
+  const quote = getQuote(input.quoteId);
+  if (!quote) {
+    throw new Error("Quote not found or expired. Please request a new quote.");
+  }
+  if (quote.type !== "bridge") {
+    throw new Error("Invalid quote type. Expected a bridge quote.");
+  }
+  const { fromChain, toChain, amount, recipient } = quote.data;
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Bridge ${amount} USDT0 from ${fromChain} to ${toChain}`,
+      details: { fromChain, toChain, amount, recipient, quoteId: input.quoteId }
+    };
+  }
+  const result = await executeBridge(
+    { fromChain, toChain, amount, recipient, confirmed: true },
+    options
+  );
+  if ("needsConfirmation" in result) {
+    return result;
+  }
+  deleteQuote(input.quoteId);
+  return result;
+}
+function executeExecuteBridgeFromQuoteDemo(input) {
+  const quote = getQuote(input.quoteId);
+  if (!quote) {
+    throw new Error("Quote not found or expired. Please request a new quote.");
+  }
+  if (quote.type !== "bridge") {
+    throw new Error("Invalid quote type. Expected a bridge quote.");
+  }
+  const { fromChain, toChain, amount, recipient } = quote.data;
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Bridge ${amount} USDT0 from ${fromChain} to ${toChain}`,
+      details: { fromChain, toChain, amount, recipient, quoteId: input.quoteId }
+    };
+  }
+  deleteQuote(input.quoteId);
+  const fakeTxHash = `0x${"a".repeat(64)}`;
+  const fakeGuid = `0x${"b".repeat(64)}`;
+  return {
+    txHash: fakeTxHash,
+    messageGuid: fakeGuid,
+    amount,
+    fromChain,
+    toChain,
+    estimatedTime: quote.data.estimatedTime ?? 300,
+    trackingUrl: `https://layerzeroscan.com/tx/${fakeGuid}`
+  };
+}
+
+// src/tools/unified.ts
+var import_zod27 = require("zod");
+var smartPayInputSchema = import_zod27.z.object({
+  url: import_zod27.z.string().url().describe("URL of the 402-protected resource"),
+  maxBridgeFee: import_zod27.z.string().regex(/^\d+(\.\d+)?$/).optional().describe("Maximum acceptable bridge fee in native token (optional)"),
+  preferredNetwork: import_zod27.z.string().optional().describe("Preferred network for payment (optional)"),
+  confirmed: import_zod27.z.boolean().optional().describe("Set to true to confirm and execute this payment")
+});
+var paymentPlanInputSchema = import_zod27.z.object({
+  paymentRequired: import_zod27.z.object({
+    scheme: import_zod27.z.string().optional(),
+    network: import_zod27.z.string().optional(),
+    maxAmountRequired: import_zod27.z.string().optional(),
+    resource: import_zod27.z.string().optional(),
+    description: import_zod27.z.string().optional(),
+    payTo: import_zod27.z.string().optional(),
+    maxDeadline: import_zod27.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)"
+        },
+        confirmed: {
+          type: "boolean",
+          description: "Set to true to confirm and execute. Omit for a preview/confirmation prompt."
+        }
+      },
+      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) {
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Smart-pay for ${input.url}${input.preferredNetwork ? ` on ${input.preferredNetwork}` : ""}`,
+      details: {
+        url: input.url,
+        ...input.maxBridgeFee ? { maxBridgeFee: input.maxBridgeFee } : {},
+        ...input.preferredNetwork ? { preferredNetwork: input.preferredNetwork } : {}
+      }
+    };
+  }
+  const steps = [];
+  const chains10 = input.preferredNetwork ? [input.preferredNetwork] : ["ethereum", "arbitrum", "base"];
+  steps.push({
+    action: "check_balance",
+    status: "success",
+    detail: `Checking balances on ${chains10.join(", ")}`
+  });
+  const { T402Protocol } = await import("@t402/wdk-protocol");
+  const protocol = await T402Protocol.create(wdk, { chains: chains10 });
+  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) {
+  if (!input.confirmed) {
+    return {
+      needsConfirmation: true,
+      summary: `Smart-pay for ${input.url}${input.preferredNetwork ? ` on ${input.preferredNetwork}` : ""}`,
+      details: {
+        url: input.url,
+        ...input.maxBridgeFee ? { maxBridgeFee: input.maxBridgeFee } : {},
+        ...input.preferredNetwork ? { preferredNetwork: input.preferredNetwork } : {}
+      }
+    };
+  }
+  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" }
@@ -2178,49 +3087,225 @@ var TOOL_DEFINITIONS = {
             "berachain",
             "unichain"
           ],
-          description: "Network to execute payment on"
+          description: "Network to execute payment on"
+        },
+        memo: {
+          type: "string",
+          description: "Optional memo/reference for the payment"
+        },
+        confirmed: {
+          type: "boolean",
+          description: "Set to true to confirm and execute. Omit for a preview/confirmation prompt."
+        }
+      },
+      required: ["to", "amount", "token", "network"]
+    }
+  },
+  "t402/payGasless": {
+    name: "t402/payGasless",
+    description: "Execute a gasless stablecoin payment using ERC-4337 account abstraction. Gas fees are sponsored by a paymaster, so no ETH is needed for the transaction. Supported on select networks.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        to: {
+          type: "string",
+          pattern: "^0x[a-fA-F0-9]{40}$",
+          description: "Recipient address"
+        },
+        amount: {
+          type: "string",
+          pattern: "^\\d+(\\.\\d+)?$",
+          description: "Amount to pay (e.g., '10.50' for 10.50 USDC)"
+        },
+        token: {
+          type: "string",
+          enum: ["USDC", "USDT", "USDT0"],
+          description: "Token to use for payment"
+        },
+        network: {
+          type: "string",
+          enum: ["ethereum", "base", "arbitrum", "optimism", "polygon", "avalanche"],
+          description: "Network to execute gasless payment on (must support ERC-4337)"
+        },
+        confirmed: {
+          type: "boolean",
+          description: "Set to true to confirm and execute. Omit for a preview/confirmation prompt."
+        }
+      },
+      required: ["to", "amount", "token", "network"]
+    }
+  },
+  "t402/getBridgeFee": {
+    name: "t402/getBridgeFee",
+    description: "Get the fee quote for bridging USDT0 between chains using LayerZero OFT. Returns the native token fee required and estimated delivery time. Supported chains: ethereum, arbitrum, ink, berachain, unichain.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        fromChain: {
+          type: "string",
+          enum: ["ethereum", "arbitrum", "ink", "berachain", "unichain"],
+          description: "Source chain to bridge from"
+        },
+        toChain: {
+          type: "string",
+          enum: ["ethereum", "arbitrum", "ink", "berachain", "unichain"],
+          description: "Destination chain to bridge to"
+        },
+        amount: {
+          type: "string",
+          pattern: "^\\d+(\\.\\d+)?$",
+          description: "Amount of USDT0 to bridge (e.g., '100' for 100 USDT0)"
+        },
+        recipient: {
+          type: "string",
+          pattern: "^0x[a-fA-F0-9]{40}$",
+          description: "Recipient address on destination chain"
+        }
+      },
+      required: ["fromChain", "toChain", "amount", "recipient"]
+    }
+  },
+  "t402/bridge": {
+    name: "t402/bridge",
+    description: "Bridge USDT0 between chains using LayerZero OFT standard. Executes a cross-chain transfer and returns the LayerZero message GUID for tracking. Supported chains: ethereum, arbitrum, ink, berachain, unichain.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        fromChain: {
+          type: "string",
+          enum: ["ethereum", "arbitrum", "ink", "berachain", "unichain"],
+          description: "Source chain to bridge from"
+        },
+        toChain: {
+          type: "string",
+          enum: ["ethereum", "arbitrum", "ink", "berachain", "unichain"],
+          description: "Destination chain to bridge to"
+        },
+        amount: {
+          type: "string",
+          pattern: "^\\d+(\\.\\d+)?$",
+          description: "Amount of USDT0 to bridge (e.g., '100' for 100 USDT0)"
+        },
+        recipient: {
+          type: "string",
+          pattern: "^0x[a-fA-F0-9]{40}$",
+          description: "Recipient address on destination chain"
+        },
+        confirmed: {
+          type: "boolean",
+          description: "Set to true to confirm and execute. Omit for a preview/confirmation prompt."
+        }
+      },
+      required: ["fromChain", "toChain", "amount", "recipient"]
+    }
+  },
+  "t402/getTokenPrice": {
+    name: "t402/getTokenPrice",
+    description: "Get current market prices for tokens (ETH, MATIC, AVAX, USDC, etc.) via CoinGecko. Cached for 5 minutes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tokens: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Token symbols to get prices for (e.g., ["ETH", "MATIC", "USDC"])'
+        },
+        currency: {
+          type: "string",
+          description: 'Target currency (default: "usd")'
+        }
+      },
+      required: ["tokens"]
+    }
+  },
+  "t402/getGasPrice": {
+    name: "t402/getGasPrice",
+    description: "Get the current gas price on a specific blockchain network. Returns the price in gwei.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        network: {
+          type: "string",
+          enum: [
+            "ethereum",
+            "base",
+            "arbitrum",
+            "optimism",
+            "polygon",
+            "avalanche",
+            "ink",
+            "berachain",
+            "unichain"
+          ],
+          description: "Blockchain network to check gas price on"
+        }
+      },
+      required: ["network"]
+    }
+  },
+  "t402/estimatePaymentFee": {
+    name: "t402/estimatePaymentFee",
+    description: "Estimate the gas cost (in native token and USD) for a stablecoin payment on a specific network.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        network: {
+          type: "string",
+          enum: [
+            "ethereum",
+            "base",
+            "arbitrum",
+            "optimism",
+            "polygon",
+            "avalanche",
+            "ink",
+            "berachain",
+            "unichain"
+          ],
+          description: "Network to estimate fee on"
         },
-        memo: {
+        amount: {
           type: "string",
-          description: "Optional memo/reference for the payment"
+          pattern: "^\\d+(\\.\\d+)?$",
+          description: "Payment amount (e.g., '100')"
+        },
+        token: {
+          type: "string",
+          enum: ["USDC", "USDT", "USDT0"],
+          description: "Token to use for payment"
         }
       },
-      required: ["to", "amount", "token", "network"]
+      required: ["network", "amount", "token"]
     }
   },
-  "t402/payGasless": {
-    name: "t402/payGasless",
-    description: "Execute a gasless stablecoin payment using ERC-4337 account abstraction. Gas fees are sponsored by a paymaster, so no ETH is needed for the transaction. Supported on select networks.",
+  "t402/compareNetworkFees": {
+    name: "t402/compareNetworkFees",
+    description: "Compare payment fees across multiple networks for the same token. Returns a sorted table from cheapest to most expensive.",
     inputSchema: {
       type: "object",
       properties: {
-        to: {
-          type: "string",
-          pattern: "^0x[a-fA-F0-9]{40}$",
-          description: "Recipient address"
-        },
         amount: {
           type: "string",
           pattern: "^\\d+(\\.\\d+)?$",
-          description: "Amount to pay (e.g., '10.50' for 10.50 USDC)"
+          description: "Payment amount (e.g., '100')"
         },
         token: {
           type: "string",
           enum: ["USDC", "USDT", "USDT0"],
           description: "Token to use for payment"
         },
-        network: {
-          type: "string",
-          enum: ["ethereum", "base", "arbitrum", "optimism", "polygon", "avalanche"],
-          description: "Network to execute gasless payment on (must support ERC-4337)"
+        networks: {
+          type: "array",
+          items: { type: "string" },
+          description: "Networks to compare. If not provided, compares all networks that support the token."
         }
       },
-      required: ["to", "amount", "token", "network"]
+      required: ["amount", "token"]
     }
   },
-  "t402/getBridgeFee": {
-    name: "t402/getBridgeFee",
-    description: "Get the fee quote for bridging USDT0 between chains using LayerZero OFT. Returns the native token fee required and estimated delivery time. Supported chains: ethereum, arbitrum, ink, berachain, unichain.",
+  "t402/quoteBridge": {
+    name: "t402/quoteBridge",
+    description: "Get a bridge fee quote with a quoteId for later execution. Like getBridgeFee but returns a reusable quoteId. Call t402/executeBridge with the quoteId to execute.",
     inputSchema: {
       type: "object",
       properties: {
@@ -2248,34 +3333,147 @@ var TOOL_DEFINITIONS = {
       required: ["fromChain", "toChain", "amount", "recipient"]
     }
   },
-  "t402/bridge": {
-    name: "t402/bridge",
-    description: "Bridge USDT0 between chains using LayerZero OFT standard. Executes a cross-chain transfer and returns the LayerZero message GUID for tracking. Supported chains: ethereum, arbitrum, ink, berachain, unichain.",
+  "t402/executeBridgeQuote": {
+    name: "t402/executeBridgeQuote",
+    description: "Execute a bridge using a quoteId from t402/quoteBridge. Requires confirmation.",
     inputSchema: {
       type: "object",
       properties: {
-        fromChain: {
+        quoteId: {
           type: "string",
-          enum: ["ethereum", "arbitrum", "ink", "berachain", "unichain"],
-          description: "Source chain to bridge from"
+          description: "Quote ID from t402/quoteBridge"
         },
-        toChain: {
+        confirmed: {
+          type: "boolean",
+          description: "Set to true to confirm and execute. Omit for a preview/confirmation prompt."
+        }
+      },
+      required: ["quoteId"]
+    }
+  },
+  "t402/signMessage": {
+    name: "t402/signMessage",
+    description: "Sign a message using the configured wallet. Returns an EIP-191 personal signature. Requires a configured private key.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        chain: {
           type: "string",
-          enum: ["ethereum", "arbitrum", "ink", "berachain", "unichain"],
-          description: "Destination chain to bridge to"
+          enum: [
+            "ethereum",
+            "base",
+            "arbitrum",
+            "optimism",
+            "polygon",
+            "avalanche",
+            "ink",
+            "berachain",
+            "unichain"
+          ],
+          description: "Blockchain network context for signing"
         },
-        amount: {
+        message: {
           type: "string",
-          pattern: "^\\d+(\\.\\d+)?$",
-          description: "Amount of USDT0 to bridge (e.g., '100' for 100 USDT0)"
+          description: "Message to sign"
+        }
+      },
+      required: ["chain", "message"]
+    }
+  },
+  "t402/verifySignature": {
+    name: "t402/verifySignature",
+    description: "Verify an EIP-191 signed message. Checks whether a signature was produced by the claimed address. No wallet configuration needed \u2014 this is a read-only verification.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        chain: {
+          type: "string",
+          enum: [
+            "ethereum",
+            "base",
+            "arbitrum",
+            "optimism",
+            "polygon",
+            "avalanche",
+            "ink",
+            "berachain",
+            "unichain"
+          ],
+          description: "Blockchain network context for verification"
         },
-        recipient: {
+        message: {
+          type: "string",
+          description: "The original message that was signed"
+        },
+        signature: {
+          type: "string",
+          pattern: "^0x[a-fA-F0-9]+$",
+          description: "The signature to verify (hex string)"
+        },
+        address: {
           type: "string",
           pattern: "^0x[a-fA-F0-9]{40}$",
-          description: "Recipient address on destination chain"
+          description: "The expected signer address"
         }
       },
-      required: ["fromChain", "toChain", "amount", "recipient"]
+      required: ["chain", "message", "signature", "address"]
+    }
+  },
+  "t402/getTransferHistory": {
+    name: "t402/getTransferHistory",
+    description: "Get recent ERC-20 stablecoin transfer history for a wallet address. Queries on-chain Transfer events for USDC, USDT, and USDT0. Returns sent and received transfers sorted by most recent.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        network: {
+          type: "string",
+          enum: [
+            "ethereum",
+            "base",
+            "arbitrum",
+            "optimism",
+            "polygon",
+            "avalanche",
+            "ink",
+            "berachain",
+            "unichain"
+          ],
+          description: "Blockchain network to query"
+        },
+        address: {
+          type: "string",
+          pattern: "^0x[a-fA-F0-9]{40}$",
+          description: "Wallet address to get transfer history for"
+        },
+        token: {
+          type: "string",
+          enum: ["USDC", "USDT", "USDT0"],
+          description: "Filter by specific token. If not provided, queries all supported stablecoins."
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of transfers to return (default: 10, max: 100)"
+        }
+      },
+      required: ["network", "address"]
+    }
+  },
+  "t402/getHistoricalPrice": {
+    name: "t402/getHistoricalPrice",
+    description: "Get historical price data for a token over a specified period via CoinGecko. Returns price data points, high/low, and percentage change. Useful for trend analysis.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        token: {
+          type: "string",
+          description: 'Token symbol (e.g., "ETH", "USDC", "USDT", "MATIC", "AVAX", "BTC", "SOL")'
+        },
+        days: {
+          type: "number",
+          description: "Number of days of history to retrieve (default: 7, max: 365)"
+        }
+      },
+      required: ["token"]
     }
   }
 };
@@ -2327,6 +3525,10 @@ var WDK_TOOL_DEFINITIONS = {
         chain: {
           type: "string",
           description: 'Chain to execute transfer on (e.g., "ethereum", "arbitrum")'
+        },
+        confirmed: {
+          type: "boolean",
+          description: "Set to true to confirm and execute. Omit for a preview/confirmation prompt."
         }
       },
       required: ["to", "amount", "token", "chain"]
@@ -2354,6 +3556,10 @@ var WDK_TOOL_DEFINITIONS = {
         chain: {
           type: "string",
           description: 'Chain to execute swap on (e.g., "ethereum", "arbitrum")'
+        },
+        confirmed: {
+          type: "boolean",
+          description: "Set to true to confirm and execute. Omit for a preview/confirmation prompt."
         }
       },
       required: ["fromToken", "toToken", "amount", "chain"]
@@ -2377,10 +3583,59 @@ var WDK_TOOL_DEFINITIONS = {
         preferredChain: {
           type: "string",
           description: 'Preferred chain for payment (e.g., "arbitrum"). If not specified, uses first available.'
+        },
+        confirmed: {
+          type: "boolean",
+          description: "Set to true to confirm and execute. Omit for a preview/confirmation prompt."
         }
       },
       required: ["url"]
     }
+  },
+  "wdk/quoteSwap": {
+    name: "wdk/quoteSwap",
+    description: "Get a swap quote with a quoteId for later execution. Returns exchange rate, fee, and price impact. Call wdk/executeSwap with the quoteId to execute.",
+    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"]
+    }
+  },
+  "wdk/executeSwap": {
+    name: "wdk/executeSwap",
+    description: "Execute a swap using a quoteId from wdk/quoteSwap. Requires confirmation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        quoteId: {
+          type: "string",
+          description: "Quote ID from wdk/quoteSwap"
+        },
+        confirmed: {
+          type: "boolean",
+          description: "Set to true to confirm and execute. Omit for a preview/confirmation prompt."
+        }
+      },
+      required: ["quoteId"]
+    }
   }
 };
 var ERC8004_TOOL_DEFINITIONS = {
@@ -2499,6 +3754,19 @@ var T402McpServer = class {
       console.error("Warning: Failed to initialize WDK. WDK tools will not be available.");
     }
   }
+  /**
+   * Clear sensitive data from memory.
+   * Should be called on server shutdown to minimize key exposure window.
+   */
+  cleanup() {
+    if (this.config.privateKey) {
+      this.config.privateKey = "";
+    }
+    if (this.config.seedPhrase) {
+      this.config.seedPhrase = "";
+    }
+    this.wdk = null;
+  }
   /**
    * Register TON bridge tools
    *
@@ -2564,6 +3832,24 @@ var T402McpServer = class {
             return await this.handleSmartPay(args);
           case "t402/paymentPlan":
             return await this.handlePaymentPlan(args);
+          // Price and fee tools
+          case "t402/getTokenPrice":
+            return await this.handleGetTokenPrice(args);
+          case "t402/getGasPrice":
+            return await this.handleGetGasPrice(args);
+          case "t402/estimatePaymentFee":
+            return await this.handleEstimatePaymentFee(args);
+          case "t402/compareNetworkFees":
+            return await this.handleCompareNetworkFees(args);
+          // Quote-based tools
+          case "t402/quoteBridge":
+            return await this.handleQuoteBridge(args);
+          case "t402/executeBridgeQuote":
+            return await this.handleExecuteBridgeQuote(args);
+          case "wdk/quoteSwap":
+            return await this.handleWdkQuoteSwap(args);
+          case "wdk/executeSwap":
+            return await this.handleWdkExecuteSwap(args);
           // ERC-8004 tools
           case "erc8004/resolveAgent":
             return await this.handleErc8004ResolveAgent(args);
@@ -2625,6 +3911,28 @@ var T402McpServer = class {
       ]
     };
   }
+  /**
+   * Format a confirmation prompt for elicitation
+   */
+  formatConfirmation(result) {
+    const detailLines = Object.entries(result.details).map(([key, value]) => `- **${key}:** ${value}`).join("\n");
+    return {
+      content: [
+        {
+          type: "text",
+          text: [
+            "## Confirmation Required",
+            "",
+            result.summary,
+            "",
+            detailLines,
+            "",
+            "_Call this tool again with `confirmed: true` to execute._"
+          ].join("\n")
+        }
+      ]
+    };
+  }
   /**
    * Handle t402/pay
    */
@@ -2640,6 +3948,9 @@ var T402McpServer = class {
       rpcUrl: this.config.rpcUrls?.[input.network],
       demoMode: this.config.demoMode
     });
+    if ("needsConfirmation" in result) {
+      return this.formatConfirmation(result);
+    }
     return {
       content: [
         {
@@ -2676,6 +3987,9 @@ var T402McpServer = class {
       rpcUrl: this.config.rpcUrls?.[input.network],
       demoMode: this.config.demoMode
     });
+    if ("needsConfirmation" in result) {
+      return this.formatConfirmation(result);
+    }
     return {
       content: [
         {
@@ -2715,6 +4029,9 @@ var T402McpServer = class {
       rpcUrl: this.config.rpcUrls?.[input.fromChain],
       demoMode: this.config.demoMode
     });
+    if ("needsConfirmation" in result) {
+      return this.formatConfirmation(result);
+    }
     return {
       content: [
         {
@@ -2751,6 +4068,9 @@ var T402McpServer = class {
   async handleWdkTransfer(args) {
     const input = wdkTransferInputSchema.parse(args);
     const result = this.config.demoMode || !this.wdk ? executeWdkTransferDemo(input) : await executeWdkTransfer(input, this.wdk);
+    if ("needsConfirmation" in result) {
+      return this.formatConfirmation(result);
+    }
     return {
       content: [{ type: "text", text: formatWdkTransferResult(result) }]
     };
@@ -2761,6 +4081,9 @@ var T402McpServer = class {
   async handleWdkSwap(args) {
     const input = wdkSwapInputSchema.parse(args);
     const result = this.config.demoMode || !this.wdk ? executeWdkSwapDemo(input) : await executeWdkSwap(input, this.wdk);
+    if ("needsConfirmation" in result) {
+      return this.formatConfirmation(result);
+    }
     return {
       content: [{ type: "text", text: formatWdkSwapResult(result) }]
     };
@@ -2771,6 +4094,9 @@ var T402McpServer = class {
   async handleAutoPay(args) {
     const input = autoPayInputSchema.parse(args);
     const result = this.config.demoMode || !this.wdk ? executeAutoPayDemo(input) : await executeAutoPay(input, this.wdk);
+    if ("needsConfirmation" in result) {
+      return this.formatConfirmation(result);
+    }
     return {
       content: [{ type: "text", text: formatAutoPayResult(result) }]
     };
@@ -2782,6 +4108,9 @@ var T402McpServer = class {
   async handleSmartPay(args) {
     const input = smartPayInputSchema.parse(args);
     const result = this.config.demoMode || !this.wdk ? executeSmartPayDemo(input) : await executeSmartPay(input, this.wdk);
+    if ("needsConfirmation" in result) {
+      return this.formatConfirmation(result);
+    }
     return {
       content: [{ type: "text", text: formatSmartPayResult(result) }]
     };
@@ -2796,6 +4125,111 @@ var T402McpServer = class {
       content: [{ type: "text", text: formatPaymentPlanResult(result) }]
     };
   }
+  // ---- Price and Fee Tool Handlers ----
+  /**
+   * Handle t402/getTokenPrice
+   */
+  async handleGetTokenPrice(args) {
+    const input = getTokenPriceInputSchema.parse(args);
+    const result = await executeGetTokenPrice(input, { demoMode: this.config.demoMode });
+    return {
+      content: [{ type: "text", text: formatTokenPriceResult(result) }]
+    };
+  }
+  /**
+   * Handle t402/getGasPrice
+   */
+  async handleGetGasPrice(args) {
+    const input = getGasPriceInputSchema.parse(args);
+    const result = await executeGetGasPrice(input, {
+      rpcUrl: this.config.rpcUrls?.[input.network],
+      demoMode: this.config.demoMode
+    });
+    return {
+      content: [{ type: "text", text: formatGasPriceResult(result) }]
+    };
+  }
+  /**
+   * Handle t402/estimatePaymentFee
+   */
+  async handleEstimatePaymentFee(args) {
+    const input = estimatePaymentFeeInputSchema.parse(args);
+    const result = await executeEstimatePaymentFee(input, {
+      rpcUrl: this.config.rpcUrls?.[input.network],
+      demoMode: this.config.demoMode
+    });
+    return {
+      content: [{ type: "text", text: formatPaymentFeeEstimate(result) }]
+    };
+  }
+  /**
+   * Handle t402/compareNetworkFees
+   */
+  async handleCompareNetworkFees(args) {
+    const input = compareNetworkFeesInputSchema.parse(args);
+    const result = await executeCompareNetworkFees(input, {
+      rpcUrls: this.config.rpcUrls,
+      demoMode: this.config.demoMode
+    });
+    return {
+      content: [{ type: "text", text: formatNetworkFeeComparison(result) }]
+    };
+  }
+  // ---- Quote-based Tool Handlers ----
+  /**
+   * Handle t402/quoteBridge
+   */
+  async handleQuoteBridge(args) {
+    const input = quoteBridgeInputSchema.parse(args);
+    const result = this.config.demoMode ? executeQuoteBridgeDemo(input) : await executeQuoteBridge(input, this.config.rpcUrls);
+    return {
+      content: [{ type: "text", text: formatBridgeQuoteResult(result) }]
+    };
+  }
+  /**
+   * Handle t402/executeBridgeQuote
+   */
+  async handleExecuteBridgeQuote(args) {
+    if (!this.config.privateKey && !this.config.demoMode) {
+      throw new Error(
+        "Private key not configured. Set T402_PRIVATE_KEY environment variable or enable demo mode."
+      );
+    }
+    const input = executeBridgeFromQuoteInputSchema.parse(args);
+    const result = this.config.demoMode ? executeExecuteBridgeFromQuoteDemo(input) : await executeExecuteBridgeFromQuote(input, {
+      privateKey: this.config.privateKey || "0x",
+      demoMode: this.config.demoMode
+    });
+    if ("needsConfirmation" in result) {
+      return this.formatConfirmation(result);
+    }
+    return {
+      content: [{ type: "text", text: formatBridgeResult(result) }]
+    };
+  }
+  /**
+   * Handle wdk/quoteSwap
+   */
+  async handleWdkQuoteSwap(args) {
+    const input = wdkQuoteSwapInputSchema.parse(args);
+    const result = this.config.demoMode || !this.wdk ? executeWdkQuoteSwapDemo(input) : await executeWdkQuoteSwap(input, this.wdk);
+    return {
+      content: [{ type: "text", text: formatSwapQuoteResult(result) }]
+    };
+  }
+  /**
+   * Handle wdk/executeSwap
+   */
+  async handleWdkExecuteSwap(args) {
+    const input = wdkExecuteSwapInputSchema.parse(args);
+    const result = this.config.demoMode || !this.wdk ? executeWdkExecuteSwapDemo(input) : await executeWdkExecuteSwap(input, this.wdk);
+    if ("needsConfirmation" in result) {
+      return this.formatConfirmation(result);
+    }
+    return {
+      content: [{ type: "text", text: formatExecuteSwapResult(result) }]
+    };
+  }
   // ---- ERC-8004 Tool Handlers ----
   /**
    * Handle erc8004/resolveAgent
@@ -2842,6 +4276,16 @@ var T402McpServer = class {
    */
   async run() {
     await this.initWdk();
+    const onExit = () => this.cleanup();
+    process.on("exit", onExit);
+    process.on("SIGINT", () => {
+      onExit();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      onExit();
+      process.exit(0);
+    });
     const transport = new import_stdio.StdioServerTransport();
     await this.server.connect(transport);
     console.error("t402 MCP Server running on stdio");