@t402/mcp 1.0.0

package/dist/cjs/index.js

@@ -0,0 +1,1692 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BRIDGEABLE_CHAINS: () => BRIDGEABLE_CHAINS,
+  CHAIN_IDS: () => CHAIN_IDS,
+  DEFAULT_RPC_URLS: () => DEFAULT_RPC_URLS,
+  EXPLORER_URLS: () => EXPLORER_URLS,
+  GASLESS_SUPPORTED_NETWORKS: () => GASLESS_SUPPORTED_NETWORKS,
+  NATIVE_SYMBOLS: () => NATIVE_SYMBOLS,
+  T402McpServer: () => T402McpServer,
+  TOOL_DEFINITIONS: () => TOOL_DEFINITIONS,
+  USDC_ADDRESSES: () => USDC_ADDRESSES,
+  USDT0_ADDRESSES: () => USDT0_ADDRESSES,
+  USDT_ADDRESSES: () => USDT_ADDRESSES,
+  bridgeInputSchema: () => bridgeInputSchema,
+  createT402McpServer: () => createT402McpServer,
+  executeBridge: () => executeBridge,
+  executeGetAllBalances: () => executeGetAllBalances,
+  executeGetBalance: () => executeGetBalance,
+  executeGetBridgeFee: () => executeGetBridgeFee,
+  executePay: () => executePay,
+  executePayGasless: () => executePayGasless,
+  formatAllBalancesResult: () => formatAllBalancesResult,
+  formatBalanceResult: () => formatBalanceResult,
+  formatBridgeFeeResult: () => formatBridgeFeeResult,
+  formatBridgeResult: () => formatBridgeResult,
+  formatGaslessPaymentResult: () => formatGaslessPaymentResult,
+  formatPaymentResult: () => formatPaymentResult,
+  formatTokenAmount: () => formatTokenAmount,
+  getAllBalancesInputSchema: () => getAllBalancesInputSchema,
+  getBalanceInputSchema: () => getBalanceInputSchema,
+  getBridgeFeeInputSchema: () => getBridgeFeeInputSchema,
+  getExplorerTxUrl: () => getExplorerTxUrl,
+  getLayerZeroScanUrl: () => getLayerZeroScanUrl,
+  getTokenAddress: () => getTokenAddress,
+  loadConfigFromEnv: () => loadConfigFromEnv,
+  parseTokenAmount: () => parseTokenAmount,
+  payGaslessInputSchema: () => payGaslessInputSchema,
+  payInputSchema: () => payInputSchema,
+  supportsToken: () => supportsToken
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/server/t402Server.ts
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+
+// src/tools/getBalance.ts
+var import_zod = require("zod");
+var import_viem = require("viem");
+var chains = __toESM(require("viem/chains"));
+
+// src/constants.ts
+var CHAIN_IDS = {
+  ethereum: 1,
+  base: 8453,
+  arbitrum: 42161,
+  optimism: 10,
+  polygon: 137,
+  avalanche: 43114,
+  ink: 57073,
+  berachain: 80094,
+  unichain: 130
+};
+var NATIVE_SYMBOLS = {
+  ethereum: "ETH",
+  base: "ETH",
+  arbitrum: "ETH",
+  optimism: "ETH",
+  polygon: "MATIC",
+  avalanche: "AVAX",
+  ink: "ETH",
+  berachain: "BERA",
+  unichain: "ETH"
+};
+var EXPLORER_URLS = {
+  ethereum: "https://etherscan.io",
+  base: "https://basescan.org",
+  arbitrum: "https://arbiscan.io",
+  optimism: "https://optimistic.etherscan.io",
+  polygon: "https://polygonscan.com",
+  avalanche: "https://snowtrace.io",
+  ink: "https://explorer.inkonchain.com",
+  berachain: "https://berascan.com",
+  unichain: "https://unichain.blockscout.com"
+};
+var DEFAULT_RPC_URLS = {
+  ethereum: "https://eth.llamarpc.com",
+  base: "https://mainnet.base.org",
+  arbitrum: "https://arb1.arbitrum.io/rpc",
+  optimism: "https://mainnet.optimism.io",
+  polygon: "https://polygon-rpc.com",
+  avalanche: "https://api.avax.network/ext/bc/C/rpc",
+  ink: "https://rpc-gel.inkonchain.com",
+  berachain: "https://rpc.berachain.com",
+  unichain: "https://mainnet.unichain.org"
+};
+var USDC_ADDRESSES = {
+  ethereum: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  arbitrum: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  optimism: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+  polygon: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+  avalanche: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E"
+};
+var USDT_ADDRESSES = {
+  ethereum: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+  arbitrum: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+  polygon: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+  avalanche: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+  optimism: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58"
+};
+var USDT0_ADDRESSES = {
+  ethereum: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee",
+  arbitrum: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+  ink: "0x0200C29006150606B650577BBE7B6248F58470c1",
+  berachain: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+  unichain: "0x588ce4F028D8e7B53B687865d6A67b3A54C75518"
+};
+var BRIDGEABLE_CHAINS = [
+  "ethereum",
+  "arbitrum",
+  "ink",
+  "berachain",
+  "unichain"
+];
+var ERC20_ABI = [
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "decimals",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    name: "symbol",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    name: "transfer",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+function getExplorerTxUrl(network, txHash) {
+  return `${EXPLORER_URLS[network]}/tx/${txHash}`;
+}
+function getLayerZeroScanUrl(messageGuid) {
+  return `https://layerzeroscan.com/tx/${messageGuid}`;
+}
+function supportsToken(network, token) {
+  switch (token) {
+    case "USDC":
+      return network in USDC_ADDRESSES;
+    case "USDT":
+      return network in USDT_ADDRESSES;
+    case "USDT0":
+      return network in USDT0_ADDRESSES;
+    default:
+      return false;
+  }
+}
+function getTokenAddress(network, token) {
+  switch (token) {
+    case "USDC":
+      return USDC_ADDRESSES[network];
+    case "USDT":
+      return USDT_ADDRESSES[network];
+    case "USDT0":
+      return USDT0_ADDRESSES[network];
+    default:
+      return void 0;
+  }
+}
+function formatTokenAmount(amount, decimals, symbol) {
+  const divisor = BigInt(10 ** decimals);
+  const wholePart = amount / divisor;
+  const fractionalPart = amount % divisor;
+  const fractionalStr = fractionalPart.toString().padStart(decimals, "0");
+  const trimmedFractional = fractionalStr.replace(/0+$/, "") || "0";
+  if (trimmedFractional === "0") {
+    return `${wholePart} ${symbol}`;
+  }
+  return `${wholePart}.${trimmedFractional} ${symbol}`;
+}
+function parseTokenAmount(amount, decimals) {
+  const [wholePart, fractionalPart = ""] = amount.split(".");
+  const paddedFractional = fractionalPart.padEnd(decimals, "0").slice(0, decimals);
+  return BigInt(wholePart + paddedFractional);
+}
+
+// src/tools/getBalance.ts
+var getBalanceInputSchema = import_zod.z.object({
+  network: import_zod.z.enum([
+    "ethereum",
+    "base",
+    "arbitrum",
+    "optimism",
+    "polygon",
+    "avalanche",
+    "ink",
+    "berachain",
+    "unichain"
+  ]).describe("Blockchain network to check balance on"),
+  address: import_zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("Wallet address to check balance for")
+});
+function getViemChain(network) {
+  switch (network) {
+    case "ethereum":
+      return chains.mainnet;
+    case "base":
+      return chains.base;
+    case "arbitrum":
+      return chains.arbitrum;
+    case "optimism":
+      return chains.optimism;
+    case "polygon":
+      return chains.polygon;
+    case "avalanche":
+      return chains.avalanche;
+    case "ink":
+      return chains.ink;
+    case "berachain":
+      return chains.berachain;
+    case "unichain":
+      return chains.unichain;
+    default:
+      return chains.mainnet;
+  }
+}
+async function getTokenBalance(client, tokenAddress, walletAddress) {
+  try {
+    const [balance, decimals, symbol] = await Promise.all([
+      client.readContract({
+        address: tokenAddress,
+        abi: ERC20_ABI,
+        functionName: "balanceOf",
+        args: [walletAddress]
+      }),
+      client.readContract({
+        address: tokenAddress,
+        abi: ERC20_ABI,
+        functionName: "decimals"
+      }),
+      client.readContract({
+        address: tokenAddress,
+        abi: ERC20_ABI,
+        functionName: "symbol"
+      })
+    ]);
+    return {
+      symbol,
+      address: tokenAddress,
+      balance: balance.toString(),
+      formatted: (0, import_viem.formatUnits)(balance, decimals),
+      decimals
+    };
+  } catch {
+    return null;
+  }
+}
+async function executeGetBalance(input, rpcUrls) {
+  const { network, address } = input;
+  const walletAddress = address;
+  const rpcUrl = rpcUrls?.[network] || DEFAULT_RPC_URLS[network];
+  const chain = getViemChain(network);
+  const client = (0, import_viem.createPublicClient)({
+    chain,
+    transport: (0, import_viem.http)(rpcUrl)
+  });
+  const nativeBalance = await client.getBalance({ address: walletAddress });
+  const tokenAddresses = [];
+  if (USDC_ADDRESSES[network]) {
+    tokenAddresses.push({ token: USDC_ADDRESSES[network], expected: "USDC" });
+  }
+  if (USDT_ADDRESSES[network]) {
+    tokenAddresses.push({ token: USDT_ADDRESSES[network], expected: "USDT" });
+  }
+  if (USDT0_ADDRESSES[network]) {
+    tokenAddresses.push({ token: USDT0_ADDRESSES[network], expected: "USDT0" });
+  }
+  const tokenBalances = await Promise.all(
+    tokenAddresses.map(
+      ({ token }) => getTokenBalance(client, token, walletAddress)
+    )
+  );
+  const tokens = tokenBalances.filter(
+    (t) => t !== null
+  );
+  return {
+    network,
+    chainId: CHAIN_IDS[network],
+    native: {
+      symbol: NATIVE_SYMBOLS[network],
+      balance: nativeBalance.toString(),
+      formatted: (0, import_viem.formatEther)(nativeBalance)
+    },
+    tokens
+  };
+}
+function formatBalanceResult(balance) {
+  const lines = [
+    `## Balance on ${balance.network} (Chain ID: ${balance.chainId})`,
+    "",
+    `### Native Token`,
+    `- ${balance.native.symbol}: ${balance.native.formatted}`,
+    ""
+  ];
+  if (balance.tokens.length > 0) {
+    lines.push("### Stablecoins");
+    for (const token of balance.tokens) {
+      lines.push(`- ${token.symbol}: ${token.formatted}`);
+    }
+  } else {
+    lines.push("_No stablecoin balances found_");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/getAllBalances.ts
+var import_zod2 = require("zod");
+var getAllBalancesInputSchema = import_zod2.z.object({
+  address: import_zod2.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("Wallet address to check balances for"),
+  networks: import_zod2.z.array(
+    import_zod2.z.enum([
+      "ethereum",
+      "base",
+      "arbitrum",
+      "optimism",
+      "polygon",
+      "avalanche",
+      "ink",
+      "berachain",
+      "unichain"
+    ])
+  ).optional().describe(
+    "Optional list of networks to check. If not provided, checks all supported networks."
+  )
+});
+var ALL_NETWORKS = [
+  "ethereum",
+  "base",
+  "arbitrum",
+  "optimism",
+  "polygon",
+  "avalanche",
+  "ink",
+  "berachain",
+  "unichain"
+];
+async function executeGetAllBalances(input, rpcUrls) {
+  const { address, networks = ALL_NETWORKS } = input;
+  const balancePromises = networks.map(
+    (network) => executeGetBalance({ network, address }, rpcUrls).catch((error) => {
+      console.error(`Failed to fetch balance for ${network}:`, error);
+      return null;
+    })
+  );
+  const results = await Promise.all(balancePromises);
+  const balances = results.filter((b) => b !== null);
+  let totalUsdc = 0n;
+  let totalUsdt = 0n;
+  for (const balance of balances) {
+    for (const token of balance.tokens) {
+      if (token.symbol === "USDC") {
+        totalUsdc += BigInt(token.balance);
+      } else if (token.symbol === "USDT" || token.symbol === "USDT0") {
+        totalUsdt += BigInt(token.balance);
+      }
+    }
+  }
+  const formatTotal = (amount) => {
+    const divisor = BigInt(10 ** 6);
+    const whole = amount / divisor;
+    const fraction = amount % divisor;
+    const fractionStr = fraction.toString().padStart(6, "0").replace(/0+$/, "");
+    return fractionStr ? `${whole}.${fractionStr}` : whole.toString();
+  };
+  const totalUsdcFormatted = formatTotal(totalUsdc);
+  const totalUsdtFormatted = formatTotal(totalUsdt);
+  const chainsWithBalance = balances.filter(
+    (b) => b.tokens.some((t) => BigInt(t.balance) > 0n) || BigInt(b.native.balance) > 0n
+  );
+  const summary = [
+    `Found balances on ${chainsWithBalance.length} of ${balances.length} networks checked.`,
+    `Total USDC: ${totalUsdcFormatted}`,
+    `Total USDT: ${totalUsdtFormatted}`
+  ].join(" ");
+  return {
+    address,
+    balances,
+    totalUsdcBalance: totalUsdcFormatted,
+    totalUsdtBalance: totalUsdtFormatted,
+    summary
+  };
+}
+function formatAllBalancesResult(result) {
+  const lines = [
+    `## Multi-Chain Balance Summary`,
+    `**Address:** \`${result.address}\``,
+    "",
+    `### Totals`,
+    `- **Total USDC:** ${result.totalUsdcBalance}`,
+    `- **Total USDT:** ${result.totalUsdtBalance}`,
+    "",
+    `### By Network`,
+    ""
+  ];
+  for (const balance of result.balances) {
+    const hasBalance = balance.tokens.some((t) => BigInt(t.balance) > 0n) || BigInt(balance.native.balance) > 0n;
+    if (!hasBalance) continue;
+    lines.push(`#### ${balance.network}`);
+    lines.push(`- ${balance.native.symbol}: ${balance.native.formatted}`);
+    for (const token of balance.tokens) {
+      if (BigInt(token.balance) > 0n) {
+        lines.push(`- ${token.symbol}: ${token.formatted}`);
+      }
+    }
+    lines.push("");
+  }
+  const emptyNetworks = result.balances.filter(
+    (b) => !b.tokens.some((t) => BigInt(t.balance) > 0n) && BigInt(b.native.balance) === 0n
+  );
+  if (emptyNetworks.length > 0) {
+    lines.push(`_No balance on: ${emptyNetworks.map((n) => n.network).join(", ")}_`);
+  }
+  return lines.join("\n");
+}
+
+// src/tools/pay.ts
+var import_zod3 = require("zod");
+var import_viem2 = require("viem");
+var import_accounts = require("viem/accounts");
+var chains2 = __toESM(require("viem/chains"));
+var payInputSchema = import_zod3.z.object({
+  to: import_zod3.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("Recipient address"),
+  amount: import_zod3.z.string().regex(/^\d+(\.\d+)?$/).describe("Amount to pay (e.g., '10.50' for 10.50 USDC)"),
+  token: import_zod3.z.enum(["USDC", "USDT", "USDT0"]).describe("Token to use for payment"),
+  network: import_zod3.z.enum([
+    "ethereum",
+    "base",
+    "arbitrum",
+    "optimism",
+    "polygon",
+    "avalanche",
+    "ink",
+    "berachain",
+    "unichain"
+  ]).describe("Network to execute payment on"),
+  memo: import_zod3.z.string().optional().describe("Optional memo/reference for the payment")
+});
+function getViemChain2(network) {
+  switch (network) {
+    case "ethereum":
+      return chains2.mainnet;
+    case "base":
+      return chains2.base;
+    case "arbitrum":
+      return chains2.arbitrum;
+    case "optimism":
+      return chains2.optimism;
+    case "polygon":
+      return chains2.polygon;
+    case "avalanche":
+      return chains2.avalanche;
+    case "ink":
+      return chains2.ink;
+    case "berachain":
+      return chains2.berachain;
+    case "unichain":
+      return chains2.unichain;
+    default:
+      return chains2.mainnet;
+  }
+}
+async function executePay(input, options) {
+  const { to, amount, token, network, memo } = input;
+  const { privateKey, rpcUrl, demoMode } = options;
+  if (!supportsToken(network, token)) {
+    throw new Error(`Token ${token} is not supported on ${network}`);
+  }
+  const tokenAddress = getTokenAddress(network, token);
+  if (!tokenAddress) {
+    throw new Error(`Could not find ${token} address for ${network}`);
+  }
+  const decimals = 6;
+  const amountBigInt = (0, import_viem2.parseUnits)(amount, decimals);
+  if (demoMode) {
+    const fakeTxHash = `0x${"0".repeat(64)}`;
+    return {
+      txHash: fakeTxHash,
+      network,
+      amount,
+      token,
+      to,
+      explorerUrl: getExplorerTxUrl(network, fakeTxHash)
+    };
+  }
+  const chain = getViemChain2(network);
+  const transport = (0, import_viem2.http)(rpcUrl || DEFAULT_RPC_URLS[network]);
+  const account = (0, import_accounts.privateKeyToAccount)(privateKey);
+  const publicClient = (0, import_viem2.createPublicClient)({
+    chain,
+    transport
+  });
+  const walletClient = (0, import_viem2.createWalletClient)({
+    account,
+    chain,
+    transport
+  });
+  const balance = await publicClient.readContract({
+    address: tokenAddress,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [account.address]
+  });
+  if (balance < amountBigInt) {
+    throw new Error(
+      `Insufficient ${token} balance. Have: ${balance.toString()}, Need: ${amountBigInt.toString()}`
+    );
+  }
+  const hash = await walletClient.writeContract({
+    address: tokenAddress,
+    abi: ERC20_ABI,
+    functionName: "transfer",
+    args: [to, amountBigInt]
+  });
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  if (receipt.status !== "success") {
+    throw new Error(`Transaction failed: ${hash}`);
+  }
+  return {
+    txHash: hash,
+    network,
+    amount,
+    token,
+    to,
+    explorerUrl: getExplorerTxUrl(network, hash)
+  };
+}
+function formatPaymentResult(result) {
+  return [
+    `## Payment Successful`,
+    "",
+    `- **Amount:** ${result.amount} ${result.token}`,
+    `- **To:** \`${result.to}\``,
+    `- **Network:** ${result.network}`,
+    `- **Transaction:** \`${result.txHash}\``,
+    "",
+    `[View on Explorer](${result.explorerUrl})`
+  ].join("\n");
+}
+
+// src/tools/payGasless.ts
+var import_zod4 = require("zod");
+var import_viem3 = require("viem");
+var import_accounts2 = require("viem/accounts");
+var chains3 = __toESM(require("viem/chains"));
+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)")
+});
+var GASLESS_SUPPORTED_NETWORKS = [
+  "ethereum",
+  "base",
+  "arbitrum",
+  "optimism",
+  "polygon",
+  "avalanche"
+];
+function getViemChain3(network) {
+  switch (network) {
+    case "ethereum":
+      return chains3.mainnet;
+    case "base":
+      return chains3.base;
+    case "arbitrum":
+      return chains3.arbitrum;
+    case "optimism":
+      return chains3.optimism;
+    case "polygon":
+      return chains3.polygon;
+    case "avalanche":
+      return chains3.avalanche;
+    case "ink":
+      return chains3.ink;
+    case "berachain":
+      return chains3.berachain;
+    case "unichain":
+      return chains3.unichain;
+    default:
+      return chains3.mainnet;
+  }
+}
+async function executePayGasless(input, options) {
+  const { to, amount, token, network } = input;
+  const { privateKey, bundlerUrl, paymasterUrl, rpcUrl, demoMode } = options;
+  if (!GASLESS_SUPPORTED_NETWORKS.includes(network)) {
+    throw new Error(
+      `Network ${network} does not support ERC-4337 gasless transactions. Supported: ${GASLESS_SUPPORTED_NETWORKS.join(", ")}`
+    );
+  }
+  if (!supportsToken(network, token)) {
+    throw new Error(`Token ${token} is not supported on ${network}`);
+  }
+  const tokenAddress = getTokenAddress(network, token);
+  if (!tokenAddress) {
+    throw new Error(`Could not find ${token} address for ${network}`);
+  }
+  const decimals = 6;
+  const amountBigInt = (0, import_viem3.parseUnits)(amount, decimals);
+  if (demoMode) {
+    const fakeTxHash = `0x${"1".repeat(64)}`;
+    const fakeUserOpHash = `0x${"2".repeat(64)}`;
+    return {
+      txHash: fakeTxHash,
+      userOpHash: fakeUserOpHash,
+      network,
+      amount,
+      token,
+      to,
+      explorerUrl: getExplorerTxUrl(network, fakeTxHash),
+      paymaster: "demo-paymaster"
+    };
+  }
+  const chain = getViemChain3(network);
+  const transport = (0, import_viem3.http)(rpcUrl || DEFAULT_RPC_URLS[network]);
+  const account = (0, import_accounts2.privateKeyToAccount)(privateKey);
+  const publicClient = (0, import_viem3.createPublicClient)({
+    chain,
+    transport
+  });
+  const callData = (0, import_viem3.encodeFunctionData)({
+    abi: ERC20_ABI,
+    functionName: "transfer",
+    args: [to, amountBigInt]
+  });
+  const nonce = await publicClient.getTransactionCount({
+    address: account.address
+  });
+  const gasPrice = await publicClient.getGasPrice();
+  const userOp = {
+    sender: account.address,
+    nonce: BigInt(nonce),
+    initCode: "0x",
+    callData,
+    callGasLimit: 100000n,
+    verificationGasLimit: 100000n,
+    preVerificationGas: 50000n,
+    maxFeePerGas: gasPrice,
+    maxPriorityFeePerGas: gasPrice / 10n,
+    paymasterAndData: "0x",
+    // Would be filled by paymaster
+    signature: "0x"
+  };
+  const response = await fetch(bundlerUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "eth_sendUserOperation",
+      params: [userOp, chain.id]
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Bundler request failed: ${response.statusText}`);
+  }
+  const result = await response.json();
+  if (result.error) {
+    throw new Error(`Bundler error: ${result.error.message}`);
+  }
+  const userOpHash = result.result;
+  let receipt = null;
+  for (let i = 0; i < 30; i++) {
+    const receiptResponse = await fetch(bundlerUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "eth_getUserOperationReceipt",
+        params: [userOpHash]
+      })
+    });
+    const receiptResult = await receiptResponse.json();
+    if (receiptResult.result) {
+      receipt = receiptResult.result;
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+  }
+  if (!receipt) {
+    throw new Error("Timeout waiting for user operation receipt");
+  }
+  return {
+    txHash: receipt.transactionHash,
+    userOpHash,
+    network,
+    amount,
+    token,
+    to,
+    explorerUrl: getExplorerTxUrl(network, receipt.transactionHash)
+  };
+}
+function formatGaslessPaymentResult(result) {
+  const lines = [
+    `## Gasless Payment Successful`,
+    "",
+    `- **Amount:** ${result.amount} ${result.token}`,
+    `- **To:** \`${result.to}\``,
+    `- **Network:** ${result.network}`,
+    `- **Transaction:** \`${result.txHash}\``,
+    `- **UserOp Hash:** \`${result.userOpHash}\``
+  ];
+  if (result.paymaster) {
+    lines.push(`- **Paymaster:** ${result.paymaster}`);
+  }
+  lines.push("");
+  lines.push(`[View on Explorer](${result.explorerUrl})`);
+  lines.push("");
+  lines.push("_Gas fees were sponsored - no ETH was deducted from your wallet._");
+  return lines.join("\n");
+}
+
+// src/tools/getBridgeFee.ts
+var import_zod5 = require("zod");
+var import_viem4 = require("viem");
+var chains4 = __toESM(require("viem/chains"));
+var getBridgeFeeInputSchema = import_zod5.z.object({
+  fromChain: import_zod5.z.enum(["ethereum", "arbitrum", "ink", "berachain", "unichain"]).describe("Source chain to bridge from"),
+  toChain: import_zod5.z.enum(["ethereum", "arbitrum", "ink", "berachain", "unichain"]).describe("Destination chain to bridge to"),
+  amount: import_zod5.z.string().regex(/^\d+(\.\d+)?$/).describe("Amount of USDT0 to bridge (e.g., '100' for 100 USDT0)"),
+  recipient: import_zod5.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("Recipient address on destination chain")
+});
+var LAYERZERO_ENDPOINT_IDS = {
+  ethereum: 30101,
+  arbitrum: 30110,
+  ink: 30291,
+  berachain: 30362,
+  unichain: 30320
+};
+var ESTIMATED_BRIDGE_TIMES = {
+  ethereum: 900,
+  // 15 minutes
+  arbitrum: 300,
+  // 5 minutes
+  ink: 300,
+  // 5 minutes
+  berachain: 300,
+  // 5 minutes
+  unichain: 300
+  // 5 minutes
+};
+var OFT_ABI = [
+  {
+    name: "quoteSend",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      {
+        name: "_sendParam",
+        type: "tuple",
+        components: [
+          { name: "dstEid", type: "uint32" },
+          { name: "to", type: "bytes32" },
+          { name: "amountLD", type: "uint256" },
+          { name: "minAmountLD", type: "uint256" },
+          { name: "extraOptions", type: "bytes" },
+          { name: "composeMsg", type: "bytes" },
+          { name: "oftCmd", type: "bytes" }
+        ]
+      },
+      { name: "_payInLzToken", type: "bool" }
+    ],
+    outputs: [
+      {
+        name: "msgFee",
+        type: "tuple",
+        components: [
+          { name: "nativeFee", type: "uint256" },
+          { name: "lzTokenFee", type: "uint256" }
+        ]
+      }
+    ]
+  }
+];
+function getViemChain4(network) {
+  switch (network) {
+    case "ethereum":
+      return chains4.mainnet;
+    case "arbitrum":
+      return chains4.arbitrum;
+    case "ink":
+      return chains4.ink;
+    case "berachain":
+      return chains4.berachain;
+    case "unichain":
+      return chains4.unichain;
+    default:
+      return void 0;
+  }
+}
+function addressToBytes32(address) {
+  return `0x${address.slice(2).padStart(64, "0")}`;
+}
+async function executeGetBridgeFee(input, rpcUrls) {
+  const { fromChain, toChain, amount, recipient } = input;
+  if (fromChain === toChain) {
+    throw new Error("Source and destination chains must be different");
+  }
+  if (!BRIDGEABLE_CHAINS.includes(fromChain)) {
+    throw new Error(`Chain ${fromChain} does not support USDT0 bridging`);
+  }
+  if (!BRIDGEABLE_CHAINS.includes(toChain)) {
+    throw new Error(`Chain ${toChain} does not support USDT0 bridging`);
+  }
+  const usdt0Address = USDT0_ADDRESSES[fromChain];
+  if (!usdt0Address) {
+    throw new Error(`USDT0 not found on ${fromChain}`);
+  }
+  const amountBigInt = parseTokenAmount(amount, 6);
+  const chain = getViemChain4(fromChain);
+  if (!chain) {
+    throw new Error(`Unsupported chain: ${fromChain}`);
+  }
+  const rpcUrl = rpcUrls?.[fromChain] || DEFAULT_RPC_URLS[fromChain];
+  const client = (0, import_viem4.createPublicClient)({
+    chain,
+    transport: (0, import_viem4.http)(rpcUrl)
+  });
+  const dstEid = LAYERZERO_ENDPOINT_IDS[toChain];
+  const sendParam = {
+    dstEid,
+    to: addressToBytes32(recipient),
+    amountLD: amountBigInt,
+    minAmountLD: amountBigInt,
+    // No slippage for quote
+    extraOptions: "0x",
+    composeMsg: "0x",
+    oftCmd: "0x"
+  };
+  const quote = await client.readContract({
+    address: usdt0Address,
+    abi: OFT_ABI,
+    functionName: "quoteSend",
+    args: [sendParam, false]
+  });
+  const nativeSymbol = NATIVE_SYMBOLS[fromChain];
+  const estimatedTime = ESTIMATED_BRIDGE_TIMES[toChain] || 300;
+  return {
+    fromChain,
+    toChain,
+    amount,
+    nativeFee: quote.nativeFee.toString(),
+    nativeFeeFormatted: `${(0, import_viem4.formatEther)(quote.nativeFee)} ${nativeSymbol}`,
+    estimatedTime
+  };
+}
+function formatBridgeFeeResult(result) {
+  const minutes = Math.ceil(result.estimatedTime / 60);
+  return [
+    `## Bridge Fee Quote`,
+    "",
+    `- **Route:** ${result.fromChain} \u2192 ${result.toChain}`,
+    `- **Amount:** ${result.amount} USDT0`,
+    `- **Native Fee:** ${result.nativeFeeFormatted}`,
+    `- **Estimated Time:** ~${minutes} minutes`,
+    "",
+    "_Note: Actual fees may vary slightly at execution time._"
+  ].join("\n");
+}
+
+// src/tools/bridge.ts
+var import_zod6 = require("zod");
+var import_viem5 = require("viem");
+var import_accounts3 = require("viem/accounts");
+var chains5 = __toESM(require("viem/chains"));
+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")
+});
+var LAYERZERO_ENDPOINT_IDS2 = {
+  ethereum: 30101,
+  arbitrum: 30110,
+  ink: 30291,
+  berachain: 30362,
+  unichain: 30320
+};
+var ESTIMATED_BRIDGE_TIMES2 = {
+  ethereum: 900,
+  arbitrum: 300,
+  ink: 300,
+  berachain: 300,
+  unichain: 300
+};
+var OFT_ABI2 = [
+  {
+    name: "quoteSend",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      {
+        name: "_sendParam",
+        type: "tuple",
+        components: [
+          { name: "dstEid", type: "uint32" },
+          { name: "to", type: "bytes32" },
+          { name: "amountLD", type: "uint256" },
+          { name: "minAmountLD", type: "uint256" },
+          { name: "extraOptions", type: "bytes" },
+          { name: "composeMsg", type: "bytes" },
+          { name: "oftCmd", type: "bytes" }
+        ]
+      },
+      { name: "_payInLzToken", type: "bool" }
+    ],
+    outputs: [
+      {
+        name: "msgFee",
+        type: "tuple",
+        components: [
+          { name: "nativeFee", type: "uint256" },
+          { name: "lzTokenFee", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    name: "send",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "_sendParam",
+        type: "tuple",
+        components: [
+          { name: "dstEid", type: "uint32" },
+          { name: "to", type: "bytes32" },
+          { name: "amountLD", type: "uint256" },
+          { name: "minAmountLD", type: "uint256" },
+          { name: "extraOptions", type: "bytes" },
+          { name: "composeMsg", type: "bytes" },
+          { name: "oftCmd", type: "bytes" }
+        ]
+      },
+      {
+        name: "_fee",
+        type: "tuple",
+        components: [
+          { name: "nativeFee", type: "uint256" },
+          { name: "lzTokenFee", type: "uint256" }
+        ]
+      },
+      { name: "_refundAddress", type: "address" }
+    ],
+    outputs: [
+      {
+        name: "msgReceipt",
+        type: "tuple",
+        components: [
+          { name: "guid", type: "bytes32" },
+          { name: "nonce", type: "uint64" },
+          {
+            name: "fee",
+            type: "tuple",
+            components: [
+              { name: "nativeFee", type: "uint256" },
+              { name: "lzTokenFee", type: "uint256" }
+            ]
+          }
+        ]
+      },
+      {
+        name: "oftReceipt",
+        type: "tuple",
+        components: [
+          { name: "amountSentLD", type: "uint256" },
+          { name: "amountReceivedLD", type: "uint256" }
+        ]
+      }
+    ]
+  }
+];
+var OFT_SENT_EVENT_TOPIC = (0, import_viem5.keccak256)(
+  (0, import_viem5.toBytes)("OFTSent(bytes32,uint32,address,uint256,uint256)")
+);
+function getViemChain5(network) {
+  switch (network) {
+    case "ethereum":
+      return chains5.mainnet;
+    case "arbitrum":
+      return chains5.arbitrum;
+    case "ink":
+      return chains5.ink;
+    case "berachain":
+      return chains5.berachain;
+    case "unichain":
+      return chains5.unichain;
+    default:
+      return void 0;
+  }
+}
+function addressToBytes322(address) {
+  return `0x${address.slice(2).padStart(64, "0")}`;
+}
+async function executeBridge(input, options) {
+  const { fromChain, toChain, amount, recipient } = input;
+  const { privateKey, rpcUrl, demoMode, slippageTolerance = 0.5 } = options;
+  if (fromChain === toChain) {
+    throw new Error("Source and destination chains must be different");
+  }
+  if (!BRIDGEABLE_CHAINS.includes(fromChain)) {
+    throw new Error(`Chain ${fromChain} does not support USDT0 bridging`);
+  }
+  if (!BRIDGEABLE_CHAINS.includes(toChain)) {
+    throw new Error(`Chain ${toChain} does not support USDT0 bridging`);
+  }
+  const usdt0Address = USDT0_ADDRESSES[fromChain];
+  if (!usdt0Address) {
+    throw new Error(`USDT0 not found on ${fromChain}`);
+  }
+  const amountBigInt = parseTokenAmount(amount, 6);
+  const slippageMultiplier = BigInt(Math.floor((100 - slippageTolerance) * 100));
+  const minAmountBigInt = amountBigInt * slippageMultiplier / 10000n;
+  if (demoMode) {
+    const fakeTxHash = `0x${"a".repeat(64)}`;
+    const fakeGuid = `0x${"b".repeat(64)}`;
+    const estimatedTime2 = ESTIMATED_BRIDGE_TIMES2[toChain] || 300;
+    return {
+      txHash: fakeTxHash,
+      messageGuid: fakeGuid,
+      amount,
+      fromChain,
+      toChain,
+      estimatedTime: estimatedTime2,
+      trackingUrl: getLayerZeroScanUrl(fakeGuid)
+    };
+  }
+  const chain = getViemChain5(fromChain);
+  if (!chain) {
+    throw new Error(`Unsupported chain: ${fromChain}`);
+  }
+  const transport = (0, import_viem5.http)(rpcUrl || DEFAULT_RPC_URLS[fromChain]);
+  const account = (0, import_accounts3.privateKeyToAccount)(privateKey);
+  const publicClient = (0, import_viem5.createPublicClient)({
+    chain,
+    transport
+  });
+  const walletClient = (0, import_viem5.createWalletClient)({
+    account,
+    chain,
+    transport
+  });
+  const balance = await publicClient.readContract({
+    address: usdt0Address,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [account.address]
+  });
+  if (balance < amountBigInt) {
+    throw new Error(
+      `Insufficient USDT0 balance. Have: ${balance.toString()}, Need: ${amountBigInt.toString()}`
+    );
+  }
+  const dstEid = LAYERZERO_ENDPOINT_IDS2[toChain];
+  const sendParam = {
+    dstEid,
+    to: addressToBytes322(recipient),
+    amountLD: amountBigInt,
+    minAmountLD: minAmountBigInt,
+    extraOptions: "0x",
+    composeMsg: "0x",
+    oftCmd: "0x"
+  };
+  const quote = await publicClient.readContract({
+    address: usdt0Address,
+    abi: OFT_ABI2,
+    functionName: "quoteSend",
+    args: [sendParam, false]
+  });
+  const nativeFeeWithBuffer = quote.nativeFee * 110n / 100n;
+  const hash = await walletClient.writeContract({
+    address: usdt0Address,
+    abi: OFT_ABI2,
+    functionName: "send",
+    args: [
+      sendParam,
+      { nativeFee: nativeFeeWithBuffer, lzTokenFee: 0n },
+      account.address
+    ],
+    value: nativeFeeWithBuffer
+  });
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  if (receipt.status !== "success") {
+    throw new Error(`Bridge transaction failed: ${hash}`);
+  }
+  let messageGuid = "0x";
+  for (const log of receipt.logs) {
+    if (log.topics[0] === OFT_SENT_EVENT_TOPIC && log.topics[1]) {
+      messageGuid = log.topics[1];
+      break;
+    }
+  }
+  if (messageGuid === "0x") {
+    throw new Error("Failed to extract message GUID from transaction logs");
+  }
+  const estimatedTime = ESTIMATED_BRIDGE_TIMES2[toChain] || 300;
+  return {
+    txHash: hash,
+    messageGuid,
+    amount,
+    fromChain,
+    toChain,
+    estimatedTime,
+    trackingUrl: getLayerZeroScanUrl(messageGuid)
+  };
+}
+function formatBridgeResult(result) {
+  const minutes = Math.ceil(result.estimatedTime / 60);
+  return [
+    `## Bridge Transaction Submitted`,
+    "",
+    `- **Route:** ${result.fromChain} \u2192 ${result.toChain}`,
+    `- **Amount:** ${result.amount} USDT0`,
+    `- **Transaction:** \`${result.txHash}\``,
+    `- **Message GUID:** \`${result.messageGuid}\``,
+    `- **Estimated Delivery:** ~${minutes} minutes`,
+    "",
+    `### Tracking`,
+    `- [View on LayerZero Scan](${result.trackingUrl})`,
+    `- [View Source TX](${getExplorerTxUrl(result.fromChain, result.txHash)})`,
+    "",
+    "_Your USDT0 will arrive on ${result.toChain} once the LayerZero message is delivered._"
+  ].join("\n");
+}
+
+// src/tools/index.ts
+var TOOL_DEFINITIONS = {
+  "t402/getBalance": {
+    name: "t402/getBalance",
+    description: "Get token balances (native + stablecoins) for a wallet on a specific blockchain network. Returns ETH/native token balance plus USDC, USDT, and USDT0 balances where supported.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        network: {
+          type: "string",
+          enum: [
+            "ethereum",
+            "base",
+            "arbitrum",
+            "optimism",
+            "polygon",
+            "avalanche",
+            "ink",
+            "berachain",
+            "unichain"
+          ],
+          description: "Blockchain network to check balance on"
+        },
+        address: {
+          type: "string",
+          pattern: "^0x[a-fA-F0-9]{40}$",
+          description: "Wallet address to check balance for"
+        }
+      },
+      required: ["network", "address"]
+    }
+  },
+  "t402/getAllBalances": {
+    name: "t402/getAllBalances",
+    description: "Get token balances across all supported networks for a wallet. Returns aggregated totals and per-network breakdown of native tokens and stablecoins (USDC, USDT, USDT0).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        address: {
+          type: "string",
+          pattern: "^0x[a-fA-F0-9]{40}$",
+          description: "Wallet address to check balances for"
+        },
+        networks: {
+          type: "array",
+          items: {
+            type: "string",
+            enum: [
+              "ethereum",
+              "base",
+              "arbitrum",
+              "optimism",
+              "polygon",
+              "avalanche",
+              "ink",
+              "berachain",
+              "unichain"
+            ]
+          },
+          description: "Optional list of networks to check. If not provided, checks all supported networks."
+        }
+      },
+      required: ["address"]
+    }
+  },
+  "t402/pay": {
+    name: "t402/pay",
+    description: "Execute a stablecoin payment on a specific blockchain network. Supports USDC, USDT, and USDT0 tokens. Requires a configured wallet with sufficient balance and native token for gas.",
+    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",
+            "ink",
+            "berachain",
+            "unichain"
+          ],
+          description: "Network to execute payment on"
+        },
+        memo: {
+          type: "string",
+          description: "Optional memo/reference for the payment"
+        }
+      },
+      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)"
+        }
+      },
+      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"
+        }
+      },
+      required: ["fromChain", "toChain", "amount", "recipient"]
+    }
+  }
+};
+
+// src/server/t402Server.ts
+var T402McpServer = class {
+  constructor(config = {}) {
+    this.config = config;
+    this.server = new import_server.Server(
+      {
+        name: "t402",
+        version: "1.0.0"
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    this.setupHandlers();
+  }
+  /**
+   * Set up MCP request handlers
+   */
+  setupHandlers() {
+    this.server.setRequestHandler(import_types.ListToolsRequestSchema, async () => {
+      return {
+        tools: Object.values(TOOL_DEFINITIONS)
+      };
+    });
+    this.server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      try {
+        switch (name) {
+          case "t402/getBalance":
+            return await this.handleGetBalance(args);
+          case "t402/getAllBalances":
+            return await this.handleGetAllBalances(args);
+          case "t402/pay":
+            return await this.handlePay(args);
+          case "t402/payGasless":
+            return await this.handlePayGasless(args);
+          case "t402/getBridgeFee":
+            return await this.handleGetBridgeFee(args);
+          case "t402/bridge":
+            return await this.handleBridge(args);
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    });
+  }
+  /**
+   * Handle t402/getBalance
+   */
+  async handleGetBalance(args) {
+    const input = getBalanceInputSchema.parse(args);
+    const result = await executeGetBalance(input, this.config.rpcUrls);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatBalanceResult(result)
+        }
+      ]
+    };
+  }
+  /**
+   * Handle t402/getAllBalances
+   */
+  async handleGetAllBalances(args) {
+    const input = getAllBalancesInputSchema.parse(args);
+    const result = await executeGetAllBalances(input, this.config.rpcUrls);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAllBalancesResult(result)
+        }
+      ]
+    };
+  }
+  /**
+   * Handle t402/pay
+   */
+  async handlePay(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 = payInputSchema.parse(args);
+    const result = await executePay(input, {
+      privateKey: this.config.privateKey || "0x",
+      rpcUrl: this.config.rpcUrls?.[input.network],
+      demoMode: this.config.demoMode
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatPaymentResult(result)
+        }
+      ]
+    };
+  }
+  /**
+   * Handle t402/payGasless
+   */
+  async handlePayGasless(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."
+      );
+    }
+    if (!this.config.bundlerUrl && !this.config.demoMode) {
+      throw new Error(
+        "Bundler URL not configured. Set T402_BUNDLER_URL environment variable or enable demo mode."
+      );
+    }
+    if (!this.config.paymasterUrl && !this.config.demoMode) {
+      throw new Error(
+        "Paymaster URL not configured. Set T402_PAYMASTER_URL environment variable or enable demo mode."
+      );
+    }
+    const input = payGaslessInputSchema.parse(args);
+    const result = await executePayGasless(input, {
+      privateKey: this.config.privateKey || "0x",
+      bundlerUrl: this.config.bundlerUrl || "",
+      paymasterUrl: this.config.paymasterUrl || "",
+      rpcUrl: this.config.rpcUrls?.[input.network],
+      demoMode: this.config.demoMode
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatGaslessPaymentResult(result)
+        }
+      ]
+    };
+  }
+  /**
+   * Handle t402/getBridgeFee
+   */
+  async handleGetBridgeFee(args) {
+    const input = getBridgeFeeInputSchema.parse(args);
+    const result = await executeGetBridgeFee(input, this.config.rpcUrls);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatBridgeFeeResult(result)
+        }
+      ]
+    };
+  }
+  /**
+   * Handle t402/bridge
+   */
+  async handleBridge(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 = bridgeInputSchema.parse(args);
+    const result = await executeBridge(input, {
+      privateKey: this.config.privateKey || "0x",
+      rpcUrl: this.config.rpcUrls?.[input.fromChain],
+      demoMode: this.config.demoMode
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatBridgeResult(result)
+        }
+      ]
+    };
+  }
+  /**
+   * Start the server using stdio transport
+   */
+  async run() {
+    const transport = new import_stdio.StdioServerTransport();
+    await this.server.connect(transport);
+    console.error("t402 MCP Server running on stdio");
+  }
+};
+function createT402McpServer(config) {
+  return new T402McpServer(config);
+}
+function loadConfigFromEnv() {
+  const config = {};
+  if (process.env.T402_PRIVATE_KEY) {
+    config.privateKey = process.env.T402_PRIVATE_KEY;
+  }
+  if (process.env.T402_DEMO_MODE === "true") {
+    config.demoMode = true;
+  }
+  if (process.env.T402_BUNDLER_URL) {
+    config.bundlerUrl = process.env.T402_BUNDLER_URL;
+  }
+  if (process.env.T402_PAYMASTER_URL) {
+    config.paymasterUrl = process.env.T402_PAYMASTER_URL;
+  }
+  const rpcUrls = {};
+  const networks = [
+    "ethereum",
+    "base",
+    "arbitrum",
+    "optimism",
+    "polygon",
+    "avalanche",
+    "ink",
+    "berachain",
+    "unichain"
+  ];
+  for (const network of networks) {
+    const envVar = `T402_RPC_${network.toUpperCase()}`;
+    if (process.env[envVar]) {
+      rpcUrls[network] = process.env[envVar];
+    }
+  }
+  if (Object.keys(rpcUrls).length > 0) {
+    config.rpcUrls = rpcUrls;
+  }
+  return config;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BRIDGEABLE_CHAINS,
+  CHAIN_IDS,
+  DEFAULT_RPC_URLS,
+  EXPLORER_URLS,
+  GASLESS_SUPPORTED_NETWORKS,
+  NATIVE_SYMBOLS,
+  T402McpServer,
+  TOOL_DEFINITIONS,
+  USDC_ADDRESSES,
+  USDT0_ADDRESSES,
+  USDT_ADDRESSES,
+  bridgeInputSchema,
+  createT402McpServer,
+  executeBridge,
+  executeGetAllBalances,
+  executeGetBalance,
+  executeGetBridgeFee,
+  executePay,
+  executePayGasless,
+  formatAllBalancesResult,
+  formatBalanceResult,
+  formatBridgeFeeResult,
+  formatBridgeResult,
+  formatGaslessPaymentResult,
+  formatPaymentResult,
+  formatTokenAmount,
+  getAllBalancesInputSchema,
+  getBalanceInputSchema,
+  getBridgeFeeInputSchema,
+  getExplorerTxUrl,
+  getLayerZeroScanUrl,
+  getTokenAddress,
+  loadConfigFromEnv,
+  parseTokenAmount,
+  payGaslessInputSchema,
+  payInputSchema,
+  supportsToken
+});
+//# sourceMappingURL=index.js.map