web3agent 0.1.0

package/dist/startup-PHXZQ2SL.js

@@ -0,0 +1,3912 @@
+#!/usr/bin/env node
+import {
+  VERSION
+} from "./chunk-4GQR4EEY.js";
+import {
+  BLOCKSCOUT_DEFAULT_URL,
+  ETHERSCAN_DEFAULT_URL,
+  ValidationError,
+  getChainById,
+  getConfig,
+  isSupported,
+  parseEnv,
+  setConfig
+} from "./chunk-BF4PA46E.js";
+
+// src/config/health.ts
+function formatHealthSummary(report) {
+  const lines = [
+    `[web3agent] Starting on chain ${report.activeChainId}, wallet: ${report.walletMode}, confirm: ${report.confirmWrites}`,
+    `[web3agent] Tools: ${report.totalToolCount} loaded`
+  ];
+  if (report.degradedServices.length > 0) {
+    lines.push(`[web3agent] Degraded: ${report.degradedServices.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function createDefaultHealthStatus() {
+  return {
+    core: "ok",
+    blockscout: { name: "blockscout", status: "not_configured" },
+    etherscan: { name: "etherscan", status: "not_configured" },
+    evm: { name: "evm", status: "not_configured" },
+    goat: { name: "goat", status: "not_configured" },
+    lifi: { name: "lifi", status: "not_configured" },
+    orbs: { name: "orbs", status: "not_configured" }
+  };
+}
+function createStartupReport(partial) {
+  return {
+    health: partial.health ?? createDefaultHealthStatus(),
+    totalToolCount: partial.totalToolCount ?? 0,
+    walletMode: partial.walletMode ?? "none",
+    confirmWrites: partial.confirmWrites ?? true,
+    activeChainId: partial.activeChainId ?? 8453,
+    degradedServices: partial.degradedServices ?? [],
+    fatalError: partial.fatalError
+  };
+}
+
+// src/goat/provider.ts
+import { getOnChainTools } from "@goat-sdk/adapter-model-context-protocol";
+import { viem } from "@goat-sdk/wallet-viem";
+import { generatePrivateKey as generatePrivateKey2, privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+
+// src/config/wallet-factory.ts
+import { http, createWalletClient } from "viem";
+var RELIABLE_FALLBACK_RPCS = {
+  56: "https://bsc-dataseed.bnbchain.org"
+};
+function getTransportForChain(chainId) {
+  const config = getConfig();
+  const perChainUrl = config.chainRpcUrls[chainId];
+  if (perChainUrl) return http(perChainUrl);
+  if (config.rpcUrl && chainId === config.chainId) return http(config.rpcUrl);
+  const fallback = RELIABLE_FALLBACK_RPCS[chainId];
+  if (fallback) return http(fallback);
+  return http();
+}
+function createWalletClientForChain(account, chainId) {
+  const chain = getChainById(chainId);
+  if (!chain) {
+    throw new Error(`Unsupported chain ID: ${chainId}`);
+  }
+  return createWalletClient({ account, chain, transport: getTransportForChain(chainId) });
+}
+
+// src/wallet/events.ts
+import { EventEmitter } from "events";
+var WalletEventEmitter = class extends EventEmitter {
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+};
+var walletEvents = new WalletEventEmitter();
+
+// src/wallet/persistence.ts
+import { existsSync } from "fs";
+import { mkdir, open, readFile, rename, unlink } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from "viem/accounts";
+var currentState = {
+  mode: "read-only",
+  chainId: 1,
+  accountIndex: 0,
+  addressIndex: 0
+};
+var currentAccount = null;
+function getWalletDir() {
+  return join(homedir(), ".web3agent");
+}
+function getWalletPath() {
+  return join(getWalletDir(), "wallet.json");
+}
+function getWalletState() {
+  return { ...currentState };
+}
+function getActiveAccount() {
+  if (!currentAccount) {
+    throw new Error("Wallet not initialized \u2014 call initializeWallet() first");
+  }
+  return currentAccount;
+}
+function resolveFromPrivateKey(privateKey, chainId) {
+  const account = privateKeyToAccount(privateKey);
+  return {
+    account,
+    state: {
+      mode: "private-key",
+      address: account.address,
+      chainId,
+      accountIndex: 0,
+      addressIndex: 0
+    }
+  };
+}
+function resolveFromMnemonic(mnemonic, chainId, accountIndex, addressIndex) {
+  const account = mnemonicToAccount(mnemonic, {
+    accountIndex,
+    addressIndex
+  });
+  return {
+    account,
+    state: {
+      mode: "mnemonic",
+      address: account.address,
+      chainId,
+      accountIndex,
+      addressIndex
+    }
+  };
+}
+function resolveEphemeral(chainId) {
+  const key = generatePrivateKey();
+  const account = privateKeyToAccount(key);
+  return {
+    account,
+    state: {
+      mode: "read-only",
+      address: account.address,
+      chainId,
+      accountIndex: 0,
+      addressIndex: 0
+    }
+  };
+}
+async function tryLoadPersistedWallet(chainId, accountIndex, addressIndex) {
+  const walletPath = getWalletPath();
+  const tmpPath = `${walletPath}.tmp`;
+  if (existsSync(tmpPath)) {
+    try {
+      await unlink(tmpPath);
+    } catch {
+    }
+  }
+  if (!existsSync(walletPath)) return null;
+  try {
+    const raw = await readFile(walletPath, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.type === "private-key") {
+      return resolveFromPrivateKey(data.privateKey, chainId);
+    }
+    if (data.type === "mnemonic") {
+      return resolveFromMnemonic(
+        data.mnemonic,
+        chainId,
+        data.accountIndex ?? accountIndex,
+        data.addressIndex ?? addressIndex
+      );
+    }
+  } catch {
+  }
+  return null;
+}
+async function initializeWallet(config) {
+  const { chainId, accountIndex, addressIndex } = config;
+  const envKey = config.privateKey;
+  if (envKey) {
+    const resolved = resolveFromPrivateKey(envKey, chainId);
+    currentAccount = resolved.account;
+    currentState = resolved.state;
+    walletEvents.emit("wallet-changed", currentState);
+    return;
+  }
+  const envMnemonic = config.mnemonic;
+  if (envMnemonic) {
+    const resolved = resolveFromMnemonic(envMnemonic, chainId, accountIndex, addressIndex);
+    currentAccount = resolved.account;
+    currentState = resolved.state;
+    walletEvents.emit("wallet-changed", currentState);
+    return;
+  }
+  const persisted = await tryLoadPersistedWallet(chainId, accountIndex, addressIndex);
+  if (persisted) {
+    currentAccount = persisted.account;
+    currentState = persisted.state;
+    walletEvents.emit("wallet-changed", currentState);
+    return;
+  }
+  const ephemeral = resolveEphemeral(chainId);
+  currentAccount = ephemeral.account;
+  currentState = ephemeral.state;
+  walletEvents.emit("wallet-changed", currentState);
+}
+async function ensureWalletDir() {
+  const dir = getWalletDir();
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+}
+async function persistWallet(data) {
+  await ensureWalletDir();
+  const walletPath = getWalletPath();
+  const tmpPath = `${walletPath}.tmp`;
+  const fd = await open(tmpPath, "w", 384);
+  try {
+    await fd.writeFile(JSON.stringify(data, null, 2));
+    await fd.sync();
+  } finally {
+    await fd.close();
+  }
+  await rename(tmpPath, walletPath);
+}
+async function activateWallet(params) {
+  const chainId = currentState.chainId;
+  const accountIndex = params.accountIndex ?? 0;
+  const addressIndex = params.addressIndex ?? 0;
+  if (params.privateKey) {
+    const resolved = resolveFromPrivateKey(params.privateKey, chainId);
+    await persistWallet({
+      type: "private-key",
+      privateKey: params.privateKey,
+      address: resolved.account.address
+    });
+    currentAccount = resolved.account;
+    currentState = resolved.state;
+  } else if (params.mnemonic) {
+    const resolved = resolveFromMnemonic(params.mnemonic, chainId, accountIndex, addressIndex);
+    await persistWallet({
+      type: "mnemonic",
+      mnemonic: params.mnemonic,
+      accountIndex,
+      addressIndex
+    });
+    currentAccount = resolved.account;
+    currentState = resolved.state;
+  } else {
+    throw new Error("Either privateKey or mnemonic must be provided");
+  }
+  walletEvents.emit("wallet-changed", currentState);
+  return getWalletState();
+}
+async function getPersistedKeyForSubprocess() {
+  if (process.env.PRIVATE_KEY) return process.env.PRIVATE_KEY;
+  if (process.env.MNEMONIC) {
+    const accountIndex = Number(process.env.WALLET_ACCOUNT_INDEX ?? 0);
+    const addressIndex = Number(process.env.WALLET_ADDRESS_INDEX ?? 0);
+    const account = mnemonicToAccount(process.env.MNEMONIC, { accountIndex, addressIndex });
+    const hdKey = account.getHdKey();
+    if (hdKey.privateKey) {
+      return `0x${Buffer.from(hdKey.privateKey).toString("hex")}`;
+    }
+    return null;
+  }
+  const walletPath = getWalletPath();
+  if (!existsSync(walletPath)) return null;
+  try {
+    const raw = await readFile(walletPath, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.type === "private-key") return data.privateKey;
+    if (data.type === "mnemonic") {
+      const account = mnemonicToAccount(data.mnemonic, {
+        accountIndex: data.accountIndex ?? 0,
+        addressIndex: data.addressIndex ?? 0
+      });
+      const hdKey = account.getHdKey();
+      if (hdKey.privateKey) {
+        return `0x${Buffer.from(hdKey.privateKey).toString("hex")}`;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function deactivateWallet() {
+  const walletPath = getWalletPath();
+  if (existsSync(walletPath)) {
+    await unlink(walletPath);
+  }
+  const ephemeral = resolveEphemeral(currentState.chainId);
+  currentAccount = ephemeral.account;
+  currentState = ephemeral.state;
+  walletEvents.emit("wallet-changed", currentState);
+}
+
+// src/goat/plugins.ts
+import { zeroEx } from "@goat-sdk/plugin-0x";
+import { balancer } from "@goat-sdk/plugin-balancer";
+import { coingecko } from "@goat-sdk/plugin-coingecko";
+import { dexscreener } from "@goat-sdk/plugin-dexscreener";
+import { ens } from "@goat-sdk/plugin-ens";
+import { USDC, WETH, erc20 } from "@goat-sdk/plugin-erc20";
+
+// node_modules/.pnpm/@goat-sdk+plugin-erc721@0.1.22_@goat-sdk+core@0.5.0_zod@3.25.76__bufferutil@4.1.0_typescript@_kuv3rgxdfmzbc55zxk3icop5ti/node_modules/@goat-sdk/plugin-erc721/dist/chunk-YSXGDEY5.mjs
+var c = Object.defineProperty;
+var d = (a2, b) => c(a2, "name", { value: b, configurable: true });
+
+// node_modules/.pnpm/@goat-sdk+plugin-erc721@0.1.22_@goat-sdk+core@0.5.0_zod@3.25.76__bufferutil@4.1.0_typescript@_kuv3rgxdfmzbc55zxk3icop5ti/node_modules/@goat-sdk/plugin-erc721/dist/chunk-YVTV6MH2.mjs
+var d2 = { symbol: "BAYC", name: "Bored Ape Yacht Club", chains: { 1: { contractAddress: "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D" } } };
+var A = { symbol: "PUNK", name: "CryptoPunks", chains: { 1: { contractAddress: "0xb47e3cd837dDF8e4c57F05d70Ab865de6e193BBB" } } };
+function m(t2, c4) {
+  let s3 = [];
+  for (let o2 of c4) {
+    let e3 = o2.chains[t2];
+    e3 && s3.push({ chainId: t2, symbol: o2.symbol, name: o2.name, contractAddress: e3.contractAddress });
+  }
+  return s3;
+}
+d(m, "getTokensForNetwork");
+
+// node_modules/.pnpm/@goat-sdk+plugin-erc721@0.1.22_@goat-sdk+core@0.5.0_zod@3.25.76__bufferutil@4.1.0_typescript@_kuv3rgxdfmzbc55zxk3icop5ti/node_modules/@goat-sdk/plugin-erc721/dist/chunk-Y4M3I524.mjs
+import { parseAbi as e } from "viem";
+var o = e(["function transferFrom(address from, address to, uint256 tokenId) external", "function safeTransferFrom(address from, address to, uint256 tokenId) external", "function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) external", "function approve(address to, uint256 tokenId) external", "function setApprovalForAll(address operator, bool approved) external", "function getApproved(uint256 tokenId) external view returns (address)", "function isApprovedForAll(address owner, address operator) external view returns (bool)", "function balanceOf(address owner) external view returns (uint256)", "function ownerOf(uint256 tokenId) external view returns (address)"]);
+
+// node_modules/.pnpm/@goat-sdk+plugin-erc721@0.1.22_@goat-sdk+core@0.5.0_zod@3.25.76__bufferutil@4.1.0_typescript@_kuv3rgxdfmzbc55zxk3icop5ti/node_modules/@goat-sdk/plugin-erc721/dist/chunk-7FXBTDRO.mjs
+async function f(a2, o2, r) {
+  try {
+    return (await a2.read({ address: o2.contractAddress, abi: o, functionName: "balanceOf", args: [r.wallet] })).value.toString();
+  } catch (t2) {
+    throw Error(`Failed to fetch balance: ${t2}`);
+  }
+}
+d(f, "balanceOf");
+async function u(a2, o2, r) {
+  try {
+    let t2 = r.to;
+    return (await a2.sendTransaction({ to: o2.contractAddress, abi: o, functionName: "safeTransferFrom", args: [a2.getAddress(), t2, r.tokenId] })).hash;
+  } catch (t2) {
+    throw Error(`Failed to transfer: ${t2}`);
+  }
+}
+d(u, "transfer");
+async function l(a2, o2) {
+  try {
+    return (await a2.read({ address: o2.contractAddress, abi: o, functionName: "totalSupply" })).value.toString();
+  } catch (r) {
+    throw Error(`Failed to fetch total supply: ${r}`);
+  }
+}
+d(l, "totalSupply");
+async function p(a2, o2, r) {
+  try {
+    let t2 = r.spender;
+    return (await a2.sendTransaction({ to: o2.contractAddress, abi: o, functionName: "approve", args: [t2, r.tokenId] })).hash;
+  } catch (t2) {
+    throw Error(`Failed to approve: ${t2}`);
+  }
+}
+d(p, "approve");
+async function y(a2, o2, r) {
+  try {
+    let t2 = r.from, s3 = r.to;
+    return (await a2.sendTransaction({ to: o2.contractAddress, abi: o, functionName: "safeTransferFrom", args: [t2, s3, r.tokenId] })).hash;
+  } catch (t2) {
+    throw Error(`Failed to transfer from: ${t2}`);
+  }
+}
+d(y, "transferFrom");
+
+// node_modules/.pnpm/@goat-sdk+plugin-erc721@0.1.22_@goat-sdk+core@0.5.0_zod@3.25.76__bufferutil@4.1.0_typescript@_kuv3rgxdfmzbc55zxk3icop5ti/node_modules/@goat-sdk/plugin-erc721/dist/chunk-QJ4AOIPR.mjs
+import { z as e2 } from "zod";
+var s = e2.object({ wallet: e2.string().describe("The address to get the NFT balance of") });
+var a = e2.object({ to: e2.string().describe("The address to transfer the NFT to"), tokenId: e2.string().describe("The ID of the NFT to transfer") });
+var c2 = e2.object({});
+var n = e2.object({ spender: e2.string().describe("The address to approve for the NFT"), tokenId: e2.string().describe("The ID of the NFT to approve") });
+var h = e2.object({ from: e2.string().describe("The address to transfer the NFT from"), to: e2.string().describe("The address to transfer the NFT to"), tokenId: e2.string().describe("The ID of the NFT to transfer") });
+var d3 = e2.object({ tokenId: e2.string().describe("The ID of the NFT to check ownership of") });
+
+// node_modules/.pnpm/@goat-sdk+plugin-erc721@0.1.22_@goat-sdk+core@0.5.0_zod@3.25.76__bufferutil@4.1.0_typescript@_kuv3rgxdfmzbc55zxk3icop5ti/node_modules/@goat-sdk/plugin-erc721/dist/chunk-CBG3ZAQD.mjs
+import { createTool as s2 } from "@goat-sdk/core";
+function k(e3, b) {
+  let a2 = [];
+  for (let o2 of b) {
+    let d4 = s2({ name: `get_${o2.symbol}_balance`, description: `This {{tool}} gets the number of NFTs owned for ${o2.symbol}`, parameters: s }, (r) => f(e3, o2, r)), $ = s2({ name: `transfer_${o2.symbol}`, description: `This {{tool}} transfers a ${o2.symbol} NFT to the specified address`, parameters: a }, (r) => u(e3, o2, r)), u2 = s2({ name: `get_${o2.symbol}_total_supply`, description: `This {{tool}} gets the total supply of ${o2.symbol} NFTs`, parameters: c2 }, (r) => l(e3, o2)), _ = s2({ name: `approve_${o2.symbol}`, description: `This {{tool}} approves an address to transfer a specific ${o2.symbol} NFT`, parameters: n }, (r) => p(e3, o2, r)), F = s2({ name: `transfer_${o2.symbol}_from`, description: `This {{tool}} transfers a ${o2.symbol} NFT from one address to another`, parameters: h }, (r) => y(e3, o2, r));
+    a2.push(d4, $, u2, _, F);
+  }
+  return a2;
+}
+d(k, "getTools");
+
+// node_modules/.pnpm/@goat-sdk+plugin-erc721@0.1.22_@goat-sdk+core@0.5.0_zod@3.25.76__bufferutil@4.1.0_typescript@_kuv3rgxdfmzbc55zxk3icop5ti/node_modules/@goat-sdk/plugin-erc721/dist/chunk-DH72JTG4.mjs
+import { PluginBase as c3 } from "@goat-sdk/core";
+var t = class extends c3 {
+  static {
+    d(this, "ERC721Plugin");
+  }
+  tokens;
+  constructor({ tokens: o2 }) {
+    super("erc721", []), this.tokens = o2;
+  }
+  supportsChain = d((o2) => o2.type === "evm", "supportsChain");
+  getTools(o2) {
+    let s3 = o2.getChain();
+    if (!s3.id) throw new Error("Network ID is required");
+    let p2 = m(s3.id, this.tokens);
+    return k(o2, p2);
+  }
+};
+function w({ tokens: e3 }) {
+  return new t({ tokens: e3 });
+}
+d(w, "erc721");
+
+// src/goat/plugins.ts
+import { uniswap } from "@goat-sdk/plugin-uniswap";
+function loadPlugins(options) {
+  const result = {
+    plugins: [],
+    loadedTier0: [],
+    loadedTier1: [],
+    loadedTier2: [],
+    failedPlugins: []
+  };
+  const tier0 = [
+    {
+      name: "erc20",
+      factory: () => erc20({ tokens: [USDC, WETH] })
+    },
+    {
+      name: "erc721",
+      factory: () => w({ tokens: [d2, A] })
+    },
+    {
+      name: "ens",
+      factory: () => ens({})
+    },
+    {
+      name: "dexscreener",
+      factory: () => dexscreener()
+    }
+  ];
+  for (const { name, factory } of tier0) {
+    try {
+      result.plugins.push(factory());
+      result.loadedTier0.push(name);
+    } catch (e3) {
+      process.stderr.write(`[web3agent] GOAT plugin ${name} failed to load: ${e3}
+`);
+      result.failedPlugins.push({ name, error: String(e3) });
+    }
+  }
+  if (options.hasWallet) {
+    const tier1 = [
+      {
+        name: "uniswap",
+        factory: () => uniswap({
+          apiKey: "default",
+          baseUrl: "https://api.uniswap.org"
+        }),
+        condition: true
+      },
+      {
+        name: "balancer",
+        factory: () => balancer({ rpcUrl: options.rpcUrl ?? "https://eth.llamarpc.com" }),
+        condition: true
+      }
+    ];
+    for (const { name, factory, condition } of tier1) {
+      if (!condition) continue;
+      try {
+        result.plugins.push(factory());
+        result.loadedTier1.push(name);
+      } catch (e3) {
+        process.stderr.write(`[web3agent] GOAT plugin ${name} failed to load: ${e3}
+`);
+        result.failedPlugins.push({ name, error: String(e3) });
+      }
+    }
+  }
+  if (options.coingeckoApiKey) {
+    try {
+      result.plugins.push(coingecko({ apiKey: options.coingeckoApiKey }));
+      result.loadedTier2.push("coingecko");
+    } catch (e3) {
+      process.stderr.write(`[web3agent] GOAT plugin coingecko failed to load: ${e3}
+`);
+      result.failedPlugins.push({ name: "coingecko", error: String(e3) });
+    }
+  }
+  if (options.zeroxApiKey) {
+    try {
+      result.plugins.push(zeroEx({ apiKey: options.zeroxApiKey }));
+      result.loadedTier2.push("0x");
+    } catch (e3) {
+      process.stderr.write(`[web3agent] GOAT plugin 0x failed to load: ${e3}
+`);
+      result.failedPlugins.push({ name: "0x", error: String(e3) });
+    }
+  }
+  return result;
+}
+
+// src/goat/provider.ts
+var GoatProvider = class {
+  snapshots = /* @__PURE__ */ new Map();
+  pluginResult;
+  referenceSnapshot;
+  generation = 0;
+  initConfig;
+  walletChangeHandler;
+  rebuildPromise = Promise.resolve();
+  async initialize(config) {
+    this.initConfig = config;
+    const walletState = getWalletState();
+    const hasWallet = walletState.mode !== "read-only";
+    this.pluginResult = loadPlugins({
+      hasWallet,
+      zeroxApiKey: config.zeroxApiKey,
+      coingeckoApiKey: config.coingeckoApiKey,
+      rpcUrl: config.rpcUrl
+    });
+    const defaultChainId = walletState.chainId;
+    await this.buildSnapshot(defaultChainId);
+    this.referenceSnapshot = this.snapshots.get(defaultChainId);
+    this.walletChangeHandler = (state) => {
+      this.generation++;
+      const gen = this.generation;
+      const hasWallet2 = state.mode !== "read-only";
+      this.pluginResult = loadPlugins({
+        hasWallet: hasWallet2,
+        zeroxApiKey: this.initConfig?.zeroxApiKey,
+        coingeckoApiKey: this.initConfig?.coingeckoApiKey,
+        rpcUrl: this.initConfig?.rpcUrl
+      });
+      this.rebuildPromise = this.rebuildPromise.catch(() => {
+      }).then(() => this.buildSnapshot(state.chainId)).then(() => {
+        if (this.generation !== gen) return;
+        this.referenceSnapshot = this.snapshots.get(state.chainId);
+        process.stderr.write(
+          `[goat] Rebuilt snapshot for chain ${state.chainId} after wallet change
+`
+        );
+      }).catch((e3) => {
+        process.stderr.write(`[goat] Failed to rebuild snapshot after wallet change: ${e3}
+`);
+      });
+    };
+    walletEvents.on("wallet-changed", this.walletChangeHandler);
+  }
+  /** Wait for any in-flight rebuild triggered by a wallet change. */
+  async waitForRebuild() {
+    await this.rebuildPromise;
+  }
+  shutdown() {
+    if (this.walletChangeHandler) {
+      walletEvents.off("wallet-changed", this.walletChangeHandler);
+      this.walletChangeHandler = void 0;
+    }
+  }
+  async buildSnapshot(chainId) {
+    if (!this.pluginResult) {
+      throw new Error("GoatProvider not initialized \u2014 call initialize() first");
+    }
+    let account;
+    const walletState = getWalletState();
+    if (walletState.mode !== "read-only") {
+      account = getActiveAccount();
+    } else {
+      const ephemeralKey = generatePrivateKey2();
+      account = privateKeyToAccount2(ephemeralKey);
+    }
+    const walletClient = createWalletClientForChain(account, chainId);
+    const tools = await getOnChainTools({
+      wallet: viem(walletClient),
+      plugins: this.pluginResult.plugins
+      // biome-ignore lint/suspicious/noExplicitAny: GOAT SDK generics require flexible typing for cross-plugin wallet compat
+    });
+    this.snapshots.set(chainId, {
+      listOfTools: tools.listOfTools(),
+      toolHandler: tools.toolHandler,
+      chainId
+    });
+  }
+  async getOrBuildSnapshot(chainId) {
+    const existing = this.snapshots.get(chainId);
+    if (existing) return existing;
+    try {
+      await this.buildSnapshot(chainId);
+      return this.snapshots.get(chainId);
+    } catch (e3) {
+      process.stderr.write(`[web3agent] GOAT snapshot failed for chain ${chainId}: ${e3}
+`);
+      return void 0;
+    }
+  }
+  getReferenceSnapshot() {
+    return this.referenceSnapshot;
+  }
+  getAllToolNames() {
+    if (this.referenceSnapshot) {
+      return this.referenceSnapshot.listOfTools.map((t2) => t2.name);
+    }
+    return [];
+  }
+  getLoadedPlugins() {
+    if (!this.pluginResult) return [];
+    return [
+      ...this.pluginResult.loadedTier0,
+      ...this.pluginResult.loadedTier1,
+      ...this.pluginResult.loadedTier2
+    ];
+  }
+};
+var goatProvider = new GoatProvider();
+
+// src/lifi/config.ts
+import { EVM, createConfig } from "@lifi/sdk";
+var isConfigured = false;
+function initializeLifi(apiKey) {
+  if (isConfigured) return;
+  createConfig({
+    integrator: "web3agent",
+    ...apiKey ? { apiKey } : {},
+    providers: [
+      EVM({
+        getWalletClient: async () => {
+          const account = getActiveAccount();
+          const walletState = getWalletState();
+          return createWalletClientForChain(account, walletState.chainId);
+        },
+        switchChain: async (chainId) => {
+          const account = getActiveAccount();
+          return createWalletClientForChain(account, chainId);
+        }
+      })
+    ]
+  });
+  isConfigured = true;
+}
+
+// src/tools/lifi/index.ts
+import { convertQuoteToRoute, executeRoute, getChains, getQuote } from "@lifi/sdk";
+
+// src/utils/errors.ts
+function formatToolError(code, message, details) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ error: code, message, details })
+      }
+    ],
+    isError: true
+  };
+}
+function formatToolResponse(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof data === "string" ? data : JSON.stringify(data, null, 2)
+      }
+    ],
+    isError: false
+  };
+}
+
+// src/utils/validation.ts
+function validateInput(schema, input) {
+  const result = schema.safeParse(input);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const messages = result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`);
+  return {
+    success: false,
+    error: formatToolError("INVALID_PARAMS", messages.join("; "))
+  };
+}
+
+// src/wallet/confirmation.ts
+import { randomUUID } from "crypto";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, open as open2, readFile as readFile2, rename as rename2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var THIRTY_MINUTES_MS = 30 * 60 * 1e3;
+var executorRegistry = /* @__PURE__ */ new Map();
+function registerExecutor(type, fn) {
+  executorRegistry.set(type, fn);
+}
+function getPendingOpsPath() {
+  return join2(homedir2(), ".web3agent", "pending-ops.json");
+}
+var ConfirmationQueueManager = class {
+  queue = /* @__PURE__ */ new Map();
+  enabled;
+  constructor(enabled) {
+    this.enabled = enabled;
+  }
+  enqueue(type, description, params, executor, walletAddress) {
+    if (!this.enabled) {
+      return {
+        queued: false,
+        id: null,
+        summary: `Confirmation bypassed: ${description}`
+      };
+    }
+    const id = randomUUID();
+    const operation = {
+      id,
+      type,
+      description,
+      params,
+      executor,
+      createdAt: /* @__PURE__ */ new Date(),
+      ttlMs: THIRTY_MINUTES_MS,
+      walletAddress
+    };
+    this.queue.set(id, operation);
+    this.persistQueue().catch((e3) => {
+      process.stderr.write(`[confirmation] Failed to persist queue: ${e3}
+`);
+    });
+    return {
+      queued: true,
+      id,
+      summary: `Queued [${type}]: ${description} \u2014 confirm with ID: ${id}`
+    };
+  }
+  confirm(id) {
+    const operation = this.queue.get(id);
+    if (!operation) return null;
+    const elapsed = Date.now() - operation.createdAt.getTime();
+    const stale = elapsed > operation.ttlMs;
+    return { operation, stale };
+  }
+  complete(id) {
+    this.queue.delete(id);
+    this.persistQueue().catch((e3) => {
+      process.stderr.write(`[confirmation] Failed to persist queue: ${e3}
+`);
+    });
+  }
+  deny(id) {
+    const removed = this.queue.delete(id);
+    if (removed)
+      this.persistQueue().catch((e3) => {
+        process.stderr.write(`[confirmation] Failed to persist queue: ${e3}
+`);
+      });
+    return removed;
+  }
+  list() {
+    return [...this.queue.values()];
+  }
+  pruneExpired() {
+    const now = Date.now();
+    let pruned = false;
+    for (const [id, op] of this.queue) {
+      if (now - op.createdAt.getTime() > op.ttlMs) {
+        this.queue.delete(id);
+        pruned = true;
+      }
+    }
+    if (pruned)
+      this.persistQueue().catch((e3) => {
+        process.stderr.write(`[confirmation] Failed to persist queue: ${e3}
+`);
+      });
+  }
+  flushAll() {
+    const count = this.queue.size;
+    this.queue.clear();
+    this.persistQueue().catch((e3) => {
+      process.stderr.write(`[confirmation] Failed to persist queue: ${e3}
+`);
+    });
+    return count;
+  }
+  async persistQueue() {
+    const ops = [...this.queue.values()].map((op) => ({
+      id: op.id,
+      type: op.type,
+      description: op.description,
+      params: op.params,
+      createdAt: op.createdAt.toISOString(),
+      ttlMs: op.ttlMs,
+      walletAddress: op.walletAddress
+    }));
+    const filePath = getPendingOpsPath();
+    const dir = join2(homedir2(), ".web3agent");
+    if (!existsSync2(dir)) {
+      await mkdir2(dir, { recursive: true });
+    }
+    const tmpPath = `${filePath}.tmp`;
+    const fd = await open2(tmpPath, "w", 384);
+    try {
+      await fd.writeFile(JSON.stringify(ops, null, 2));
+      await fd.sync();
+    } finally {
+      await fd.close();
+    }
+    await rename2(tmpPath, filePath);
+  }
+  async loadQueue() {
+    const filePath = getPendingOpsPath();
+    if (!existsSync2(filePath)) return;
+    try {
+      const raw = await readFile2(filePath, "utf-8");
+      const ops = JSON.parse(raw);
+      const now = Date.now();
+      for (const serialized of ops) {
+        const createdAt = new Date(serialized.createdAt);
+        const elapsed = now - createdAt.getTime();
+        if (elapsed > serialized.ttlMs) continue;
+        const executor = executorRegistry.get(serialized.type);
+        if (!executor) {
+          process.stderr.write(
+            `[confirmation] Skipping persisted op ${serialized.id}: no executor for type '${serialized.type}'
+`
+          );
+          continue;
+        }
+        this.queue.set(serialized.id, {
+          id: serialized.id,
+          type: serialized.type,
+          description: serialized.description,
+          params: serialized.params,
+          executor,
+          createdAt,
+          ttlMs: serialized.ttlMs,
+          walletAddress: serialized.walletAddress
+        });
+      }
+      if (this.queue.size > 0) {
+        process.stderr.write(
+          `[confirmation] Restored ${this.queue.size} pending operation(s) from disk
+`
+        );
+      }
+    } catch (e3) {
+      process.stderr.write(
+        `[confirmation] Failed to load persisted queue (starting fresh): ${e3}
+`
+      );
+    }
+  }
+};
+var confirmationQueue = new ConfirmationQueueManager(true);
+
+// src/utils/write.ts
+async function executeWrite(options) {
+  const walletState = getWalletState();
+  if (walletState.mode === "read-only") {
+    return formatToolError(
+      "WALLET_READ_ONLY",
+      `${options.toolName} requires an active wallet. Use wallet_generate or import a key first.`
+    );
+  }
+  const { queued, id, summary } = confirmationQueue.enqueue(
+    options.toolName,
+    options.description,
+    options.params,
+    options.executor,
+    walletState.address
+  );
+  if (queued) {
+    return formatToolResponse({ status: "pending_confirmation", id, summary });
+  }
+  return options.executor(options.params);
+}
+
+// src/tools/lifi/schemas.ts
+import { z } from "zod";
+var lifiGetQuoteSchema = z.object({
+  fromChainId: z.number({ required_error: "fromChainId is required" }),
+  toChainId: z.number({ required_error: "toChainId is required" }),
+  fromTokenAddress: z.string({ required_error: "fromTokenAddress is required" }),
+  toTokenAddress: z.string({ required_error: "toTokenAddress is required" }),
+  fromAmount: z.string({ required_error: "fromAmount is required" })
+});
+
+// src/tools/lifi/index.ts
+async function lifiGetChains(_params) {
+  try {
+    const chains = await getChains();
+    const summary = chains.map((c4) => ({
+      id: c4.id,
+      name: c4.name,
+      nativeToken: c4.nativeToken?.symbol
+    }));
+    return formatToolResponse(summary);
+  } catch (e3) {
+    return formatToolError("LIFI_ERROR", String(e3));
+  }
+}
+async function lifiGetQuote(params) {
+  const v = validateInput(lifiGetQuoteSchema, params);
+  if (!v.success) return v.error;
+  const { fromChainId, toChainId, fromTokenAddress, toTokenAddress, fromAmount } = v.data;
+  try {
+    const walletState = getWalletState();
+    const quote = await getQuote({
+      fromChain: fromChainId,
+      toChain: toChainId,
+      fromToken: fromTokenAddress,
+      toToken: toTokenAddress,
+      fromAmount,
+      fromAddress: walletState.address ?? "0x0000000000000000000000000000000000000000"
+    });
+    const trimmed = {
+      fromChainId: quote.action.fromChainId,
+      toChainId: quote.action.toChainId,
+      fromToken: quote.action.fromToken?.symbol,
+      toToken: quote.action.toToken?.symbol,
+      fromAmount: quote.action.fromAmount,
+      fromAmountUSD: quote.estimate?.fromAmountUSD,
+      toAmount: quote.estimate?.toAmount,
+      toAmountUSD: quote.estimate?.toAmountUSD,
+      toAmountMin: quote.estimate?.toAmountMin,
+      gasCostUSD: quote.estimate?.gasCosts?.[0]?.amountUSD,
+      estimatedDurationSeconds: quote.estimate?.executionDuration,
+      includedSteps: quote.includedSteps?.map((s3) => ({
+        type: s3.type,
+        tool: s3.tool
+      }))
+    };
+    return formatToolResponse(trimmed);
+  } catch (e3) {
+    return formatToolError("LIFI_QUOTE_ERROR", String(e3));
+  }
+}
+async function lifiExecuteBridge(params) {
+  const v = validateInput(lifiGetQuoteSchema, params);
+  if (!v.success) return v.error;
+  const { fromChainId, toChainId, fromTokenAddress, toTokenAddress, fromAmount } = v.data;
+  return executeWrite({
+    toolName: "lifi_execute_bridge",
+    description: `Bridge ${fromAmount} from chain ${fromChainId} to chain ${toChainId}`,
+    params: v.data,
+    executor: executeBridgeNow
+  });
+}
+async function executeBridgeNow(params) {
+  try {
+    const { fromChainId, toChainId, fromTokenAddress, toTokenAddress, fromAmount } = params;
+    const walletState = getWalletState();
+    const quote = await getQuote({
+      fromChain: fromChainId,
+      toChain: toChainId,
+      fromToken: fromTokenAddress,
+      toToken: toTokenAddress,
+      fromAmount,
+      fromAddress: walletState.address ?? "0x0000000000000000000000000000000000000000"
+    });
+    const route = convertQuoteToRoute(quote);
+    await executeRoute(route, {
+      updateRouteHook: (updatedRoute) => {
+        const step = updatedRoute.steps?.[0];
+        if (step?.execution) {
+          process.stderr.write(
+            `[web3agent] Bridge progress: ${JSON.stringify(step.execution.process)}
+`
+          );
+        }
+      }
+    });
+    return formatToolResponse({
+      status: "completed",
+      message: "Bridge executed successfully"
+    });
+  } catch (e3) {
+    return formatToolError("BRIDGE_ERROR", String(e3));
+  }
+}
+function getLifiToolDefinitions() {
+  return [
+    {
+      name: "lifi_get_chains",
+      description: "Get list of chains supported by LI.FI for cross-chain bridging",
+      inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+      },
+      handler: lifiGetChains
+    },
+    {
+      name: "lifi_get_quote",
+      description: "Get a cross-chain bridge/swap quote from LI.FI. Supports 20+ EVM chains including Ethereum, BSC, Polygon, Arbitrum, Optimism, Base, Linea, Avalanche, zkSync, Scroll, Gnosis, and more. Requires token addresses \u2014 use resolve_token first to get addresses.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          fromChainId: {
+            type: "number",
+            description: "Source chain ID"
+          },
+          toChainId: {
+            type: "number",
+            description: "Destination chain ID"
+          },
+          fromTokenAddress: {
+            type: "string",
+            description: "Source token address"
+          },
+          toTokenAddress: {
+            type: "string",
+            description: "Destination token address"
+          },
+          fromAmount: {
+            type: "string",
+            description: "Amount in wei"
+          }
+        },
+        required: ["fromChainId", "toChainId", "fromTokenAddress", "toTokenAddress", "fromAmount"]
+      },
+      handler: lifiGetQuote
+    },
+    {
+      name: "lifi_execute_bridge",
+      description: "Execute a cross-chain bridge (write operation, requires wallet and confirmation). Requires token addresses \u2014 use resolve_token first to get addresses.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          fromChainId: { type: "number" },
+          toChainId: { type: "number" },
+          fromTokenAddress: { type: "string" },
+          toTokenAddress: { type: "string" },
+          fromAmount: { type: "string" }
+        },
+        required: ["fromChainId", "toChainId", "fromTokenAddress", "toTokenAddress", "fromAmount"]
+      },
+      handler: lifiExecuteBridge
+    }
+  ];
+}
+function registerLifiExecutors() {
+  registerExecutor("lifi_execute_bridge", executeBridgeNow);
+}
+
+// src/orbs/chains.ts
+import { Configs } from "@orbs-network/twap-sdk";
+var LIQUIDITY_HUB_CHAINS = [
+  137,
+  // Polygon
+  56,
+  // BSC
+  8453,
+  // Base
+  59144,
+  // Linea
+  81457,
+  // Blast
+  42161
+  // Arbitrum
+];
+var TWAP_CHAIN_IDS = new Set(Object.values(Configs).map((c4) => c4.chainId));
+function isLiquidityHubSupported(chainId) {
+  return LIQUIDITY_HUB_CHAINS.includes(chainId);
+}
+function isTwapSupported(chainId) {
+  return TWAP_CHAIN_IDS.has(chainId);
+}
+function getLiquidityHubError(chainId) {
+  const names = LIQUIDITY_HUB_CHAINS.map(
+    (id) => `${getChainById(id)?.name ?? String(id)} (${id})`
+  ).join(", ");
+  return `Orbs Liquidity Hub is not available on chain ${chainId}. Supported: ${names}`;
+}
+function getTwapError(chainId) {
+  return `Orbs dTWAP/dLIMIT is not available on chain ${chainId}. Use isTwapSupported() to check availability.`;
+}
+
+// src/orbs/dsltp.ts
+var DSLTP_AVAILABLE = false;
+function getDsltpToolDefinitions() {
+  if (!DSLTP_AVAILABLE) return [];
+  return [];
+}
+
+// src/orbs/liquidity-hub.ts
+import { constructSDK } from "@orbs-network/liquidity-hub-sdk";
+import { createPublicClient, maxUint256 } from "viem";
+if (!("localStorage" in globalThis)) {
+  const noop = () => void 0;
+  Object.defineProperty(globalThis, "localStorage", {
+    value: {
+      getItem: () => null,
+      setItem: noop,
+      removeItem: noop,
+      clear: noop,
+      key: () => null,
+      length: 0
+    },
+    writable: true,
+    configurable: true
+  });
+}
+function normalizeEip712ForSigning(domain, types, primaryType, message) {
+  function normalizeValue(fieldType, value) {
+    if (value == null) return value;
+    if (fieldType.endsWith("[]")) {
+      const elementType = fieldType.slice(0, -2);
+      if (!Array.isArray(value)) return value;
+      return value.map((item) => normalizeValue(elementType, item));
+    }
+    if (types[fieldType]) {
+      return normalizeStruct(fieldType, value);
+    }
+    if (fieldType === "address" && typeof value === "string") {
+      return value.toLowerCase();
+    }
+    if (/^u?int\d*$/.test(fieldType)) {
+      return BigInt(value).toString();
+    }
+    if (fieldType === "bool") {
+      return !!value;
+    }
+    return value;
+  }
+  function normalizeStruct(typeName, obj) {
+    const fields = types[typeName];
+    if (!fields) return obj;
+    const result = {};
+    for (const field of fields) {
+      if (obj[field.name] !== void 0) {
+        result[field.name] = normalizeValue(field.type, obj[field.name]);
+      }
+    }
+    return result;
+  }
+  const normalizedDomain = {};
+  if (domain.name != null) normalizedDomain.name = domain.name;
+  if (domain.version != null) normalizedDomain.version = domain.version;
+  if (domain.chainId != null) normalizedDomain.chainId = Number(domain.chainId);
+  if (domain.verifyingContract != null) {
+    normalizedDomain.verifyingContract = domain.verifyingContract.toLowerCase();
+  }
+  if (domain.salt != null) normalizedDomain.salt = domain.salt;
+  return {
+    domain: normalizedDomain,
+    types,
+    primaryType,
+    message: normalizeStruct(primaryType, message)
+  };
+}
+var sdkCache = /* @__PURE__ */ new Map();
+var DEFAULT_PARTNERS = {
+  56: "thena",
+  137: "quickswap",
+  8453: "intentx",
+  59144: "lynex"
+};
+function getPartner(chainId) {
+  return getConfig().orbsPartner || DEFAULT_PARTNERS[chainId] || "widget";
+}
+function getSdk(chainId) {
+  let sdk = sdkCache.get(chainId);
+  if (!sdk) {
+    sdk = constructSDK({ partner: getPartner(chainId), chainId });
+    sdkCache.set(chainId, sdk);
+  }
+  return sdk;
+}
+var API_URLS = {
+  137: "https://polygon.hub.orbs.network",
+  56: "https://bsc.hub.orbs.network",
+  250: "https://ftm.hub.orbs.network",
+  8453: "https://base.hub.orbs.network",
+  59144: "https://linea.hub.orbs.network",
+  81457: "https://blast.hub.orbs.network",
+  1101: "https://zkevm.hub.orbs.network",
+  146: "https://sonic.hub.orbs.network",
+  42161: "https://arbi.hub.orbs.network"
+};
+function getApiUrl(chainId) {
+  return API_URLS[chainId] || "https://hub.orbs.network";
+}
+async function submitSwap(params) {
+  const { chainId, quote, signature } = params;
+  const apiUrl = getApiUrl(chainId);
+  process.stderr.write(
+    `[orbs] Submitting swap session=${quote.sessionId} ${quote.inAmount} ${quote.inToken} \u2192 ${quote.outToken}
+`
+  );
+  const response = await fetch(`${apiUrl}/swap-async?chainId=${chainId}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      ...quote,
+      inToken: quote.inToken,
+      outToken: quote.outToken,
+      inAmount: quote.inAmount,
+      user: quote.user,
+      signature,
+      sessionId: quote.sessionId
+    })
+  });
+  const result = await response.json();
+  process.stderr.write(`[orbs] swap-async response: ${JSON.stringify(result)}
+`);
+  if (result.error) {
+    return { sessionId: quote.sessionId, status: "failed", error: result.error };
+  }
+  if (result.txHash) {
+    return { sessionId: quote.sessionId, txHash: result.txHash, status: "completed" };
+  }
+  return { sessionId: quote.sessionId, status: "submitted" };
+}
+async function pollSwapStatus(params) {
+  const { chainId, sessionId, user, maxAttempts = 15 } = params;
+  const apiUrl = getApiUrl(chainId);
+  for (let i = 0; i < maxAttempts; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+    try {
+      const response = await fetch(`${apiUrl}/swap/status/${sessionId}?chainId=${chainId}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ user })
+      });
+      const status = await response.json();
+      if (i % 5 === 0 || status.txHash || status.error) {
+        process.stderr.write(`[orbs] Poll ${i + 1}/${maxAttempts}: ${JSON.stringify(status)}
+`);
+      }
+      if (status.error) {
+        return { sessionId, status: "failed", error: status.error };
+      }
+      if (status.txHash) {
+        process.stderr.write(`[orbs] Swap filled! txHash: ${status.txHash}
+`);
+        return { sessionId, txHash: status.txHash, status: "completed" };
+      }
+    } catch (e3) {
+      process.stderr.write(`[orbs] Poll ${i + 1} error: ${e3}
+`);
+    }
+  }
+  return { sessionId, status: "submitted" };
+}
+var QUOTE_ERRORS = {
+  tns: "Token not supported or swap amount too small (minimum ~$6-10 depending on chain)",
+  ldv: "Low dollar value \u2014 swap amount is below the minimum for this token pair",
+  "no liquidity": "No liquidity available for this token pair on the Liquidity Hub",
+  timeout: "Quote request timed out"
+};
+function formatQuoteError(code) {
+  return QUOTE_ERRORS[code] || `Liquidity Hub quote error: ${code}`;
+}
+async function getQuote2(chainId, request) {
+  const sdk = getSdk(chainId);
+  const quote = await sdk.getQuote({
+    fromToken: request.fromToken,
+    toToken: request.toToken,
+    inAmount: request.inAmount,
+    slippage: request.slippage ?? 0.5,
+    account: request.account
+  });
+  if (quote.error) {
+    throw new Error(formatQuoteError(quote.error));
+  }
+  return {
+    inToken: quote.inToken,
+    outToken: quote.outToken,
+    inAmount: quote.inAmount,
+    outAmount: quote.outAmount,
+    minAmountOut: quote.minAmountOut,
+    exchange: quote.exchange
+  };
+}
+var PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var NATIVE_TOKENS = /* @__PURE__ */ new Set([
+  "0x0000000000000000000000000000000000000000",
+  "0x0000000000000000000000000000000000001010",
+  "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+  "0x000000000000000000000000000000000000dead"
+]);
+var WRAPPED_NATIVE = {
+  137: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+  56: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+  8453: "0x4200000000000000000000000000000000000006",
+  59144: "0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f",
+  81457: "0x4300000000000000000000000000000000000004",
+  42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"
+};
+var erc20Abi = [
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "deposit",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [],
+    outputs: []
+  }
+];
+function isNativeToken(address) {
+  return NATIVE_TOKENS.has(address.toLowerCase());
+}
+async function prepareSwap(params) {
+  const { chainId, inAmount, account } = params;
+  const chain = getChainById(chainId);
+  if (!chain) throw new Error(`Unsupported chain: ${chainId}`);
+  const publicClient = createPublicClient({ chain, transport: getTransportForChain(chainId) });
+  let fromToken = params.fromToken;
+  if (isNativeToken(params.fromToken)) {
+    const wrapped = WRAPPED_NATIVE[chainId];
+    if (!wrapped) throw new Error(`No wrapped native token for chain ${chainId}`);
+    const walletClient = createWalletClientForChain(account, chainId);
+    const hash = await walletClient.writeContract({
+      address: wrapped,
+      abi: erc20Abi,
+      functionName: "deposit",
+      value: BigInt(inAmount),
+      chain,
+      account
+    });
+    await publicClient.waitForTransactionReceipt({ hash });
+    process.stderr.write(`[orbs] Wrapped ${inAmount} native \u2192 ${wrapped} (tx: ${hash})
+`);
+    fromToken = wrapped;
+  }
+  const allowance = await publicClient.readContract({
+    address: fromToken,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: [account.address, PERMIT2]
+  });
+  if (allowance < BigInt(inAmount)) {
+    const walletClient = createWalletClientForChain(account, chainId);
+    const hash = await walletClient.writeContract({
+      address: fromToken,
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [PERMIT2, maxUint256],
+      chain,
+      account
+    });
+    await publicClient.waitForTransactionReceipt({ hash });
+    process.stderr.write(`[orbs] Approved ${fromToken} \u2192 Permit2 (tx: ${hash})
+`);
+  }
+  return { fromToken };
+}
+
+// src/orbs/twap.ts
+import {
+  Configs as Configs2,
+  buildRePermitOrderData,
+  getAccountOrders,
+  getSrcTokenChunkAmount,
+  getConfig as getTwapConfig,
+  submitOrder
+} from "@orbs-network/twap-sdk";
+function getChainConfig(chainId) {
+  const match = Object.values(Configs2).find((c4) => c4.chainId === chainId);
+  if (!match) return void 0;
+  return getTwapConfig(chainId, match.partner);
+}
+function prepareTwapOrder(params) {
+  const config = getChainConfig(params.chainId);
+  if (!config) {
+    throw new Error(`No TWAP config available for chain ${params.chainId}`);
+  }
+  const srcAmountPerTrade = getSrcTokenChunkAmount(params.srcAmount, params.chunks);
+  const fillDelayMillis = params.fillDelaySeconds * 1e3;
+  const durationMillis = params.durationSeconds * 1e3;
+  const deadlineMillis = Date.now() + durationMillis;
+  const orderData = buildRePermitOrderData({
+    chainId: params.chainId,
+    srcToken: params.srcToken,
+    dstToken: params.dstToken,
+    srcAmount: params.srcAmount,
+    deadlineMillis,
+    fillDelayMillis,
+    slippage: params.slippage ?? 0.5,
+    account: params.account,
+    srcAmountPerTrade,
+    dstMinAmountPerTrade: params.dstMinAmountPerTrade,
+    triggerAmountPerTrade: params.triggerAmountPerTrade,
+    config
+  });
+  return {
+    domain: orderData.domain,
+    order: orderData.order,
+    types: orderData.types,
+    primaryType: orderData.primaryType
+  };
+}
+async function submitSignedOrder(order, signature) {
+  return submitOrder(order, signature);
+}
+async function listOrders(chainId, account, options) {
+  return getAccountOrders({
+    chainId,
+    account,
+    limit: options?.limit ?? 50,
+    page: options?.page ?? 0
+  });
+}
+
+// src/utils/signature.ts
+function splitSignature(signature) {
+  if (!signature.startsWith("0x")) {
+    throw new Error("Invalid signature: must start with 0x prefix");
+  }
+  if (signature.length !== 132) {
+    throw new Error(
+      `Invalid signature: expected 132 characters (0x + 130 hex), got ${signature.length}`
+    );
+  }
+  if (!/^0x[0-9a-fA-F]{130}$/.test(signature)) {
+    throw new Error("Invalid signature: contains non-hex characters");
+  }
+  return {
+    r: `0x${signature.slice(2, 66)}`,
+    s: `0x${signature.slice(66, 130)}`,
+    v: `0x${signature.slice(130, 132)}`
+  };
+}
+
+// src/utils/tool-helpers.ts
+function resolveChainId(params) {
+  return typeof params.chainId === "number" ? params.chainId : getConfig().chainId;
+}
+
+// src/tools/orbs/schemas.ts
+import { z as z2 } from "zod";
+var orbsGetQuoteSchema = z2.object({
+  chainId: z2.number({ required_error: "chainId is required" }),
+  fromToken: z2.string({ required_error: "fromToken is required" }),
+  toToken: z2.string({ required_error: "toToken is required" }),
+  inAmount: z2.string({ required_error: "inAmount is required" }),
+  slippage: z2.number().optional()
+});
+var orbsSwapSchema = orbsGetQuoteSchema;
+var orbsPlaceTwapSchema = z2.object({
+  chainId: z2.number({ required_error: "chainId is required" }),
+  srcToken: z2.string({ required_error: "srcToken is required" }),
+  dstToken: z2.string({ required_error: "dstToken is required" }),
+  srcAmount: z2.string({ required_error: "srcAmount is required" }),
+  chunks: z2.number({ required_error: "chunks is required" }),
+  fillDelay: z2.number({ required_error: "fillDelay is required" })
+});
+var orbsPlaceLimitSchema = z2.object({
+  chainId: z2.number({ required_error: "chainId is required" }),
+  srcToken: z2.string({ required_error: "srcToken is required" }),
+  dstToken: z2.string({ required_error: "dstToken is required" }),
+  srcAmount: z2.string({ required_error: "srcAmount is required" }),
+  dstMinAmount: z2.string({ required_error: "dstMinAmount is required" }),
+  expiry: z2.number().optional()
+});
+var orbsSwapStatusSchema = z2.object({
+  chainId: z2.number({ required_error: "chainId is required" }),
+  sessionId: z2.string({ required_error: "sessionId is required" }),
+  user: z2.string({ required_error: "user is required" }),
+  maxAttempts: z2.number().optional()
+});
+var orbsListOrdersSchema = z2.object({
+  chainId: z2.number({ required_error: "chainId is required" })
+});
+
+// src/tools/orbs/index.ts
+async function orbsGetQuote(params) {
+  const v = validateInput(orbsGetQuoteSchema, params);
+  if (!v.success) return v.error;
+  const { chainId, fromToken, toToken, inAmount, slippage } = v.data;
+  if (!isLiquidityHubSupported(chainId)) {
+    return formatToolError("CHAIN_NOT_SUPPORTED", getLiquidityHubError(chainId));
+  }
+  try {
+    const result = await getQuote2(chainId, {
+      fromToken,
+      toToken,
+      inAmount,
+      slippage: slippage ?? 0.5
+    });
+    return formatToolResponse(result);
+  } catch (e3) {
+    return formatToolError("ORBS_QUOTE_ERROR", String(e3));
+  }
+}
+async function executeOrbsSwapNow(params) {
+  const chainId = resolveChainId(params);
+  try {
+    const account = getActiveAccount();
+    const { fromToken } = await prepareSwap({
+      chainId,
+      fromToken: params.fromToken,
+      inAmount: params.inAmount,
+      account
+    });
+    const sdk = getSdk(chainId);
+    const slippage = params.slippage ?? 0.5;
+    const toToken = params.toToken;
+    const inAmount = params.inAmount;
+    const quote = await sdk.getQuote({
+      fromToken,
+      toToken,
+      inAmount,
+      slippage,
+      dexMinAmountOut: "-1",
+      account: account.address
+    });
+    if (quote.error) {
+      return formatToolError("ORBS_QUOTE_ERROR", quote.error);
+    }
+    if (quote.inToken && quote.inToken.toLowerCase() !== fromToken.toLowerCase()) {
+      process.stderr.write(
+        `[orbs] Warning: quote.inToken (${quote.inToken}) does not match fromToken (${fromToken})
+`
+      );
+    }
+    if (!account.signTypedData) {
+      return formatToolError("WALLET_ERROR", "Active account does not support EIP-712 signing");
+    }
+    const rawPrimaryType = quote.eip712?.primaryType ?? "PermitWitnessTransferFrom";
+    const rawMessage = quote.eip712?.message ?? quote.permitData;
+    const {
+      domain: eip712Domain,
+      types: eip712Types,
+      primaryType: eip712PrimaryType,
+      message: eip712Message
+    } = normalizeEip712ForSigning(
+      quote.eip712?.domain,
+      quote.eip712?.types,
+      rawPrimaryType,
+      rawMessage
+    );
+    process.stderr.write(
+      `[orbs] EIP-712 primaryType: ${eip712PrimaryType}, types keys: ${Object.keys(eip712Types).join(", ")}
+`
+    );
+    const signature = await account.signTypedData({
+      domain: eip712Domain,
+      types: eip712Types,
+      primaryType: eip712PrimaryType,
+      message: eip712Message
+    });
+    process.stderr.write("[orbs] Attempting swap via SDK swap() method...\n");
+    let txHash;
+    try {
+      txHash = await sdk.swap(quote, signature);
+      process.stderr.write(`[orbs] SDK swap() returned txHash: ${txHash}
+`);
+    } catch (sdkSwapErr) {
+      process.stderr.write(`[orbs] SDK swap() error: ${sdkSwapErr}
+`);
+    }
+    if (txHash) {
+      return formatToolResponse({
+        txHash,
+        status: "completed",
+        quote: { outAmount: quote.outAmount, minAmountOut: quote.minAmountOut }
+      });
+    }
+    process.stderr.write(
+      "[orbs] SDK swap() did not return txHash, falling back to direct API...\n"
+    );
+    const submission = await submitSwap({ chainId, quote, signature });
+    if (submission.status === "failed") {
+      return formatToolError("ORBS_SWAP_ERROR", submission.error ?? "Swap submission failed");
+    }
+    if (submission.status === "completed") {
+      return formatToolResponse({
+        txHash: submission.txHash,
+        status: "completed",
+        quote: { outAmount: quote.outAmount, minAmountOut: quote.minAmountOut }
+      });
+    }
+    const result = await pollSwapStatus({
+      chainId,
+      sessionId: submission.sessionId,
+      user: quote.user,
+      maxAttempts: 15
+    });
+    if (result.status === "completed") {
+      return formatToolResponse({
+        txHash: result.txHash,
+        status: "completed",
+        quote: { outAmount: quote.outAmount, minAmountOut: quote.minAmountOut }
+      });
+    }
+    return formatToolResponse({
+      status: "pending",
+      sessionId: submission.sessionId,
+      chainId,
+      user: quote.user,
+      message: "Swap submitted but not yet filled. Use orbs_swap_status to check.",
+      quote: { outAmount: quote.outAmount, minAmountOut: quote.minAmountOut }
+    });
+  } catch (e3) {
+    return formatToolError("ORBS_SWAP_ERROR", String(e3));
+  }
+}
+async function orbsSwapStatus(params) {
+  const v = validateInput(orbsSwapStatusSchema, params);
+  if (!v.success) return v.error;
+  const { chainId, sessionId, user, maxAttempts } = v.data;
+  try {
+    const result = await pollSwapStatus({
+      chainId,
+      sessionId,
+      user,
+      maxAttempts: maxAttempts ?? 15
+    });
+    return formatToolResponse(result);
+  } catch (e3) {
+    return formatToolError("ORBS_STATUS_ERROR", String(e3));
+  }
+}
+async function orbsSwap(params) {
+  const v = validateInput(orbsSwapSchema, params);
+  if (!v.success) return v.error;
+  const { chainId, fromToken, toToken, inAmount } = v.data;
+  if (!isLiquidityHubSupported(chainId)) {
+    return formatToolError("CHAIN_NOT_SUPPORTED", getLiquidityHubError(chainId));
+  }
+  return executeWrite({
+    toolName: "orbs_swap",
+    description: `Orbs Liquidity Hub swap: ${inAmount} of ${fromToken} \u2192 ${toToken} on chain ${chainId}`,
+    params: { ...v.data },
+    executor: executeOrbsSwapNow
+  });
+}
+async function executeOrbsTwapNow(params) {
+  const chainId = resolveChainId(params);
+  const chunks = Number(params.chunks ?? 5);
+  const fillDelay = Number(params.fillDelay ?? 300);
+  try {
+    const account = getActiveAccount();
+    const durationSeconds = chunks * fillDelay * 2;
+    const prepared = prepareTwapOrder({
+      chainId,
+      srcToken: params.srcToken,
+      dstToken: params.dstToken,
+      srcAmount: params.srcAmount,
+      chunks,
+      fillDelaySeconds: fillDelay,
+      durationSeconds,
+      account: account.address
+    });
+    if (!account.signTypedData) {
+      return formatToolError("WALLET_ERROR", "Active account does not support EIP-712 signing");
+    }
+    const signature = await account.signTypedData({
+      domain: prepared.domain,
+      types: prepared.types,
+      primaryType: prepared.primaryType,
+      message: prepared.order
+    });
+    const { v, r, s: s3 } = splitSignature(signature);
+    const order = await submitSignedOrder(prepared.order, { v, r, s: s3 });
+    return formatToolResponse({
+      orderId: order.id,
+      status: order.status,
+      txHash: order.txHash
+    });
+  } catch (e3) {
+    return formatToolError("ORBS_TWAP_ERROR", String(e3));
+  }
+}
+async function orbsPlaceTwap(params) {
+  const v = validateInput(orbsPlaceTwapSchema, params);
+  if (!v.success) return v.error;
+  const { chainId, srcToken, dstToken, srcAmount, chunks, fillDelay } = v.data;
+  if (!isTwapSupported(chainId)) {
+    return formatToolError("CHAIN_NOT_SUPPORTED", getTwapError(chainId));
+  }
+  return executeWrite({
+    toolName: "orbs_place_twap",
+    description: `dTWAP order: ${srcAmount} of ${srcToken} \u2192 ${dstToken}, ${chunks} chunks, ${fillDelay}s delay on chain ${chainId}`,
+    params: { ...v.data },
+    executor: executeOrbsTwapNow
+  });
+}
+async function executeOrbsLimitNow(params) {
+  const chainId = resolveChainId(params);
+  try {
+    const account = getActiveAccount();
+    const expirySeconds = Number(params.expiry ?? 86400);
+    const prepared = prepareTwapOrder({
+      chainId,
+      srcToken: params.srcToken,
+      dstToken: params.dstToken,
+      srcAmount: params.srcAmount,
+      chunks: 1,
+      fillDelaySeconds: 0,
+      durationSeconds: expirySeconds,
+      account: account.address,
+      dstMinAmountPerTrade: params.dstMinAmount
+    });
+    if (!account.signTypedData) {
+      return formatToolError("WALLET_ERROR", "Active account does not support EIP-712 signing");
+    }
+    const signature = await account.signTypedData({
+      domain: prepared.domain,
+      types: prepared.types,
+      primaryType: prepared.primaryType,
+      message: prepared.order
+    });
+    const { v, r, s: s3 } = splitSignature(signature);
+    const order = await submitSignedOrder(prepared.order, { v, r, s: s3 });
+    return formatToolResponse({
+      orderId: order.id,
+      status: order.status,
+      txHash: order.txHash
+    });
+  } catch (e3) {
+    return formatToolError("ORBS_LIMIT_ERROR", String(e3));
+  }
+}
+async function orbsPlaceLimit(params) {
+  const v = validateInput(orbsPlaceLimitSchema, params);
+  if (!v.success) return v.error;
+  const { chainId, srcToken, dstToken, srcAmount, dstMinAmount } = v.data;
+  if (!isTwapSupported(chainId)) {
+    return formatToolError("CHAIN_NOT_SUPPORTED", getTwapError(chainId));
+  }
+  return executeWrite({
+    toolName: "orbs_place_limit",
+    description: `dLIMIT order: ${srcAmount} of ${srcToken} \u2192 ${dstToken}, min output ${dstMinAmount} on chain ${chainId}`,
+    params: { ...v.data },
+    executor: executeOrbsLimitNow
+  });
+}
+async function orbsListOrders(params) {
+  const v = validateInput(orbsListOrdersSchema, params);
+  if (!v.success) return v.error;
+  const { chainId } = v.data;
+  if (!isTwapSupported(chainId)) {
+    return formatToolError("CHAIN_NOT_SUPPORTED", getTwapError(chainId));
+  }
+  const walletState = getWalletState();
+  if (!walletState.address) {
+    return formatToolError(
+      "WALLET_READ_ONLY",
+      "orbs_list_orders requires an active wallet with an address."
+    );
+  }
+  try {
+    const orders = await listOrders(chainId, walletState.address);
+    return formatToolResponse({
+      count: orders.length,
+      orders: orders.map((o2) => ({
+        id: o2.id,
+        type: o2.type,
+        status: o2.status,
+        srcToken: o2.srcTokenAddress,
+        dstToken: o2.dstTokenAddress,
+        srcAmount: o2.srcAmount,
+        progress: o2.progress,
+        createdAt: o2.createdAt
+      }))
+    });
+  } catch (e3) {
+    return formatToolError("ORBS_LIST_ERROR", String(e3));
+  }
+}
+function getOrbsToolDefinitions() {
+  const tools = [
+    {
+      name: "orbs_get_quote",
+      description: "Get a quote from Orbs Liquidity Hub for same-chain aggregated swap. Requires token addresses \u2014 use resolve_token first to get addresses.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          chainId: {
+            type: "number",
+            description: "Chain ID (supported: 137, 56, 8453, 59144, 81457, 42161)"
+          },
+          fromToken: { type: "string", description: "Source token address" },
+          toToken: {
+            type: "string",
+            description: "Destination token address"
+          },
+          inAmount: {
+            type: "string",
+            description: "Input amount in wei"
+          },
+          slippage: {
+            type: "number",
+            description: "Slippage tolerance (0.5 = 0.5%)"
+          }
+        },
+        required: ["chainId", "fromToken", "toToken", "inAmount"]
+      },
+      handler: orbsGetQuote
+    },
+    {
+      name: "orbs_swap",
+      description: "Execute a same-chain swap via Orbs Liquidity Hub (write, confirmation-gated). Supported chains: 137 (Polygon), 56 (BSC), 8453 (Base), 59144 (Linea), 81457 (Blast), 42161 (Arbitrum). Requires token addresses \u2014 use resolve_token first.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          chainId: { type: "number" },
+          fromToken: { type: "string" },
+          toToken: { type: "string" },
+          inAmount: { type: "string" },
+          slippage: { type: "number" }
+        },
+        required: ["chainId", "fromToken", "toToken", "inAmount"]
+      },
+      handler: orbsSwap
+    },
+    {
+      name: "orbs_place_twap",
+      description: "Place a dTWAP (time-weighted average price) order (write, confirmation-gated)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          chainId: { type: "number" },
+          srcToken: { type: "string" },
+          dstToken: { type: "string" },
+          srcAmount: {
+            type: "string",
+            description: "Total amount to swap in wei"
+          },
+          chunks: {
+            type: "number",
+            description: "Number of equal chunks"
+          },
+          fillDelay: {
+            type: "number",
+            description: "Delay between fills in seconds"
+          }
+        },
+        required: ["chainId", "srcToken", "dstToken", "srcAmount", "chunks", "fillDelay"]
+      },
+      handler: orbsPlaceTwap
+    },
+    {
+      name: "orbs_place_limit",
+      description: "Place a dLIMIT order (write, confirmation-gated)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          chainId: { type: "number" },
+          srcToken: { type: "string" },
+          dstToken: { type: "string" },
+          srcAmount: { type: "string" },
+          dstMinAmount: {
+            type: "string",
+            description: "Minimum output amount (the limit price)"
+          },
+          expiry: {
+            type: "number",
+            description: "Order expiry in seconds from now"
+          }
+        },
+        required: ["chainId", "srcToken", "dstToken", "srcAmount", "dstMinAmount"]
+      },
+      handler: orbsPlaceLimit
+    },
+    {
+      name: "orbs_swap_status",
+      description: "Check the status of a pending Orbs Liquidity Hub swap",
+      inputSchema: {
+        type: "object",
+        properties: {
+          chainId: { type: "number", description: "Chain ID" },
+          sessionId: {
+            type: "string",
+            description: "Session ID from orbs_swap response"
+          },
+          user: {
+            type: "string",
+            description: "User wallet address"
+          },
+          maxAttempts: {
+            type: "number",
+            description: "Max poll attempts (default 15, 2s each = 30s)"
+          }
+        },
+        required: ["chainId", "sessionId", "user"]
+      },
+      handler: orbsSwapStatus
+    },
+    {
+      name: "orbs_list_orders",
+      description: "List open TWAP/dLIMIT orders for active wallet",
+      inputSchema: {
+        type: "object",
+        properties: {
+          chainId: { type: "number" }
+        },
+        required: ["chainId"]
+      },
+      handler: orbsListOrders
+    },
+    ...getDsltpToolDefinitions()
+  ];
+  return tools;
+}
+function registerOrbsExecutors() {
+  registerExecutor("orbs_swap", executeOrbsSwapNow);
+  registerExecutor("orbs_place_twap", executeOrbsTwapNow);
+  registerExecutor("orbs_place_limit", executeOrbsLimitNow);
+}
+
+// src/goat/dispatch.ts
+var RESTRICTED_PLUGIN_CHAINS = {
+  uniswap: [1, 137, 43114, 8453, 10, 42161, 42220],
+  balancer: [34443, 8453, 137, 100, 42161, 43114, 10]
+};
+function findRestrictedPlugin(toolName) {
+  const lowerName = toolName.toLowerCase();
+  for (const pluginKey of Object.keys(RESTRICTED_PLUGIN_CHAINS)) {
+    if (lowerName.startsWith(pluginKey.toLowerCase())) {
+      return pluginKey;
+    }
+  }
+  return void 0;
+}
+async function dispatchGoatTool(toolName, params) {
+  const config = getConfig();
+  const chainId = typeof params.chainId === "number" ? params.chainId : config.chainId;
+  if (!isSupported(chainId)) {
+    return formatToolError("UNSUPPORTED_CHAIN", `Chain ${chainId} is not a known EVM chain`);
+  }
+  const pluginKey = findRestrictedPlugin(toolName);
+  if (pluginKey) {
+    const availableChains = RESTRICTED_PLUGIN_CHAINS[pluginKey];
+    if (!availableChains.includes(chainId)) {
+      return formatToolError(
+        "TOOL_UNAVAILABLE_ON_CHAIN",
+        `${toolName} is not available on chain ${chainId}. Available on chains: ${availableChains.join(", ")}`,
+        { availableChainIds: availableChains }
+      );
+    }
+  }
+  const snapshot = await goatProvider.getOrBuildSnapshot(chainId);
+  if (!snapshot) {
+    return formatToolError(
+      "CHAIN_INIT_FAILED",
+      `Failed to initialize GOAT tools for chain ${chainId}`
+    );
+  }
+  const { chainId: _ignored, ...goatParams } = params;
+  try {
+    const result = await snapshot.toolHandler(toolName, goatParams);
+    return result;
+  } catch (e3) {
+    return formatToolError("GOAT_TOOL_ERROR", String(e3));
+  }
+}
+
+// src/tools/utility/index.ts
+var _health = null;
+var _totalToolCount = 0;
+function setHealthStatus(health, totalToolCount) {
+  _health = health;
+  _totalToolCount = totalToolCount;
+}
+async function serverStatus() {
+  try {
+    const wallet = getWalletState();
+    const backends = _health ? {
+      blockscout: _health.blockscout.status,
+      etherscan: _health.etherscan.status,
+      evm: _health.evm.status,
+      goat: _health.goat.status,
+      lifi: _health.lifi.status,
+      orbs: _health.orbs.status
+    } : {
+      blockscout: "not_initialized",
+      etherscan: "not_initialized",
+      evm: "not_initialized",
+      goat: "not_initialized",
+      lifi: "not_initialized",
+      orbs: "not_initialized"
+    };
+    return formatToolResponse({
+      walletMode: wallet.mode,
+      activeChainId: wallet.chainId,
+      confirmWrites: confirmationQueue.enabled,
+      backends,
+      toolCount: _totalToolCount
+    });
+  } catch (err) {
+    return formatToolError("STATUS_FAILED", err instanceof Error ? err.message : "Unknown error");
+  }
+}
+var INTEGRATION_CHAINS = /* @__PURE__ */ new Set([
+  ...LIQUIDITY_HUB_CHAINS,
+  ...Object.values(RESTRICTED_PLUGIN_CHAINS).flat()
+]);
+async function listSupportedChains() {
+  try {
+    const chains = [...INTEGRATION_CHAINS].map((id) => {
+      const chain = getChainById(id);
+      if (!chain) return null;
+      return { id: chain.id, name: chain.name, nativeCurrency: chain.nativeCurrency };
+    }).filter((c4) => c4 !== null);
+    return formatToolResponse({
+      note: "Any EVM chain supported by viem works for basic operations (ERC-20, ERC-721, ENS). Chains listed below have enhanced integration (DEX swaps, bridging, Orbs).",
+      chains
+    });
+  } catch (e3) {
+    return formatToolError("CHAINS_UNAVAILABLE", String(e3));
+  }
+}
+
+// src/tools/wallet/index.ts
+import {
+  english,
+  generateMnemonic,
+  generatePrivateKey as generatePrivateKey3,
+  mnemonicToAccount as mnemonicToAccount2,
+  privateKeyToAccount as privateKeyToAccount3
+} from "viem/accounts";
+
+// src/tools/wallet/schemas.ts
+import { z as z3 } from "zod";
+var walletFromMnemonicSchema = z3.object({
+  mnemonic: z3.string({ required_error: "mnemonic is required" }).min(1, "mnemonic must not be empty"),
+  accountIndex: z3.number().optional(),
+  addressIndex: z3.number().optional()
+});
+var walletDeriveAddressesSchema = z3.object({
+  mnemonic: z3.string({ required_error: "mnemonic is required" }).min(1, "mnemonic must not be empty"),
+  count: z3.number().min(1).max(20).optional()
+});
+var walletActivateSchema = z3.object({
+  privateKey: z3.string().optional(),
+  mnemonic: z3.string().optional(),
+  accountIndex: z3.number().optional(),
+  addressIndex: z3.number().optional()
+}).refine((data) => data.privateKey || data.mnemonic, {
+  message: "Either privateKey or mnemonic must be provided"
+});
+var walletSetConfirmationSchema = z3.object({
+  enabled: z3.boolean({ required_error: "enabled is required" })
+});
+var transactionConfirmSchema = z3.object({
+  id: z3.string({ required_error: "id is required" }).min(1, "id must not be empty")
+});
+var transactionDenySchema = transactionConfirmSchema;
+
+// src/tools/wallet/index.ts
+async function walletGenerate() {
+  try {
+    const key = generatePrivateKey3();
+    const account = privateKeyToAccount3(key);
+    return formatToolResponse({
+      address: account.address,
+      privateKey: key,
+      warning: "Private key returned once. Never stored. Save it now."
+    });
+  } catch (err) {
+    return formatToolError(
+      "WALLET_GENERATE_FAILED",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+  }
+}
+async function walletGenerateMnemonic() {
+  try {
+    const mnemonic = generateMnemonic(english);
+    const account = mnemonicToAccount2(mnemonic);
+    return formatToolResponse({
+      mnemonic,
+      firstAddress: account.address,
+      derivationPath: "m/44'/60'/0'/0/0",
+      warning: "Mnemonic returned once. Never stored. Save it now."
+    });
+  } catch (err) {
+    return formatToolError(
+      "MNEMONIC_GENERATE_FAILED",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+  }
+}
+async function walletFromMnemonic(params) {
+  try {
+    const v = validateInput(walletFromMnemonicSchema, params);
+    if (!v.success) return v.error;
+    const { mnemonic, accountIndex = 0, addressIndex = 0 } = v.data;
+    const account = mnemonicToAccount2(mnemonic, {
+      accountIndex,
+      addressIndex
+    });
+    return formatToolResponse({
+      address: account.address,
+      derivationPath: `m/44'/60'/${accountIndex}'/0/${addressIndex}`
+    });
+  } catch (err) {
+    return formatToolError(
+      "MNEMONIC_RESOLVE_FAILED",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+  }
+}
+async function walletDeriveAddresses(params) {
+  try {
+    const v = validateInput(walletDeriveAddressesSchema, params);
+    if (!v.success) return v.error;
+    const { mnemonic, count = 5 } = v.data;
+    const addresses = Array.from({ length: count }, (_, i) => {
+      const account = mnemonicToAccount2(mnemonic, { addressIndex: i });
+      return {
+        index: i,
+        address: account.address,
+        derivationPath: `m/44'/60'/0'/0/${i}`
+      };
+    });
+    return formatToolResponse(addresses);
+  } catch (err) {
+    return formatToolError("DERIVE_FAILED", err instanceof Error ? err.message : "Unknown error");
+  }
+}
+async function walletGetActive() {
+  try {
+    const state = getWalletState();
+    return formatToolResponse({
+      address: state.address ?? getActiveAccount().address,
+      chainId: state.chainId,
+      mode: state.mode
+    });
+  } catch (err) {
+    return formatToolError(
+      "WALLET_STATE_FAILED",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+  }
+}
+async function walletActivate(params) {
+  try {
+    const v = validateInput(walletActivateSchema, params);
+    if (!v.success) return v.error;
+    const { privateKey, mnemonic, accountIndex, addressIndex } = v.data;
+    const state = await activateWallet({
+      privateKey,
+      mnemonic,
+      accountIndex,
+      addressIndex
+    });
+    return formatToolResponse({
+      address: state.address,
+      chainId: state.chainId,
+      mode: state.mode
+    });
+  } catch (err) {
+    return formatToolError(
+      "WALLET_ACTIVATE_FAILED",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+  }
+}
+async function walletDeactivate() {
+  try {
+    await deactivateWallet();
+    const state = getWalletState();
+    return formatToolResponse({
+      mode: state.mode,
+      message: "Wallet deactivated. Reverted to read-only ephemeral wallet."
+    });
+  } catch (err) {
+    return formatToolError(
+      "WALLET_DEACTIVATE_FAILED",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+  }
+}
+async function walletSetConfirmation(params) {
+  try {
+    const v = validateInput(walletSetConfirmationSchema, params);
+    if (!v.success) return v.error;
+    const { enabled } = v.data;
+    confirmationQueue.enabled = enabled;
+    return formatToolResponse({
+      confirmationRequired: confirmationQueue.enabled,
+      message: enabled ? "Write confirmation enabled. Transactions will require explicit confirmation." : "Write confirmation disabled. Transactions will execute immediately."
+    });
+  } catch (err) {
+    return formatToolError(
+      "SET_CONFIRMATION_FAILED",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+  }
+}
+async function transactionConfirm(params) {
+  try {
+    const walletState = getWalletState();
+    if (walletState.mode === "read-only") {
+      return formatToolError(
+        "WALLET_READ_ONLY",
+        "transaction_confirm requires an active wallet. Activate a wallet first."
+      );
+    }
+    const v = validateInput(transactionConfirmSchema, params);
+    if (!v.success) return v.error;
+    const { id } = v.data;
+    const result = confirmationQueue.confirm(id);
+    if (!result) {
+      return formatToolError("NOT_FOUND", `No pending operation with ID: ${id}`);
+    }
+    if (result.stale) {
+      confirmationQueue.complete(id);
+      return formatToolError(
+        "OPERATION_EXPIRED",
+        `Operation ${id} was confirmed after TTL expiry and will not be executed.`
+      );
+    }
+    if (result.operation.walletAddress && walletState.address && result.operation.walletAddress.toLowerCase() !== walletState.address.toLowerCase()) {
+      return formatToolError(
+        "WALLET_MISMATCH",
+        `Operation ${id} was queued for wallet ${result.operation.walletAddress} but active wallet is ${walletState.address}. Deny this operation and re-submit.`
+      );
+    }
+    const execResult = await result.operation.executor(result.operation.params);
+    confirmationQueue.complete(id);
+    return execResult;
+  } catch (err) {
+    return formatToolError("CONFIRM_FAILED", err instanceof Error ? err.message : "Unknown error");
+  }
+}
+async function transactionDeny(params) {
+  try {
+    const v = validateInput(transactionDenySchema, params);
+    if (!v.success) return v.error;
+    const { id } = v.data;
+    const removed = confirmationQueue.deny(id);
+    if (!removed) {
+      return formatToolError("NOT_FOUND", `No pending operation with ID: ${id}`);
+    }
+    return formatToolResponse({
+      denied: true,
+      id,
+      message: "Operation denied and removed from queue."
+    });
+  } catch (err) {
+    return formatToolError("DENY_FAILED", err instanceof Error ? err.message : "Unknown error");
+  }
+}
+async function transactionList() {
+  try {
+    confirmationQueue.pruneExpired();
+    const operations = confirmationQueue.list();
+    return formatToolResponse({
+      count: operations.length,
+      operations: operations.map((op) => ({
+        id: op.id,
+        type: op.type,
+        description: op.description,
+        createdAt: op.createdAt.toISOString(),
+        expiresIn: Math.max(0, op.ttlMs - (Date.now() - op.createdAt.getTime()))
+      }))
+    });
+  } catch (err) {
+    return formatToolError("LIST_FAILED", err instanceof Error ? err.message : "Unknown error");
+  }
+}
+
+// src/tools/register.ts
+function getWalletToolDefinitions() {
+  return [
+    {
+      name: "wallet_generate",
+      description: "Generate a new random Ethereum wallet. Returns address and private key once \u2014 never stored.",
+      inputSchema: { type: "object", properties: {} },
+      handler: () => walletGenerate()
+    },
+    {
+      name: "wallet_generate_mnemonic",
+      description: "Generate a new BIP-39 mnemonic phrase with its first derived address.",
+      inputSchema: { type: "object", properties: {} },
+      handler: () => walletGenerateMnemonic()
+    },
+    {
+      name: "wallet_from_mnemonic",
+      description: "Derive an address from a BIP-39 mnemonic at optional account/address index. Does NOT return private key.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          mnemonic: { type: "string", description: "BIP-39 mnemonic phrase" },
+          accountIndex: {
+            type: "number",
+            description: "BIP-44 account index (default 0)"
+          },
+          addressIndex: {
+            type: "number",
+            description: "BIP-44 address index (default 0)"
+          }
+        },
+        required: ["mnemonic"]
+      },
+      handler: (params) => walletFromMnemonic(params)
+    },
+    {
+      name: "wallet_derive_addresses",
+      description: "Derive multiple addresses from a mnemonic (1-20). Returns index, address, and derivation path.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          mnemonic: { type: "string", description: "BIP-39 mnemonic phrase" },
+          count: {
+            type: "number",
+            description: "Number of addresses to derive (1-20, default 5)"
+          }
+        },
+        required: ["mnemonic"]
+      },
+      handler: (params) => walletDeriveAddresses(params)
+    },
+    {
+      name: "wallet_get_active",
+      description: "Get the currently active wallet address, chain ID, and mode (private-key, mnemonic, or read-only).",
+      inputSchema: { type: "object", properties: {} },
+      handler: () => walletGetActive()
+    },
+    {
+      name: "wallet_activate",
+      description: "Activate a wallet from a private key or mnemonic. Persists to disk (mode 0600) and emits wallet-changed.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          privateKey: {
+            type: "string",
+            description: "Hex-encoded private key (0x-prefixed)"
+          },
+          mnemonic: {
+            type: "string",
+            description: "BIP-39 mnemonic phrase"
+          },
+          accountIndex: {
+            type: "number",
+            description: "BIP-44 account index (default 0, mnemonic only)"
+          },
+          addressIndex: {
+            type: "number",
+            description: "BIP-44 address index (default 0, mnemonic only)"
+          }
+        }
+      },
+      handler: (params) => walletActivate(params)
+    },
+    {
+      name: "wallet_deactivate",
+      description: "Deactivate the current wallet, delete persisted key file, and revert to read-only ephemeral mode.",
+      inputSchema: { type: "object", properties: {} },
+      handler: () => walletDeactivate()
+    },
+    {
+      name: "wallet_set_confirmation",
+      description: "Toggle write confirmation at runtime. When enabled, write operations are queued and require explicit confirmation.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          enabled: {
+            type: "boolean",
+            description: "true to require confirmation for writes, false to execute immediately"
+          }
+        },
+        required: ["enabled"]
+      },
+      handler: (params) => walletSetConfirmation(params)
+    }
+  ];
+}
+function getTransactionToolDefinitions() {
+  return [
+    {
+      name: "transaction_confirm",
+      description: "Confirm a pending operation by ID. Returns the operation details so the caller can execute it.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "UUID of the pending operation to confirm"
+          }
+        },
+        required: ["id"]
+      },
+      handler: (params) => transactionConfirm(params)
+    },
+    {
+      name: "transaction_deny",
+      description: "Deny and remove a pending operation by ID without executing it.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "UUID of the pending operation to deny"
+          }
+        },
+        required: ["id"]
+      },
+      handler: (params) => transactionDeny(params)
+    },
+    {
+      name: "transaction_list",
+      description: "List all pending operations awaiting confirmation. Automatically prunes expired entries.",
+      inputSchema: { type: "object", properties: {} },
+      handler: () => transactionList()
+    }
+  ];
+}
+function getUtilityToolDefinitions() {
+  return [
+    {
+      name: "server_status",
+      description: "Get current server status including wallet mode, active chain, confirmation setting, and backend health.",
+      inputSchema: { type: "object", properties: {} },
+      handler: () => serverStatus()
+    },
+    {
+      name: "list_supported_chains",
+      description: "List all supported EVM chains with their chain IDs, names, and native currencies.",
+      inputSchema: { type: "object", properties: {} },
+      handler: () => listSupportedChains()
+    }
+  ];
+}
+
+// src/tokens/registry.ts
+var WELL_KNOWN_TOKENS = {
+  // ── Ethereum Mainnet (1) ──────────────────────────────────────────
+  1: {
+    USDT: {
+      address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+      decimals: 6,
+      name: "Tether USD",
+      symbol: "USDT"
+    },
+    USDC: {
+      address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      decimals: 6,
+      name: "USD Coin",
+      symbol: "USDC"
+    },
+    WETH: {
+      address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    DAI: {
+      address: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+      decimals: 18,
+      name: "Dai Stablecoin",
+      symbol: "DAI"
+    },
+    WBTC: {
+      address: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+      decimals: 8,
+      name: "Wrapped BTC",
+      symbol: "WBTC"
+    },
+    LINK: {
+      address: "0x514910771AF9Ca656af840dff83E8264EcF986CA",
+      decimals: 18,
+      name: "Chainlink",
+      symbol: "LINK"
+    },
+    UNI: {
+      address: "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984",
+      decimals: 18,
+      name: "Uniswap",
+      symbol: "UNI"
+    },
+    AAVE: {
+      address: "0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9",
+      decimals: 18,
+      name: "Aave",
+      symbol: "AAVE"
+    }
+  },
+  // ── BNB Smart Chain (56) ──────────────────────────────────────────
+  56: {
+    USDT: {
+      address: "0x55d398326f99059fF775485246999027B3197955",
+      decimals: 18,
+      name: "Binance-Peg BSC-USD",
+      symbol: "USDT"
+    },
+    USDC: {
+      address: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+      decimals: 18,
+      name: "Binance-Peg USD Coin",
+      symbol: "USDC"
+    },
+    WBNB: {
+      address: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+      decimals: 18,
+      name: "Wrapped BNB",
+      symbol: "WBNB"
+    },
+    WETH: {
+      address: "0x2170Ed0880ac9A755fd29B2688956BD959F933F8",
+      decimals: 18,
+      name: "Binance-Peg Ethereum",
+      symbol: "WETH"
+    },
+    DAI: {
+      address: "0x1AF3F329e8BE154074D8769D1FFa4eE058B1DBc3",
+      decimals: 18,
+      name: "Binance-Peg Dai",
+      symbol: "DAI"
+    },
+    BTCB: {
+      address: "0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c",
+      decimals: 18,
+      name: "Binance-Peg BTCB",
+      symbol: "BTCB"
+    },
+    CAKE: {
+      address: "0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82",
+      decimals: 18,
+      name: "PancakeSwap",
+      symbol: "CAKE"
+    }
+  },
+  // ── Polygon (137) ─────────────────────────────────────────────────
+  137: {
+    USDT: {
+      address: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+      decimals: 6,
+      name: "Tether USD",
+      symbol: "USDT"
+    },
+    USDC: {
+      address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+      decimals: 6,
+      name: "USD Coin",
+      symbol: "USDC"
+    },
+    "USDC.E": {
+      address: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+      decimals: 6,
+      name: "Bridged USDC",
+      symbol: "USDC.e"
+    },
+    WETH: {
+      address: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    WMATIC: {
+      address: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+      decimals: 18,
+      name: "Wrapped Matic",
+      symbol: "WMATIC"
+    },
+    WPOL: {
+      address: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+      decimals: 18,
+      name: "Wrapped POL",
+      symbol: "WPOL"
+    },
+    DAI: {
+      address: "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063",
+      decimals: 18,
+      name: "Dai Stablecoin",
+      symbol: "DAI"
+    },
+    WBTC: {
+      address: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6",
+      decimals: 8,
+      name: "Wrapped BTC",
+      symbol: "WBTC"
+    },
+    LINK: {
+      address: "0x53E0bca35eC356BD5ddDFebbD1Fc0fD03FaBad39",
+      decimals: 18,
+      name: "Chainlink",
+      symbol: "LINK"
+    },
+    AAVE: {
+      address: "0xD6DF932A45C0f255f85145f286eA0b292B21C90B",
+      decimals: 18,
+      name: "Aave",
+      symbol: "AAVE"
+    }
+  },
+  // ── Arbitrum One (42161) ──────────────────────────────────────────
+  42161: {
+    USDT: {
+      address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+      decimals: 6,
+      name: "Tether USD",
+      symbol: "USDT"
+    },
+    USDC: {
+      address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+      decimals: 6,
+      name: "USD Coin",
+      symbol: "USDC"
+    },
+    "USDC.E": {
+      address: "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
+      decimals: 6,
+      name: "Bridged USDC",
+      symbol: "USDC.e"
+    },
+    WETH: {
+      address: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    DAI: {
+      address: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
+      decimals: 18,
+      name: "Dai Stablecoin",
+      symbol: "DAI"
+    },
+    WBTC: {
+      address: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f",
+      decimals: 8,
+      name: "Wrapped BTC",
+      symbol: "WBTC"
+    },
+    ARB: {
+      address: "0x912CE59144191C1204E64559FE8253a0e49E6548",
+      decimals: 18,
+      name: "Arbitrum",
+      symbol: "ARB"
+    },
+    LINK: {
+      address: "0xf97f4df75117a78c1A5a0DBb814Af92458539FB4",
+      decimals: 18,
+      name: "Chainlink",
+      symbol: "LINK"
+    }
+  },
+  // ── Optimism (10) ─────────────────────────────────────────────────
+  10: {
+    USDT: {
+      address: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58",
+      decimals: 6,
+      name: "Tether USD",
+      symbol: "USDT"
+    },
+    USDC: {
+      address: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+      decimals: 6,
+      name: "USD Coin",
+      symbol: "USDC"
+    },
+    "USDC.E": {
+      address: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
+      decimals: 6,
+      name: "Bridged USDC",
+      symbol: "USDC.e"
+    },
+    WETH: {
+      address: "0x4200000000000000000000000000000000000006",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    DAI: {
+      address: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
+      decimals: 18,
+      name: "Dai Stablecoin",
+      symbol: "DAI"
+    },
+    WBTC: {
+      address: "0x68f180fcCe6836688e9084f035309E29Bf0A2095",
+      decimals: 8,
+      name: "Wrapped BTC",
+      symbol: "WBTC"
+    },
+    OP: {
+      address: "0x4200000000000000000000000000000000000042",
+      decimals: 18,
+      name: "Optimism",
+      symbol: "OP"
+    },
+    LINK: {
+      address: "0x350a791Bfc2C21F9Ed5d10980Dad2e2638ffa7f6",
+      decimals: 18,
+      name: "Chainlink",
+      symbol: "LINK"
+    }
+  },
+  // ── Base (8453) ───────────────────────────────────────────────────
+  8453: {
+    USDC: {
+      address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      decimals: 6,
+      name: "USD Coin",
+      symbol: "USDC"
+    },
+    USDT: {
+      address: "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2",
+      decimals: 6,
+      name: "Tether USD",
+      symbol: "USDT"
+    },
+    WETH: {
+      address: "0x4200000000000000000000000000000000000006",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    DAI: {
+      address: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
+      decimals: 18,
+      name: "Dai Stablecoin",
+      symbol: "DAI"
+    },
+    CBBTC: {
+      address: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+      decimals: 8,
+      name: "Coinbase Wrapped BTC",
+      symbol: "cbBTC"
+    },
+    AERO: {
+      address: "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
+      decimals: 18,
+      name: "Aerodrome",
+      symbol: "AERO"
+    }
+  },
+  // ── Linea (59144) ─────────────────────────────────────────────────
+  59144: {
+    WETH: {
+      address: "0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    USDC: {
+      address: "0x176211869cA2b568f2A7D4EE941E073a821EE1ff",
+      decimals: 6,
+      name: "USDC",
+      symbol: "USDC"
+    },
+    USDT: {
+      address: "0xA219439258ca9da29E9Cc4cE5596924745e12B93",
+      decimals: 6,
+      name: "Tether USD",
+      symbol: "USDT"
+    },
+    DAI: {
+      address: "0x4AF15ec2A0BD43Db75dd04E62FAA3B8EF36b00d5",
+      decimals: 18,
+      name: "Dai Stablecoin",
+      symbol: "DAI"
+    },
+    WBTC: {
+      address: "0x3aAB2285ddcDdaD8edf438C1bAB47e1a9D05a9b4",
+      decimals: 8,
+      name: "Wrapped BTC",
+      symbol: "WBTC"
+    }
+  },
+  // ── Avalanche C-Chain (43114) ─────────────────────────────────────
+  43114: {
+    USDT: {
+      address: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+      decimals: 6,
+      name: "Tether USD",
+      symbol: "USDT"
+    },
+    USDC: {
+      address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+      decimals: 6,
+      name: "USD Coin",
+      symbol: "USDC"
+    },
+    WAVAX: {
+      address: "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7",
+      decimals: 18,
+      name: "Wrapped AVAX",
+      symbol: "WAVAX"
+    },
+    "WETH.E": {
+      address: "0x49D5c2BdFfac6CE2BFdB6640F4F80f226bc10bAB",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH.e"
+    },
+    WETH: {
+      address: "0x49D5c2BdFfac6CE2BFdB6640F4F80f226bc10bAB",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    DAI: {
+      address: "0xd586E7F844cEa2F87f50152665BCbc2C279D8d70",
+      decimals: 18,
+      name: "Dai Stablecoin",
+      symbol: "DAI"
+    },
+    "WBTC.E": {
+      address: "0x50b7545627a5162F82A992c33b87aDc75187B218",
+      decimals: 8,
+      name: "Wrapped BTC",
+      symbol: "WBTC.e"
+    },
+    WBTC: {
+      address: "0x50b7545627a5162F82A992c33b87aDc75187B218",
+      decimals: 8,
+      name: "Wrapped BTC",
+      symbol: "WBTC"
+    }
+  },
+  // ── Blast (81457) ─────────────────────────────────────────────────
+  81457: {
+    WETH: {
+      address: "0x4300000000000000000000000000000000000004",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    USDB: {
+      address: "0x4300000000000000000000000000000000000003",
+      decimals: 18,
+      name: "USDB",
+      symbol: "USDB"
+    },
+    BLAST: {
+      address: "0xb1a5700fA2358173Fe465e6eA4Ff52E36e88E2ad",
+      decimals: 18,
+      name: "Blast",
+      symbol: "BLAST"
+    }
+  },
+  // ── zkSync Era (324) ──────────────────────────────────────────────
+  324: {
+    USDT: {
+      address: "0x493257fD37EDB34451f62EDf8D2a0C418852bA4C",
+      decimals: 6,
+      name: "Tether USD",
+      symbol: "USDT"
+    },
+    USDC: {
+      address: "0x1d17CBcF0D6D143135aE902365D2E5e2A16538D4",
+      decimals: 6,
+      name: "USD Coin",
+      symbol: "USDC"
+    },
+    WETH: {
+      address: "0x5AEa5775959fBC2557Cc8789bC1bf90A239D9a91",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    WBTC: {
+      address: "0xBBeB516fb02a01611cBBE0453Fe3c580D7281011",
+      decimals: 8,
+      name: "Wrapped BTC",
+      symbol: "WBTC"
+    }
+  },
+  // ── Scroll (534352) ───────────────────────────────────────────────
+  534352: {
+    USDT: {
+      address: "0xf55BEC9cafDbE8730f096Aa55dad6D22d44099Df",
+      decimals: 6,
+      name: "Tether USD",
+      symbol: "USDT"
+    },
+    USDC: {
+      address: "0x06eFdBFf2a14a7c8E15944D1F4A48F9F95F663A4",
+      decimals: 6,
+      name: "USD Coin",
+      symbol: "USDC"
+    },
+    WETH: {
+      address: "0x5300000000000000000000000000000000000004",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    DAI: {
+      address: "0xcA77eB3fEFe3725Dc33bccB54eDEFc3D9f764f97",
+      decimals: 18,
+      name: "Dai Stablecoin",
+      symbol: "DAI"
+    },
+    WBTC: {
+      address: "0x3C1BCa5a656e69edCD0D4E36BEbb3FcDAcA60Cf1",
+      decimals: 8,
+      name: "Wrapped BTC",
+      symbol: "WBTC"
+    }
+  },
+  // ── Gnosis (100) ──────────────────────────────────────────────────
+  100: {
+    USDT: {
+      address: "0x4ECaBa5870353805a9F068101A40E0f32ed605C6",
+      decimals: 6,
+      name: "Tether USD",
+      symbol: "USDT"
+    },
+    USDC: {
+      address: "0xDDAfbb505ad214D7b80b1f830fcCc89B60fb7A83",
+      decimals: 6,
+      name: "USD Coin",
+      symbol: "USDC"
+    },
+    WETH: {
+      address: "0x6A023CCd1ff6F2045C3309768eAd9E68F978f6e1",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    },
+    WXDAI: {
+      address: "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d",
+      decimals: 18,
+      name: "Wrapped xDAI",
+      symbol: "WXDAI"
+    },
+    GNO: {
+      address: "0x9C58BAcC331c9aa871AFD802DB6379a98e80CEdb",
+      decimals: 18,
+      name: "Gnosis",
+      symbol: "GNO"
+    }
+  },
+  // ── Celo (42220) ──────────────────────────────────────────────────
+  42220: {
+    USDT: {
+      address: "0x48065fbBE25f71C9282ddf5e1cD6D6A887483D5e",
+      decimals: 6,
+      name: "Tether USD",
+      symbol: "USDT"
+    },
+    USDC: {
+      address: "0xcebA9300f2b948710d2653dD7B07f33A8B32118C",
+      decimals: 6,
+      name: "USD Coin",
+      symbol: "USDC"
+    },
+    CELO: {
+      address: "0x471EcE3750Da237f93B8E339c536989b8978a438",
+      decimals: 18,
+      name: "Celo",
+      symbol: "CELO"
+    }
+  },
+  // ── Mantle (5000) ─────────────────────────────────────────────────
+  5e3: {
+    USDT: {
+      address: "0x201EBa5CC46D216Ce6DC03F6a759e8E766e956aE",
+      decimals: 6,
+      name: "Tether USD",
+      symbol: "USDT"
+    },
+    USDC: {
+      address: "0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9",
+      decimals: 6,
+      name: "USD Coin",
+      symbol: "USDC"
+    },
+    WMNT: {
+      address: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8",
+      decimals: 18,
+      name: "Wrapped Mantle",
+      symbol: "WMNT"
+    },
+    WETH: {
+      address: "0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    }
+  },
+  // ── Mode (34443) ──────────────────────────────────────────────────
+  34443: {
+    USDT: {
+      address: "0xf0F161fDA2712DB8b566946122a5af183995e2eD",
+      decimals: 6,
+      name: "Tether USD",
+      symbol: "USDT"
+    },
+    USDC: {
+      address: "0xd988097fb8612cc24eeC14542bC03424c656005f",
+      decimals: 6,
+      name: "USD Coin",
+      symbol: "USDC"
+    },
+    WETH: {
+      address: "0x4200000000000000000000000000000000000006",
+      decimals: 18,
+      name: "Wrapped Ether",
+      symbol: "WETH"
+    }
+  }
+};
+function lookupToken(symbol, chainId) {
+  return WELL_KNOWN_TOKENS[chainId]?.[symbol.toUpperCase()];
+}
+function getChainTokens(chainId) {
+  return WELL_KNOWN_TOKENS[chainId];
+}
+
+// src/tokens/resolver.ts
+var NATIVE_ALIASES = {
+  1: { ETH: "WETH" },
+  56: { BNB: "WBNB" },
+  137: { MATIC: "WMATIC", POL: "WMATIC" },
+  42161: { ETH: "WETH" },
+  10: { ETH: "WETH" },
+  8453: { ETH: "WETH" },
+  59144: { ETH: "WETH" },
+  43114: { AVAX: "WAVAX" },
+  81457: { ETH: "WETH" },
+  324: { ETH: "WETH" },
+  534352: { ETH: "WETH" },
+  100: { XDAI: "WXDAI" },
+  5e3: { MNT: "WMNT" },
+  34443: { ETH: "WETH" }
+};
+async function resolveToken(symbol, chainId) {
+  const entry = lookupToken(symbol, chainId);
+  if (entry) {
+    return { ...entry, chainId, source: "registry" };
+  }
+  const upperSymbol = symbol.toUpperCase();
+  const chainAliases = NATIVE_ALIASES[chainId];
+  if (chainAliases) {
+    const wrappedSymbol = chainAliases[upperSymbol];
+    if (wrappedSymbol) {
+      const wrappedEntry = lookupToken(wrappedSymbol, chainId);
+      if (wrappedEntry) {
+        return {
+          ...wrappedEntry,
+          chainId,
+          source: "registry",
+          note: `${upperSymbol} is a native token; resolved to its wrapped equivalent ${wrappedSymbol}.`
+        };
+      }
+    }
+  }
+  return resolveViaDexScreener(symbol, chainId);
+}
+function listTokens(chainId) {
+  const tokens = getChainTokens(chainId);
+  if (!tokens) return [];
+  return Object.values(tokens);
+}
+var DEXSCREENER_CHAIN_SLUGS = {
+  1: "ethereum",
+  56: "bsc",
+  137: "polygon",
+  42161: "arbitrum",
+  10: "optimism",
+  8453: "base",
+  59144: "linea",
+  43114: "avalanche",
+  81457: "blast",
+  324: "zksync",
+  534352: "scroll",
+  100: "gnosis",
+  42220: "celo",
+  5e3: "mantle",
+  34443: "mode"
+};
+async function resolveViaDexScreener(symbol, chainId) {
+  const chainSlug = DEXSCREENER_CHAIN_SLUGS[chainId];
+  if (!chainSlug) return null;
+  try {
+    const response = await fetch(
+      `https://api.dexscreener.com/latest/dex/search?q=${encodeURIComponent(symbol)}`
+    );
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (!data.pairs?.length) return null;
+    const upperSymbol = symbol.toUpperCase();
+    const candidates = data.pairs.filter((p2) => p2.chainId === chainSlug).flatMap((p2) => {
+      const matches = [];
+      if (p2.baseToken.symbol.toUpperCase() === upperSymbol) {
+        matches.push({ ...p2.baseToken, liquidity: p2.liquidity?.usd ?? 0 });
+      }
+      if (p2.quoteToken.symbol.toUpperCase() === upperSymbol) {
+        matches.push({ ...p2.quoteToken, liquidity: p2.liquidity?.usd ?? 0 });
+      }
+      return matches;
+    });
+    if (!candidates.length) return null;
+    candidates.sort((a2, b) => b.liquidity - a2.liquidity);
+    const best = candidates[0];
+    const chain = getChainById(chainId);
+    const decimals = await fetchDecimals(best.address, chainId, chain);
+    if (decimals === null) {
+      process.stderr.write(
+        `[tokens] Could not fetch decimals for ${best.symbol} (${best.address}) on chain ${chainId} \u2014 refusing to resolve
+`
+      );
+      return null;
+    }
+    return {
+      address: best.address,
+      decimals,
+      name: best.name,
+      symbol: best.symbol,
+      chainId,
+      source: "dexscreener"
+    };
+  } catch (e3) {
+    process.stderr.write(`[tokens] DexScreener fallback failed: ${e3}
+`);
+    return null;
+  }
+}
+async function fetchDecimals(tokenAddress, _chainId, chain) {
+  const rpcUrl = chain?.rpcUrls?.default?.http?.[0];
+  if (!rpcUrl) return null;
+  try {
+    const response = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "eth_call",
+        params: [{ to: tokenAddress, data: "0x313ce567" }, "latest"]
+      })
+    });
+    if (!response.ok) return null;
+    const result = await response.json();
+    if (result.result && result.result !== "0x") {
+      const decimals = Number.parseInt(result.result, 16);
+      if (decimals < 0 || decimals > 77 || !Number.isFinite(decimals)) {
+        return null;
+      }
+      return decimals;
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/tools/tokens/schemas.ts
+import { z as z4 } from "zod";
+var resolveTokenSchema = z4.object({
+  symbol: z4.string({ required_error: "symbol is required" }),
+  chainId: z4.number({ required_error: "chainId is required" })
+});
+var listChainTokensSchema = z4.object({
+  chainId: z4.number({ required_error: "chainId is required" })
+});
+
+// src/tools/tokens/index.ts
+async function handleResolveToken(params) {
+  const v = validateInput(resolveTokenSchema, params);
+  if (!v.success) return v.error;
+  const { symbol, chainId } = v.data;
+  const chain = getChainById(chainId);
+  if (!chain) {
+    return formatToolError("UNKNOWN_CHAIN", `Chain ${chainId} is not a known EVM chain`);
+  }
+  const result = await resolveToken(symbol, chainId);
+  if (!result) {
+    const available = listTokens(chainId);
+    const knownSymbols = available.map((t2) => t2.symbol).join(", ");
+    return formatToolError(
+      "TOKEN_NOT_FOUND",
+      `Token '${symbol}' not found on ${chain.name} (${chainId}). Known tokens: ${knownSymbols || "none"}`
+    );
+  }
+  return formatToolResponse(result);
+}
+function handleListTokens(params) {
+  const v = validateInput(listChainTokensSchema, params);
+  if (!v.success) return v.error;
+  const { chainId } = v.data;
+  const chain = getChainById(chainId);
+  if (!chain) {
+    return formatToolError("UNKNOWN_CHAIN", `Chain ${chainId} is not a known EVM chain`);
+  }
+  const tokens = listTokens(chainId);
+  return formatToolResponse({
+    chainId,
+    chainName: chain.name,
+    tokens
+  });
+}
+function getTokenToolDefinitions() {
+  return [
+    {
+      name: "resolve_token",
+      description: "Resolve a token symbol (e.g. 'USDT', 'WBNB') to its contract address and decimals on a specific chain. Uses a built-in registry of verified canonical addresses for major tokens with DexScreener fallback. ALWAYS call this first when you need a token address \u2014 do NOT use blockscout_lookup_token_by_symbol or get_token_info_by_symbol.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: {
+            type: "string",
+            description: "Token symbol (e.g. 'USDT', 'USDC', 'WETH', 'WBNB', 'DAI')"
+          },
+          chainId: {
+            type: "number",
+            description: "EVM chain ID (e.g. 1=Ethereum, 56=BSC, 137=Polygon, 8453=Base, 59144=Linea, 42161=Arbitrum, 10=Optimism)"
+          }
+        },
+        required: ["symbol", "chainId"]
+      },
+      handler: (params) => handleResolveToken(params)
+    },
+    {
+      name: "list_chain_tokens",
+      description: "List all well-known tokens available in the built-in registry for a specific chain. Returns symbol, address, decimals, and name for each token.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          chainId: {
+            type: "number",
+            description: "EVM chain ID"
+          }
+        },
+        required: ["chainId"]
+      },
+      handler: (params) => Promise.resolve(handleListTokens(params))
+    }
+  ];
+}
+
+// src/upstream/remote-mcp-adapter.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var RemoteMcpAdapter = class {
+  name;
+  client;
+  tools = [];
+  routeMap = /* @__PURE__ */ new Map();
+  health;
+  prefix;
+  url;
+  constructor(config) {
+    this.name = config.name;
+    this.prefix = config.prefix;
+    this.url = config.url;
+    this.client = new Client({ name: "web3agent", version: VERSION });
+    this.health = {
+      name: config.name,
+      status: config.initialStatus ?? "unavailable",
+      message: config.initialMessage ?? "Not initialized"
+    };
+  }
+  shouldSkipInit() {
+    return false;
+  }
+  getTransportOptions() {
+    return void 0;
+  }
+  async postConnect() {
+  }
+  filterTools(tools) {
+    return tools;
+  }
+  transformDescription(description) {
+    return description;
+  }
+  async initialize() {
+    if (this.shouldSkipInit()) return;
+    const endpoint = new URL(this.url);
+    const requestInit = this.getTransportOptions();
+    let connected = false;
+    for (const TransportClass of [StreamableHTTPClientTransport, SSEClientTransport]) {
+      try {
+        const transport = requestInit ? new TransportClass(endpoint, { requestInit }) : new TransportClass(endpoint);
+        await this.client.connect(transport);
+        connected = true;
+        break;
+      } catch (e3) {
+        process.stderr.write(`[${this.name}] ${TransportClass.name} transport failed: ${e3}
+`);
+        try {
+          await this.client.close();
+        } catch {
+        }
+        this.client = new Client({ name: "web3agent", version: VERSION });
+      }
+    }
+    if (!connected) {
+      this.health = {
+        name: this.name,
+        status: "degraded",
+        message: `Failed to connect to ${this.url} via StreamableHTTP and SSE`
+      };
+      return;
+    }
+    try {
+      await this.postConnect();
+      const { tools: rawTools } = await this.client.listTools();
+      const filtered = this.filterTools(rawTools);
+      this.tools = filtered.map((t2) => {
+        const prefixedName = `${this.prefix}_${t2.name}`;
+        this.routeMap.set(prefixedName, t2.name);
+        return {
+          ...t2,
+          name: prefixedName,
+          description: this.transformDescription(t2.description ?? ""),
+          upstreamName: t2.name,
+          prefix: this.prefix
+        };
+      });
+      this.health = {
+        name: this.name,
+        status: "ok",
+        message: `Connected with ${this.tools.length} tools`,
+        toolCount: this.tools.length
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Unknown post-connect error";
+      this.health = {
+        name: this.name,
+        status: "degraded",
+        message: `Connected but post-connect/listTools failed: ${msg}`
+      };
+    }
+  }
+  getTools() {
+    return this.tools;
+  }
+  async callTool(name, args) {
+    const originalName = this.routeMap.get(name);
+    if (!originalName) {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+    return this.client.callTool({ name: originalName, arguments: args });
+  }
+  getHealth() {
+    return this.health;
+  }
+  async shutdown() {
+    try {
+      await this.client.close();
+    } catch (e3) {
+      process.stderr.write(`[${this.name}] Failed to close client during shutdown: ${e3}
+`);
+    }
+  }
+};
+
+// src/upstream/blockscout/adapter.ts
+var BOOTSTRAP_TOOL = "__unlock_blockchain_analysis__";
+var CHAIN_SUPPORT_NOTE = " NOTE: Blockscout hosted instances do NOT support all chains. Supported: Ethereum (1), Polygon (137), Arbitrum (42161), Optimism (10), Base (8453), Gnosis (100), Scroll (534352), zkSync Era (324). NOT supported: BSC (56), Linea (59144), Avalanche (43114), Blast (81457), Mantle (5000), Mode (34443). For token lookups, prefer resolve_token tool instead.";
+var BlockscoutAdapter = class extends RemoteMcpAdapter {
+  constructor(url = BLOCKSCOUT_DEFAULT_URL) {
+    super({ name: "blockscout", prefix: "blockscout", url });
+  }
+  async postConnect() {
+    await this.client.callTool({ name: BOOTSTRAP_TOOL, arguments: {} });
+  }
+  filterTools(tools) {
+    return tools.filter((t2) => t2.name !== BOOTSTRAP_TOOL);
+  }
+  transformDescription(desc) {
+    return desc + CHAIN_SUPPORT_NOTE;
+  }
+};
+
+// src/upstream/etherscan/adapter.ts
+var EtherscanAdapter = class extends RemoteMcpAdapter {
+  apiKey;
+  constructor(url = ETHERSCAN_DEFAULT_URL, apiKey) {
+    super({
+      name: "etherscan",
+      prefix: "etherscan",
+      url,
+      initialStatus: apiKey ? "unavailable" : "not_configured",
+      initialMessage: apiKey ? "Not initialized" : "No API key provided (ETHERSCAN_API_KEY)"
+    });
+    this.apiKey = apiKey;
+  }
+  shouldSkipInit() {
+    return !this.apiKey;
+  }
+  getTransportOptions() {
+    if (!this.apiKey) return void 0;
+    return { headers: { Authorization: `Bearer ${this.apiKey}` } };
+  }
+};
+
+// src/upstream/evm/adapter.ts
+import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+var PREFIX = "evm";
+async function buildEvmEnv() {
+  const env = {
+    PATH: process.env.PATH ?? "",
+    HOME: process.env.HOME ?? "",
+    TMPDIR: process.env.TMPDIR ?? "/tmp"
+  };
+  if (process.env.TERM) env.TERM = process.env.TERM;
+  if (process.env.NODE_ENV) env.NODE_ENV = process.env.NODE_ENV;
+  const walletKey = await getPersistedKeyForSubprocess();
+  if (walletKey) env.EVM_PRIVATE_KEY = walletKey;
+  if (process.env.WALLET_ACCOUNT_INDEX) env.EVM_ACCOUNT_INDEX = process.env.WALLET_ACCOUNT_INDEX;
+  if (process.env.ETHERSCAN_API_KEY) env.ETHERSCAN_API_KEY = process.env.ETHERSCAN_API_KEY;
+  return env;
+}
+var EvmAdapter = class {
+  name = "evm";
+  client;
+  transport;
+  tools = [];
+  routeMap = /* @__PURE__ */ new Map();
+  health;
+  startedAt;
+  restartCount = 0;
+  restarting = false;
+  walletChangeHandler;
+  constructor() {
+    this.health = {
+      name: "evm",
+      status: "unavailable",
+      message: "Not initialized"
+    };
+  }
+  async initialize() {
+    await this.start();
+    this.walletChangeHandler = async (_state) => {
+      try {
+        await this.restart();
+      } catch (e3) {
+        process.stderr.write(`[evm] Restart after wallet change failed: ${e3}
+`);
+      }
+    };
+    walletEvents.on("wallet-changed", this.walletChangeHandler);
+  }
+  async start() {
+    try {
+      const whitelistedEnv = await buildEvmEnv();
+      this.transport = new StdioClientTransport({
+        command: "npx",
+        args: ["-y", "@mcpdotdirect/evm-mcp-server"],
+        env: whitelistedEnv
+      });
+      this.client = new Client2({
+        name: "web3agent-evm",
+        version: VERSION
+      });
+      await this.client.connect(this.transport);
+      this.startedAt = /* @__PURE__ */ new Date();
+      const result = await this.client.listTools();
+      this.tools = [];
+      this.routeMap.clear();
+      for (const tool of result.tools) {
+        const prefixed = `${PREFIX}_${tool.name}`;
+        this.routeMap.set(prefixed, tool.name);
+        this.tools.push({
+          ...tool,
+          name: prefixed,
+          upstreamName: tool.name,
+          prefix: PREFIX
+        });
+      }
+      const pid = this.transport.process?.pid ?? void 0;
+      this.health = {
+        name: "evm",
+        status: "ok",
+        message: `Running with ${this.tools.length} tools`,
+        toolCount: this.tools.length,
+        restartCount: this.restartCount,
+        pid,
+        uptimeMs: 0
+      };
+      process.stderr.write(
+        `[evm] Started with ${this.tools.length} tools (pid=${pid ?? "unknown"})
+`
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown startup error";
+      process.stderr.write(`[evm] Failed to start: ${message}
+`);
+      this.tools = [];
+      this.routeMap.clear();
+      this.health = {
+        name: "evm",
+        status: "degraded",
+        message: `Startup failed: ${message}`,
+        toolCount: 0,
+        restartCount: this.restartCount
+      };
+    }
+  }
+  async restart() {
+    if (this.restarting) return;
+    this.restarting = true;
+    try {
+      process.stderr.write("[evm] Restarting due to wallet change...\n");
+      try {
+        await this.client?.close();
+      } catch (e3) {
+        process.stderr.write(`[evm] Failed to close client during restart: ${e3}
+`);
+      }
+      this.killSubprocess();
+      this.restartCount++;
+      await this.start();
+      this.health.lastRestartAt = /* @__PURE__ */ new Date();
+      this.health.restartCount = this.restartCount;
+    } finally {
+      this.restarting = false;
+    }
+  }
+  killSubprocess() {
+    try {
+      const proc = this.transport?.process;
+      if (proc?.kill) {
+        proc.kill();
+      }
+    } catch (e3) {
+      process.stderr.write(`[evm] Failed to kill subprocess: ${e3}
+`);
+    }
+  }
+  getTools() {
+    return this.tools;
+  }
+  async callTool(name, args) {
+    const upstreamName = this.routeMap.get(name);
+    if (!upstreamName) {
+      throw new Error(`Unknown EVM tool: ${name}`);
+    }
+    if (this.restarting) {
+      throw new Error("EVM adapter is restarting due to wallet change, please retry");
+    }
+    if (this.health.status !== "ok") {
+      throw new Error(`EVM adapter is ${this.health.status}: ${this.health.message}`);
+    }
+    const result = await this.client.callTool({
+      name: upstreamName,
+      arguments: args
+    });
+    return result;
+  }
+  getHealth() {
+    if (this.startedAt && this.health.status === "ok") {
+      this.health.uptimeMs = Date.now() - this.startedAt.getTime();
+    }
+    return this.health;
+  }
+  async shutdown() {
+    if (this.walletChangeHandler) {
+      walletEvents.off("wallet-changed", this.walletChangeHandler);
+      this.walletChangeHandler = void 0;
+    }
+    try {
+      await this.client?.close();
+    } catch (e3) {
+      process.stderr.write(`[evm] Failed to close client during shutdown: ${e3}
+`);
+    }
+    this.killSubprocess();
+    this.health = {
+      name: "evm",
+      status: "unavailable",
+      message: "Shut down",
+      toolCount: 0
+    };
+    process.stderr.write("[evm] Shut down\n");
+  }
+};
+
+// src/runtime/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+function normalizeInputSchema(schema) {
+  const candidate = schema;
+  return {
+    ...candidate,
+    type: "object"
+  };
+}
+var ProxyServer = class {
+  constructor(blockscoutAdapter, etherscanAdapter, evmAdapter, goatProvider2) {
+    this.blockscoutAdapter = blockscoutAdapter;
+    this.etherscanAdapter = etherscanAdapter;
+    this.evmAdapter = evmAdapter;
+    this.goatProvider = goatProvider2;
+    this.server = new Server(
+      { name: "web3agent", version: VERSION },
+      { capabilities: { tools: {} } }
+    );
+    this.frameworkTools = [
+      ...getWalletToolDefinitions(),
+      ...getTransactionToolDefinitions(),
+      ...getUtilityToolDefinitions()
+    ];
+    this.lifiTools = getLifiToolDefinitions();
+    this.orbsTools = getOrbsToolDefinitions();
+    this.tokenTools = getTokenToolDefinitions();
+    this.goatToolNames = new Set(this.goatProvider.getAllToolNames());
+    this.rebuildDispatchMap();
+    this.registerHandlers();
+    this.registerWalletChangeNotification();
+  }
+  server;
+  frameworkTools;
+  lifiTools;
+  orbsTools;
+  tokenTools;
+  goatToolNames;
+  toolDispatch = /* @__PURE__ */ new Map();
+  walletChangeHandler;
+  rebuildDispatchMap() {
+    this.toolDispatch.clear();
+    for (const tool of this.blockscoutAdapter.getTools()) {
+      this.toolDispatch.set(
+        tool.name,
+        (args) => this.blockscoutAdapter.callTool(tool.name, args)
+      );
+    }
+    for (const tool of this.etherscanAdapter.getTools()) {
+      this.toolDispatch.set(
+        tool.name,
+        (args) => this.etherscanAdapter.callTool(tool.name, args)
+      );
+    }
+    for (const tool of this.evmAdapter.getTools()) {
+      this.toolDispatch.set(
+        tool.name,
+        (args) => this.evmAdapter.callTool(tool.name, args)
+      );
+    }
+    for (const tool of this.tokenTools) {
+      this.toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+    for (const name of this.goatToolNames) {
+      this.toolDispatch.set(name, (args) => dispatchGoatTool(name, args));
+    }
+    for (const tool of this.lifiTools) {
+      this.toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+    for (const tool of this.orbsTools) {
+      this.toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+    for (const tool of this.frameworkTools) {
+      this.toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+  }
+  registerHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: this.getAggregatedTools()
+    }));
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const name = request.params.name;
+      const args = request.params.arguments ?? {};
+      const handler = this.toolDispatch.get(name);
+      if (handler) {
+        return handler(args);
+      }
+      return formatToolError("UNKNOWN_TOOL", `Unknown tool: ${name}`);
+    });
+  }
+  getGoatTools() {
+    const snapshot = this.goatProvider.getReferenceSnapshot();
+    if (!snapshot) return [];
+    return snapshot.listOfTools.map((tool) => {
+      const schema = normalizeInputSchema(tool.inputSchema);
+      const properties = schema.properties ?? {};
+      properties.chainId = {
+        type: "number",
+        description: "Optional EVM chain ID to run this tool on (e.g. 1 for Ethereum, 8453 for Base, 9745 for Plasma). Defaults to the active wallet chain."
+      };
+      let description = tool.description;
+      const lowerName = tool.name.toLowerCase();
+      for (const [plugin, chains] of Object.entries(RESTRICTED_PLUGIN_CHAINS)) {
+        if (lowerName.startsWith(plugin)) {
+          description += ` Only available on chains: ${chains.join(", ")}.`;
+          break;
+        }
+      }
+      return {
+        name: tool.name,
+        description,
+        inputSchema: { ...schema, properties }
+      };
+    });
+  }
+  getAggregatedTools() {
+    return [
+      ...this.frameworkTools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: normalizeInputSchema(tool.inputSchema)
+      })),
+      ...this.getGoatTools(),
+      ...this.blockscoutAdapter.getTools(),
+      ...this.etherscanAdapter.getTools(),
+      ...this.evmAdapter.getTools(),
+      ...this.lifiTools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: normalizeInputSchema(tool.inputSchema)
+      })),
+      ...this.orbsTools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: normalizeInputSchema(tool.inputSchema)
+      })),
+      ...this.tokenTools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: normalizeInputSchema(tool.inputSchema)
+      }))
+    ];
+  }
+  registerWalletChangeNotification() {
+    this.walletChangeHandler = () => {
+      this.goatProvider.waitForRebuild().then(() => {
+        this.goatToolNames = new Set(this.goatProvider.getAllToolNames());
+        this.rebuildDispatchMap();
+        return this.server.notification({ method: "notifications/tools/list_changed" });
+      }).catch((e3) => {
+        process.stderr.write(`[web3agent] Failed to update tools after wallet change: ${e3}
+`);
+      });
+    };
+    walletEvents.on("wallet-changed", this.walletChangeHandler);
+  }
+  async shutdown() {
+    if (this.walletChangeHandler) {
+      walletEvents.off("wallet-changed", this.walletChangeHandler);
+      this.walletChangeHandler = void 0;
+    }
+    this.goatProvider.shutdown();
+    await this.goatProvider.waitForRebuild().catch(() => {
+    });
+    await Promise.allSettled([
+      this.blockscoutAdapter.shutdown(),
+      this.etherscanAdapter.shutdown(),
+      this.evmAdapter.shutdown()
+    ]);
+    await this.server.close().catch((e3) => {
+      process.stderr.write(`[web3agent] Failed to close MCP server: ${e3}
+`);
+    });
+  }
+  async connect(transport) {
+    await this.server.connect(transport);
+  }
+  async start() {
+    const transport = new StdioServerTransport();
+    await this.connect(transport);
+  }
+};
+
+// src/runtime/startup.ts
+async function startServer() {
+  let config;
+  try {
+    config = parseEnv(process.env);
+    setConfig(config);
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      process.stderr.write(`[web3agent] Invalid config ${error.field}: ${error.message}
+`);
+      process.exit(1);
+    }
+    throw error;
+  }
+  confirmationQueue.enabled = config.confirmWrites;
+  await initializeWallet({
+    chainId: config.chainId,
+    accountIndex: config.walletAccountIndex,
+    addressIndex: config.walletAddressIndex,
+    privateKey: config.privateKey,
+    mnemonic: config.mnemonic
+  });
+  walletEvents.on("wallet-changed", () => {
+    const flushed = confirmationQueue.flushAll();
+    if (flushed > 0) {
+      process.stderr.write(
+        `[web3agent] Wallet changed \u2014 flushed ${flushed} pending operation(s) from confirmation queue
+`
+      );
+    }
+  });
+  registerOrbsExecutors();
+  registerLifiExecutors();
+  await confirmationQueue.loadQueue();
+  const blockscoutAdapter = new BlockscoutAdapter(config.blockscoutMcpUrl);
+  const etherscanAdapter = new EtherscanAdapter(config.etherscanMcpUrl, config.etherscanApiKey);
+  const evmAdapter = new EvmAdapter();
+  const health = createDefaultHealthStatus();
+  try {
+    await blockscoutAdapter.initialize();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown initialization error";
+    health.blockscout.status = "degraded";
+    health.blockscout.message = message;
+    process.stderr.write(`[web3agent] Blockscout degraded: ${message}
+`);
+  }
+  try {
+    await etherscanAdapter.initialize();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown initialization error";
+    health.etherscan.status = "degraded";
+    health.etherscan.message = message;
+    process.stderr.write(`[web3agent] Etherscan degraded: ${message}
+`);
+  }
+  try {
+    await evmAdapter.initialize();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown initialization error";
+    health.evm.status = "degraded";
+    health.evm.message = message;
+    process.stderr.write(`[web3agent] EVM degraded: ${message}
+`);
+  }
+  await goatProvider.initialize({
+    zeroxApiKey: config.zeroxApiKey,
+    coingeckoApiKey: config.coingeckoApiKey,
+    rpcUrl: config.rpcUrl
+  });
+  initializeLifi(config.lifiApiKey);
+  const server = new ProxyServer(blockscoutAdapter, etherscanAdapter, evmAdapter, goatProvider);
+  const walletMode = getWalletState().mode;
+  const goatToolCount = goatProvider.getAllToolNames().length;
+  const blockscoutToolCount = blockscoutAdapter.getTools().length;
+  const etherscanToolCount = etherscanAdapter.getTools().length;
+  const evmToolCount = evmAdapter.getTools().length;
+  const lifiToolCount = getLifiToolDefinitions().length;
+  const orbsToolCount = getOrbsToolDefinitions().length;
+  const tokenToolCount = getTokenToolDefinitions().length;
+  const frameworkToolCount = getWalletToolDefinitions().length + getTransactionToolDefinitions().length + getUtilityToolDefinitions().length;
+  health.blockscout = blockscoutAdapter.getHealth();
+  health.etherscan = etherscanAdapter.getHealth();
+  health.evm = evmAdapter.getHealth();
+  health.goat = {
+    name: "goat",
+    status: "ok",
+    toolCount: goatToolCount,
+    message: `Loaded ${goatToolCount} tools`
+  };
+  health.lifi = {
+    name: "lifi",
+    status: "ok",
+    toolCount: lifiToolCount,
+    message: `Loaded ${lifiToolCount} tools`
+  };
+  health.orbs = {
+    name: "orbs",
+    status: "ok",
+    toolCount: orbsToolCount,
+    message: `Loaded ${orbsToolCount} tools`
+  };
+  const totalToolCount = frameworkToolCount + goatToolCount + blockscoutToolCount + etherscanToolCount + evmToolCount + lifiToolCount + orbsToolCount + tokenToolCount;
+  setHealthStatus(health, totalToolCount);
+  const degradedServices = [];
+  if (health.blockscout.status !== "ok") degradedServices.push("blockscout");
+  if (health.etherscan.status !== "ok" && health.etherscan.status !== "not_configured")
+    degradedServices.push("etherscan");
+  if (health.evm.status !== "ok") degradedServices.push("evm");
+  const report = createStartupReport({
+    health,
+    activeChainId: config.chainId,
+    walletMode,
+    confirmWrites: config.confirmWrites,
+    degradedServices,
+    totalToolCount
+  });
+  process.stderr.write(`${formatHealthSummary(report)}
+`);
+  process.stderr.write(
+    `[web3agent] Tool counts => framework:${frameworkToolCount}, goat:${goatToolCount}, blockscout:${blockscoutToolCount}, etherscan:${etherscanToolCount}, evm:${evmToolCount}, lifi:${lifiToolCount}, orbs:${orbsToolCount}, tokens:${tokenToolCount}
+`
+  );
+  let shuttingDown = false;
+  const gracefulShutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    process.stderr.write("[web3agent] Shutting down...\n");
+    await server.shutdown();
+    process.exit(0);
+  };
+  process.on("SIGTERM", gracefulShutdown);
+  process.on("SIGINT", gracefulShutdown);
+  await server.start();
+}
+export {
+  startServer
+};