web3agent 0.1.0 → 0.2.0

package/dist/chunk-BJUU5ESI.js

@@ -0,0 +1,1760 @@
+import {
+  createWalletClientForChain,
+  getActiveAccount,
+  getTransportForChain,
+  getWalletState,
+  walletEvents
+} from "./chunk-KPRIUALX.js";
+import {
+  getChainById,
+  getConfig,
+  isSupported,
+  parseEnv,
+  tryGetConfig
+} from "./chunk-7QEKU2RP.js";
+
+// src/api/errors.ts
+var Web3AgentError = class _Web3AgentError extends Error {
+  code;
+  details;
+  cause;
+  constructor(options) {
+    super(options.message);
+    this.name = "Web3AgentError";
+    this.code = options.code;
+    this.details = options.details;
+    this.cause = options.cause;
+  }
+  static fromUnknown(code, error, fallbackMessage = "Unknown error", details) {
+    if (error instanceof _Web3AgentError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      return new _Web3AgentError({
+        code,
+        message: error.message,
+        details,
+        cause: error
+      });
+    }
+    return new _Web3AgentError({
+      code,
+      message: typeof error === "string" ? error : fallbackMessage,
+      details,
+      cause: error
+    });
+  }
+};
+
+// 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/toolset.ts
+import { getTools } from "@goat-sdk/core";
+import { zodToJsonSchema } from "zod-to-json-schema";
+async function buildGoatTools(params) {
+  const plugins = params.pluginResult.plugins;
+  return getTools({
+    wallet: params.wallet,
+    plugins
+  });
+}
+function createGoatToolSnapshot(chainId, tools) {
+  return {
+    listOfTools: tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: zodToJsonSchema(tool.parameters)
+    })),
+    toolHandler: async (toolName, params) => {
+      const tool = tools.find((candidate) => candidate.name === toolName);
+      if (!tool) {
+        throw new Error(`Tool ${toolName} not found`);
+      }
+      const parsed = tool.parameters.parse(params ?? {});
+      const result = await tool.execute(parsed);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    },
+    chainId
+  };
+}
+
+// src/utils/errors.ts
+function toErrorBody(code, message, details) {
+  return {
+    error: code,
+    message,
+    ...details === void 0 ? {} : { details }
+  };
+}
+function formatToolError(code, message, details) {
+  const body = toErrorBody(code, message, details);
+  const structuredContent = {
+    ok: false,
+    error: {
+      code,
+      message,
+      ...details === void 0 ? {} : { details }
+    }
+  };
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(body)
+      }
+    ],
+    structuredContent,
+    isError: true
+  };
+}
+function formatToolResponse(data) {
+  const structuredContent = {
+    ok: true,
+    data
+  };
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof data === "string" ? data : JSON.stringify(data, null, 2)
+      }
+    ],
+    structuredContent,
+    isError: false
+  };
+}
+function formatToolErrorFromUnknown(fallbackCode, error, fallbackMessage = "Unknown error") {
+  if (error instanceof Web3AgentError) {
+    return formatToolError(error.code, error.message, error.details);
+  }
+  if (error instanceof Error) {
+    return formatToolError(fallbackCode, error.message);
+  }
+  return formatToolError(fallbackCode, typeof error === "string" ? error : fallbackMessage);
+}
+
+// src/goat/provider.ts
+import { viem } from "@goat-sdk/wallet-viem";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+var GoatProvider = class {
+  snapshots = /* @__PURE__ */ new Map();
+  pluginResult;
+  referenceSnapshot;
+  generation = 0;
+  runtimeConfig;
+  walletChangeHandler;
+  rebuildPromise = Promise.resolve();
+  async initialize(config) {
+    this.runtimeConfig = 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.runtimeConfig?.zeroxApiKey,
+        coingeckoApiKey: this.runtimeConfig?.coingeckoApiKey,
+        rpcUrl: this.runtimeConfig?.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 = generatePrivateKey();
+      account = privateKeyToAccount(ephemeralKey);
+    }
+    const walletClient = createWalletClientForChain(account, chainId, this.runtimeConfig);
+    const tools = await buildGoatTools({
+      wallet: viem(walletClient),
+      pluginResult: this.pluginResult
+    });
+    this.snapshots.set(chainId, createGoatToolSnapshot(chainId, tools));
+  }
+  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/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();
+  const sortedKeys = Object.keys(RESTRICTED_PLUGIN_CHAINS).sort((a2, b) => b.length - a2.length);
+  for (const pluginKey of sortedKeys) {
+    if (lowerName.startsWith(pluginKey.toLowerCase())) {
+      return pluginKey;
+    }
+  }
+  return void 0;
+}
+async function dispatchGoatTool(toolName, params, options) {
+  const config = options?.config ?? getConfig();
+  const activeGoatProvider = options?.goatProvider ?? goatProvider;
+  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 activeGoatProvider.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/operations/validation.ts
+import { isAddress, isHex } from "viem";
+function assertChainSupported(chainId) {
+  const chain = getChainById(chainId);
+  if (!chain) {
+    throw new Web3AgentError({
+      code: "CHAIN_NOT_SUPPORTED",
+      message: `Unsupported chain ID: ${chainId}`
+    });
+  }
+  return chain;
+}
+function assertHex(value, field) {
+  if (!isHex(value)) {
+    throw new Web3AgentError({
+      code: "INVALID_PARAMS",
+      message: `${field} must be a valid 0x-prefixed hex string`
+    });
+  }
+  return value;
+}
+function assertAddress(value, field) {
+  if (!isAddress(value)) {
+    throw new Web3AgentError({
+      code: "INVALID_PARAMS",
+      message: `${field} must be a valid EVM address`
+    });
+  }
+  return value;
+}
+function assertRecord(value, field, code = "INVALID_PARAMS") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Web3AgentError({
+      code,
+      message: `${field} must be an object`
+    });
+  }
+  return value;
+}
+function parseBigIntString(value, field) {
+  try {
+    return BigInt(value);
+  } catch (error) {
+    throw new Web3AgentError({
+      code: "INVALID_PARAMS",
+      message: `${field} must be a valid integer string`,
+      cause: error
+    });
+  }
+}
+
+// src/operations/chain-access.ts
+import { createPublicClient } from "viem";
+function getFallbackProcessConfig(chainId) {
+  return parseEnv({
+    ...process.env,
+    CHAIN_ID: String(chainId)
+  });
+}
+function resolveRuntimeConfig(chainId, config) {
+  if (config) {
+    return config;
+  }
+  return tryGetConfig() ?? getFallbackProcessConfig(chainId);
+}
+function getChainForRuntime(chainId) {
+  return assertChainSupported(chainId);
+}
+function getRuntimeConfigForChain(chainId, config) {
+  return resolveRuntimeConfig(chainId, config);
+}
+function getTransportForRuntimeChain(chainId, config) {
+  return getTransportForChain(chainId, getRuntimeConfigForChain(chainId, config));
+}
+function getRpcUrlForRuntimeChain(chainId, config) {
+  const resolvedConfig = getRuntimeConfigForChain(chainId, config);
+  return resolvedConfig.chainRpcUrls[chainId] ?? (resolvedConfig.chainId === chainId ? resolvedConfig.rpcUrl : void 0);
+}
+function createPublicClientForRuntimeChain(chainId, config) {
+  return createPublicClient({
+    chain: getChainForRuntime(chainId),
+    transport: getTransportForRuntimeChain(chainId, config)
+  });
+}
+
+// src/api/schemas/common.ts
+import { isAddress as isAddress2, isHex as isHex2 } from "viem";
+import { z } from "zod";
+var addressSchema = z.string().refine((value) => isAddress2(value), {
+  message: "must be a valid EVM address"
+});
+var hexSchema = z.string().refine((value) => isHex2(value), {
+  message: "must be a valid 0x-prefixed hex string"
+});
+var typedDataPayloadSchema = z.object({
+  domain: z.record(z.unknown()),
+  types: z.record(
+    z.array(
+      z.object({
+        name: z.string(),
+        type: z.string()
+      })
+    )
+  ),
+  primaryType: z.string(),
+  message: z.record(z.unknown())
+});
+var preparedTransactionRequestSchema = z.object({
+  to: addressSchema,
+  chainId: z.number().int(),
+  data: hexSchema.optional(),
+  value: z.string().optional(),
+  gasLimit: z.string().optional()
+});
+var preparedTransactionActionSchema = z.object({
+  id: z.string(),
+  type: z.literal("transaction"),
+  label: z.string(),
+  tx: preparedTransactionRequestSchema
+});
+var preparedSignTypedDataActionSchema = z.object({
+  id: z.string(),
+  type: z.literal("signTypedData"),
+  label: z.string(),
+  chainId: z.number().int(),
+  eip712: typedDataPayloadSchema
+});
+var preparedSignMessageActionSchema = z.object({
+  id: z.string(),
+  type: z.literal("signMessage"),
+  label: z.string(),
+  chainId: z.number().int(),
+  message: z.string()
+});
+var preparedActionSchema = z.union([
+  preparedTransactionActionSchema,
+  preparedSignTypedDataActionSchema,
+  preparedSignMessageActionSchema
+]);
+var operationActionResultSchema = z.union([
+  z.object({
+    type: z.literal("transaction"),
+    txHash: z.string({ required_error: "txHash is required" }),
+    status: z.literal("confirmed")
+  }),
+  z.object({
+    type: z.literal("signature"),
+    signature: z.string({ required_error: "signature is required" })
+  }),
+  z.object({
+    type: z.literal("messageSignature"),
+    signature: z.string({ required_error: "signature is required" })
+  })
+]);
+var operationActionResultsMapSchema = z.record(operationActionResultSchema);
+var resumeStateBaseSchema = z.object({
+  summary: z.string().optional(),
+  intent: z.record(z.unknown()).optional(),
+  meta: z.record(z.unknown()).optional(),
+  actionResults: operationActionResultsMapSchema.optional()
+});
+
+// src/api/schemas/lifi.ts
+import { z as z2 } from "zod";
+var lifiGetQuoteSchema = z2.object({
+  fromChainId: z2.number({ required_error: "fromChainId is required" }).describe("Source chain ID"),
+  toChainId: z2.number({ required_error: "toChainId is required" }).describe("Destination chain ID"),
+  fromTokenAddress: z2.string({ required_error: "fromTokenAddress is required" }).describe("Source token address"),
+  toTokenAddress: z2.string({ required_error: "toTokenAddress is required" }).describe("Destination token address"),
+  fromAmount: z2.string({ required_error: "fromAmount is required" }).describe("Amount in smallest token units")
+});
+var lifiExecuteBridgeSchema = lifiGetQuoteSchema;
+var lifiPrepareBridgeIntentSchema = lifiGetQuoteSchema.extend({
+  account: addressSchema.describe("Sender wallet address"),
+  approvalAmount: z2.string().optional().describe("Optional override for the token approval amount")
+});
+
+// src/api/schemas/orbs.ts
+import { z as z3 } from "zod";
+var orbsGetQuoteSchema = z3.object({
+  chainId: z3.number().optional().describe("Chain ID (defaults to runtime config)"),
+  fromToken: z3.string({ required_error: "fromToken is required" }).describe("Source token address"),
+  toToken: z3.string({ required_error: "toToken is required" }).describe("Destination token address"),
+  inAmount: z3.string({ required_error: "inAmount is required" }).describe("Amount in smallest token units"),
+  slippage: z3.number().optional().describe("Slippage percentage (0.5 = 0.5%, default 0.5)")
+});
+var orbsSwapSchema = orbsGetQuoteSchema;
+var orbsPrepareSwapIntentSchema = orbsGetQuoteSchema.extend({
+  account: addressSchema.describe("User wallet address")
+});
+var orbsGetRequiredApprovalsSchema = z3.object({
+  chainId: z3.number().optional().describe("Chain ID (defaults to runtime config)"),
+  fromToken: z3.string({ required_error: "fromToken is required" }).describe("Source token address"),
+  inAmount: z3.string({ required_error: "inAmount is required" }).describe("Amount in smallest token units"),
+  account: addressSchema.describe("User wallet address")
+});
+var orbsPlaceTwapSchema = z3.object({
+  chainId: z3.number().optional().describe("Chain ID (defaults to runtime config)"),
+  srcToken: z3.string({ required_error: "srcToken is required" }).describe("Source token address"),
+  dstToken: z3.string({ required_error: "dstToken is required" }).describe("Destination token address"),
+  srcAmount: z3.string({ required_error: "srcAmount is required" }).describe("Total amount in smallest token units"),
+  chunks: z3.number({ required_error: "chunks is required" }).describe("Number of TWAP intervals"),
+  fillDelay: z3.number({ required_error: "fillDelay is required" }).describe("Delay between fills in seconds")
+});
+var orbsPrepareTwapIntentSchema = orbsPlaceTwapSchema.extend({
+  account: addressSchema.describe("User wallet address")
+});
+var orbsPlaceLimitSchema = z3.object({
+  chainId: z3.number().optional().describe("Chain ID (defaults to runtime config)"),
+  srcToken: z3.string({ required_error: "srcToken is required" }).describe("Source token address"),
+  dstToken: z3.string({ required_error: "dstToken is required" }).describe("Destination token address"),
+  srcAmount: z3.string({ required_error: "srcAmount is required" }).describe("Amount in smallest token units"),
+  dstMinAmount: z3.string({ required_error: "dstMinAmount is required" }).describe("Minimum output amount in smallest token units"),
+  expiry: z3.number().optional().describe("Order expiry as Unix timestamp")
+});
+var orbsPrepareLimitIntentSchema = orbsPlaceLimitSchema.extend({
+  account: addressSchema.describe("User wallet address")
+});
+var orbsSubmitSignedSwapSchema = z3.object({
+  chainId: z3.number().optional().describe("Chain ID (defaults to runtime config)"),
+  quote: z3.record(z3.unknown()).describe("Quote object from orbs_get_quote"),
+  signature: hexSchema.refine((v) => v.length >= 132, {
+    message: "signature must be at least 65 bytes (132 hex characters + 0x prefix)"
+  }).describe("Hex-encoded signature of the permit2 typed data")
+});
+var orbsSubmitSignedTwapOrderSchema = z3.object({
+  order: z3.record(z3.unknown()).describe("Order object from orbs_place_twap"),
+  signature: z3.object({
+    v: z3.number({ required_error: "signature.v is required" }).describe("Recovery parameter"),
+    r: z3.string({ required_error: "signature.r is required" }).describe("ECDSA r value"),
+    s: z3.string({ required_error: "signature.s is required" }).describe("ECDSA s value")
+  }).describe("EIP-712 signature components")
+});
+var orbsSwapStatusSchema = z3.object({
+  chainId: z3.number().optional().describe("Chain ID (defaults to runtime config)"),
+  sessionId: z3.string({ required_error: "sessionId is required" }).describe("Session ID from swap submission"),
+  user: z3.string({ required_error: "user is required" }).describe("User wallet address"),
+  maxAttempts: z3.number().optional().describe("Max polling attempts (default 20)")
+});
+var orbsListOrdersSchema = z3.object({
+  chainId: z3.number().optional().describe("Chain ID (defaults to runtime config)")
+});
+
+// src/api/schemas/operations.ts
+import { z as z4 } from "zod";
+var integerChainIdSchema = z4.custom(
+  (value) => typeof value === "number" && Number.isInteger(value),
+  {
+    message: "resumeState.state.chainId must be an integer"
+  }
+);
+var lifiBridgeFinalizationSchema = z4.discriminatedUnion("kind", [
+  z4.object({
+    kind: z4.literal("none")
+  }),
+  z4.object({
+    kind: z4.literal("permit2"),
+    signatureActionId: z4.string(),
+    tokenAddress: addressSchema,
+    amount: z4.string(),
+    nonce: z4.string(),
+    deadline: z4.string(),
+    permit2Proxy: addressSchema,
+    account: addressSchema,
+    witness: z4.literal(true),
+    diamondAddress: addressSchema,
+    diamondCalldataHash: hexSchema
+  })
+]);
+var orbsSwapResumeStateStateSchema = resumeStateBaseSchema.extend({
+  chainId: integerChainIdSchema,
+  quote: z4.record(z4.unknown()),
+  approvalActions: z4.array(preparedTransactionActionSchema),
+  signAction: preparedSignTypedDataActionSchema
+});
+var orbsOrderResumeStateStateSchema = resumeStateBaseSchema.extend({
+  order: z4.record(z4.unknown()),
+  signAction: preparedSignTypedDataActionSchema
+});
+var goatResumeStateStateSchema = resumeStateBaseSchema.extend({
+  toolName: z4.string(),
+  params: z4.record(z4.unknown()).optional(),
+  chainId: integerChainIdSchema,
+  account: addressSchema
+});
+var lifiBridgeResumeStateStateSchema = resumeStateBaseSchema.extend({
+  stages: z4.array(z4.array(preparedActionSchema)),
+  finalAction: preparedTransactionActionSchema,
+  finalization: lifiBridgeFinalizationSchema.optional()
+});
+var operationResumeStateSchema = z4.object({
+  version: z4.literal(1),
+  integration: z4.enum(["orbs", "lifi", "goat"]).describe("Integration name (e.g. 'orbs', 'lifi')"),
+  kind: z4.string({ required_error: "kind is required" }).describe("Action type"),
+  state: z4.record(z4.unknown()).describe("Opaque resume state from previous call")
+});
+var prepareOperationSchema = z4.union([
+  orbsPrepareSwapIntentSchema.extend({
+    integration: z4.literal("orbs").describe("Integration name (e.g. 'orbs', 'lifi')"),
+    kind: z4.literal("swap").describe("Action type")
+  }),
+  orbsPrepareTwapIntentSchema.extend({
+    integration: z4.literal("orbs").describe("Integration name (e.g. 'orbs', 'lifi')"),
+    kind: z4.literal("twap").describe("Action type")
+  }),
+  orbsPrepareLimitIntentSchema.extend({
+    integration: z4.literal("orbs").describe("Integration name (e.g. 'orbs', 'lifi')"),
+    kind: z4.literal("limit").describe("Action type")
+  }),
+  lifiPrepareBridgeIntentSchema.extend({
+    integration: z4.literal("lifi").describe("Integration name (e.g. 'orbs', 'lifi')"),
+    kind: z4.literal("bridge").describe("Action type")
+  }),
+  z4.object({
+    integration: z4.literal("goat").describe("Integration name (e.g. 'orbs', 'lifi')"),
+    kind: z4.literal("tool").describe("Action type"),
+    toolName: z4.string({ required_error: "toolName is required" }),
+    params: z4.record(z4.unknown()).optional().describe("Action parameters"),
+    chainId: z4.number({ required_error: "chainId is required" }),
+    account: addressSchema
+  })
+]);
+var resumeOperationSchema = z4.object({
+  resumeState: operationResumeStateSchema.describe("Opaque resume state from previous call"),
+  actionResults: operationActionResultsMapSchema.optional().describe("Array of completed action results")
+});
+
+// src/api/schemas/tokens.ts
+import { z as z5 } from "zod";
+var resolveTokenSchema = z5.object({
+  symbol: z5.string({ required_error: "symbol is required" }).describe("Token symbol (e.g. 'USDT', 'USDC', 'WETH', 'WBNB', 'DAI')"),
+  chainId: z5.number({ required_error: "chainId is required" }).describe(
+    "EVM chain ID (e.g. 1=Ethereum, 56=BSC, 137=Polygon, 8453=Base, 59144=Linea, 42161=Arbitrum, 10=Optimism)"
+  )
+});
+var listChainTokensSchema = z5.object({
+  chainId: z5.number({ required_error: "chainId is required" }).describe("EVM chain ID")
+});
+
+// src/api/schemas/wallet.ts
+import { z as z6 } from "zod";
+var walletFromMnemonicSchema = z6.object({
+  mnemonic: z6.string({ required_error: "mnemonic is required" }).min(1, "mnemonic must not be empty").describe("BIP-39 mnemonic phrase"),
+  accountIndex: z6.number().optional().describe("BIP-44 account index (default 0)"),
+  addressIndex: z6.number().optional().describe("BIP-44 address index (default 0)")
+});
+var walletDeriveAddressesSchema = z6.object({
+  mnemonic: z6.string({ required_error: "mnemonic is required" }).min(1, "mnemonic must not be empty").describe("BIP-39 mnemonic phrase"),
+  count: z6.number().min(1).max(20).optional().describe("Number of addresses to derive (1-20, default 5)")
+});
+var walletActivateSchema = z6.object({
+  privateKey: z6.string().optional().describe("Hex-encoded private key (0x-prefixed)"),
+  mnemonic: z6.string().optional().describe("BIP-39 mnemonic phrase"),
+  accountIndex: z6.number().optional().describe("BIP-44 account index (default 0, mnemonic only)"),
+  addressIndex: z6.number().optional().describe("BIP-44 address index (default 0, mnemonic only)")
+}).refine((data) => data.privateKey || data.mnemonic, {
+  message: "Either privateKey or mnemonic must be provided"
+});
+var walletSetConfirmationSchema = z6.object({
+  enabled: z6.boolean({ required_error: "enabled is required" }).describe("true to require confirmation for writes, false to execute immediately")
+});
+var transactionConfirmSchema = z6.object({
+  id: z6.string({ required_error: "id is required" }).min(1, "id must not be empty").describe("UUID of the pending operation to confirm")
+});
+var transactionDenySchema = transactionConfirmSchema;
+var transactionSimulateSchema = z6.object({
+  chainId: z6.number({ required_error: "chainId is required" }).describe("Target chain ID"),
+  to: addressSchema.describe("Destination contract or recipient address"),
+  data: hexSchema.describe("Hex-encoded calldata"),
+  value: z6.string().optional().describe("Optional native value in wei"),
+  from: addressSchema.describe("Sender address used for simulation")
+});
+
+// src/api/validation.ts
+import { z as z7 } from "zod";
+function parseInput(schema, input) {
+  try {
+    return schema.parse(input);
+  } catch (error) {
+    if (error instanceof z7.ZodError) {
+      throw new Web3AgentError({
+        code: "INVALID_PARAMS",
+        message: error.errors.map((issue) => issue.message).join("; "),
+        details: error.errors,
+        cause: error
+      });
+    }
+    throw Web3AgentError.fromUnknown("INVALID_PARAMS", error);
+  }
+}
+
+// src/api/operations/shared.ts
+function isMissingReceiptError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  return message.includes("receipt") && message.includes("not found");
+}
+function createPreparedApprovalActions(chainId, approvals) {
+  return approvals.map((step, index) => ({
+    id: `approval:${index}`,
+    type: "transaction",
+    label: step.label,
+    tx: {
+      to: step.tx.to,
+      chainId,
+      ...step.tx.data ? { data: step.tx.data } : {},
+      ...step.tx.value ? { value: step.tx.value } : {}
+    }
+  }));
+}
+function createTypedDataAction(chainId, label, eip712) {
+  return {
+    id: "sign-typed-data:0",
+    type: "signTypedData",
+    label,
+    chainId,
+    eip712
+  };
+}
+function buildPreparedOperation(integration, kind, summary, actions, state, meta) {
+  return {
+    integration,
+    kind,
+    summary,
+    actions,
+    resumeState: {
+      version: 1,
+      integration,
+      kind,
+      state: {
+        ...state,
+        actionResults: state.actionResults && typeof state.actionResults === "object" ? state.actionResults : {},
+        ...meta ? { meta } : {}
+      }
+    },
+    ...meta ? { meta } : {}
+  };
+}
+function getStoredActionResults(state) {
+  if (state.actionResults === void 0) {
+    return {};
+  }
+  return parseInput(operationActionResultsMapSchema, state.actionResults);
+}
+function mergeActionResults(state, actionResults) {
+  return {
+    ...getStoredActionResults(state),
+    ...actionResults ?? {}
+  };
+}
+function assertActionResultType(actionResults, actionId, expectedType) {
+  const result = actionResults[actionId];
+  if (!result) return void 0;
+  if (result.type !== expectedType) {
+    throw new Web3AgentError({
+      code: "INVALID_PARAMS",
+      message: `Action result ${actionId} must be of type ${expectedType}`
+    });
+  }
+  return result;
+}
+async function getConfirmedReceipt(action, result) {
+  const publicClient = createPublicClientForRuntimeChain(action.tx.chainId);
+  try {
+    const receipt = await publicClient.getTransactionReceipt({
+      hash: result.txHash
+    });
+    if (receipt.status !== "success") {
+      throw new Web3AgentError({
+        code: "INVALID_PARAMS",
+        message: `Action result ${action.id} must reference a successful confirmed transaction`
+      });
+    }
+    if (receipt.to && receipt.to.toLowerCase() !== action.tx.to.toLowerCase()) {
+      throw new Web3AgentError({
+        code: "INVALID_PARAMS",
+        message: `Action result ${action.id} transaction target does not match the prepared action`
+      });
+    }
+    return receipt;
+  } catch (error) {
+    if (error instanceof Web3AgentError) {
+      throw error;
+    }
+    if (isMissingReceiptError(error)) {
+      throw new Web3AgentError({
+        code: "INVALID_PARAMS",
+        message: `Action result ${action.id} must reference a confirmed transaction receipt`,
+        cause: error
+      });
+    }
+    throw new Web3AgentError({
+      code: "INVALID_PARAMS",
+      message: `Failed to verify transaction result for action ${action.id}`,
+      cause: error
+    });
+  }
+}
+async function isPreparedActionSatisfied(actionResults, action) {
+  if (action.type === "transaction") {
+    const result2 = assertActionResultType(actionResults, action.id, "transaction");
+    if (!result2) {
+      return false;
+    }
+    await getConfirmedReceipt(action, result2);
+    return true;
+  }
+  if (action.type === "signTypedData") {
+    return assertActionResultType(actionResults, action.id, "signature") !== void 0;
+  }
+  const result = actionResults[action.id];
+  if (!result) return false;
+  if (result.type !== "messageSignature" && result.type !== "signature") {
+    throw new Web3AgentError({
+      code: "INVALID_PARAMS",
+      message: `Action result ${action.id} must be a message signature`
+    });
+  }
+  return true;
+}
+async function getPendingPreparedActions(actions, actionResults) {
+  const pending = [];
+  for (const action of actions) {
+    if (!await isPreparedActionSatisfied(actionResults, action)) {
+      pending.push(action);
+    }
+  }
+  return pending;
+}
+async function assertConfirmedTransactionResult(actionResults, action) {
+  const result = assertActionResultType(actionResults, action.id, "transaction");
+  if (!result) {
+    return void 0;
+  }
+  await getConfirmedReceipt(action, result);
+  return result;
+}
+function toPendingOperation(resumeState, actions, fallbackSummary, actionResults) {
+  const state = assertRecord(resumeState.state, "resumeState.state");
+  const summary = typeof state.summary === "string" && state.summary.length > 0 ? state.summary : fallbackSummary;
+  const meta = state.meta && typeof state.meta === "object" ? { ...state.meta } : {};
+  const nextResumeState = {
+    ...resumeState,
+    state: {
+      ...state,
+      actionResults
+    }
+  };
+  return {
+    integration: resumeState.integration,
+    kind: resumeState.kind,
+    summary,
+    actions,
+    resumeState: nextResumeState,
+    ...Object.keys(meta).length > 0 ? { meta } : {}
+  };
+}
+function assertSubmitSwapQuote(quote) {
+  const record = assertRecord(quote, "quote");
+  const requiredFields = [
+    "sessionId",
+    "inToken",
+    "outToken",
+    "inAmount",
+    "outAmount",
+    "minAmountOut",
+    "user"
+  ];
+  for (const field of requiredFields) {
+    if (typeof record[field] !== "string") {
+      throw new Web3AgentError({
+        code: "INVALID_PARAMS",
+        message: `quote.${field} must be a string`
+      });
+    }
+  }
+  return record;
+}
+function assertSignedOrder(order) {
+  return assertRecord(order, "order");
+}
+function asQuote(value) {
+  if (typeof value.sessionId !== "string") {
+    throw new Web3AgentError({
+      code: "INVALID_PARAMS",
+      message: "quote.sessionId must be a string"
+    });
+  }
+  return value;
+}
+
+// src/tokens/registry.ts
+var TOKENS_BY_ADDRESS = /* @__PURE__ */ new Map();
+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"
+    }
+  }
+};
+for (const [chainId, tokens] of Object.entries(WELL_KNOWN_TOKENS)) {
+  TOKENS_BY_ADDRESS.set(
+    Number(chainId),
+    new Map(
+      Object.values(tokens).map(
+        (token) => [token.address.toLowerCase(), token]
+      )
+    )
+  );
+}
+function lookupToken(symbol, chainId) {
+  return WELL_KNOWN_TOKENS[chainId]?.[symbol.toUpperCase()];
+}
+function lookupTokenByAddress(address, chainId) {
+  return TOKENS_BY_ADDRESS.get(chainId)?.get(address.toLowerCase());
+}
+function getChainTokens(chainId) {
+  return WELL_KNOWN_TOKENS[chainId];
+}
+
+export {
+  Web3AgentError,
+  formatToolError,
+  formatToolResponse,
+  formatToolErrorFromUnknown,
+  loadPlugins,
+  buildGoatTools,
+  GoatProvider,
+  RESTRICTED_PLUGIN_CHAINS,
+  findRestrictedPlugin,
+  dispatchGoatTool,
+  assertChainSupported,
+  assertHex,
+  assertAddress,
+  assertRecord,
+  parseBigIntString,
+  getChainForRuntime,
+  getRuntimeConfigForChain,
+  getTransportForRuntimeChain,
+  getRpcUrlForRuntimeChain,
+  createPublicClientForRuntimeChain,
+  operationActionResultSchema,
+  lifiGetQuoteSchema,
+  lifiExecuteBridgeSchema,
+  lifiPrepareBridgeIntentSchema,
+  orbsGetQuoteSchema,
+  orbsSwapSchema,
+  orbsPrepareSwapIntentSchema,
+  orbsGetRequiredApprovalsSchema,
+  orbsPlaceTwapSchema,
+  orbsPrepareTwapIntentSchema,
+  orbsPlaceLimitSchema,
+  orbsPrepareLimitIntentSchema,
+  orbsSubmitSignedSwapSchema,
+  orbsSubmitSignedTwapOrderSchema,
+  orbsSwapStatusSchema,
+  orbsListOrdersSchema,
+  orbsSwapResumeStateStateSchema,
+  orbsOrderResumeStateStateSchema,
+  goatResumeStateStateSchema,
+  lifiBridgeResumeStateStateSchema,
+  operationResumeStateSchema,
+  prepareOperationSchema,
+  resumeOperationSchema,
+  resolveTokenSchema,
+  listChainTokensSchema,
+  walletFromMnemonicSchema,
+  walletDeriveAddressesSchema,
+  walletActivateSchema,
+  walletSetConfirmationSchema,
+  transactionConfirmSchema,
+  transactionDenySchema,
+  transactionSimulateSchema,
+  parseInput,
+  createPreparedApprovalActions,
+  createTypedDataAction,
+  buildPreparedOperation,
+  mergeActionResults,
+  assertActionResultType,
+  getConfirmedReceipt,
+  getPendingPreparedActions,
+  assertConfirmedTransactionResult,
+  toPendingOperation,
+  assertSubmitSwapQuote,
+  assertSignedOrder,
+  asQuote,
+  lookupToken,
+  lookupTokenByAddress,
+  getChainTokens
+};