web3agent 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,44 +1,385 @@
-#!/usr/bin/env node
 import {
-  VERSION
-} from "./chunk-4GQR4EEY.js";
+  getDefaultRuntime
+} from "./chunk-7ITJ5WGE.js";
+import {
+  clearTraceSupportCache,
+  confirmationQueue,
+  getRequiredApprovals,
+  getToolResultPayload,
+  listTokens,
+  normalizeEip712ForSigning,
+  pollSwapStatus,
+  prepareBridgeIntent,
+  prepareLimitIntent,
+  prepareOperation,
+  prepareSwapIntent,
+  prepareTwapIntent,
+  readAuditLog,
+  resolveCanonicalToken,
+  resolveCanonicalTokenSync,
+  resolveToken,
+  resolveTokenSync,
+  resumeOperation,
+  simulateTransaction,
+  submitSignedSwap,
+  submitSignedTwapOrder
+} from "./chunk-B4LSSN7C.js";
+import "./chunk-ETI3ZR2C.js";
+import "./chunk-4G55KHRO.js";
+import {
+  Web3AgentError,
+  lifiExecuteBridgeSchema,
+  lifiGetQuoteSchema,
+  lifiPrepareBridgeIntentSchema,
+  listChainTokensSchema,
+  operationActionResultSchema,
+  operationResumeStateSchema,
+  orbsGetQuoteSchema,
+  orbsGetRequiredApprovalsSchema,
+  orbsListOrdersSchema,
+  orbsPlaceLimitSchema,
+  orbsPlaceTwapSchema,
+  orbsPrepareLimitIntentSchema,
+  orbsPrepareSwapIntentSchema,
+  orbsPrepareTwapIntentSchema,
+  orbsSubmitSignedSwapSchema,
+  orbsSubmitSignedTwapOrderSchema,
+  orbsSwapSchema,
+  orbsSwapStatusSchema,
+  parseInput,
+  prepareOperationSchema,
+  resolveTokenSchema,
+  resumeOperationSchema,
+  transactionConfirmSchema,
+  transactionDenySchema,
+  transactionSimulateSchema,
+  walletActivateSchema,
+  walletDeriveAddressesSchema,
+  walletFromMnemonicSchema,
+  walletSetConfirmationSchema
+} from "./chunk-BJUU5ESI.js";
+import {
+  getWalletState
+} from "./chunk-KPRIUALX.js";
+import {
+  getChainById,
+  getChainByName,
+  getConfig,
+  isSupported,
+  parseEnv,
+  resetConfig,
+  setConfig
+} from "./chunk-7QEKU2RP.js";
 
-// src/index.ts
-var args = process.argv.slice(2);
-if (args[0] === "init") {
-  import("./init-DKWQSYDZ.js").then(({ runInit }) => {
-    runInit(args.slice(1)).catch((e) => {
-      process.stderr.write(`Error: ${e.message}
-`);
-      process.exit(1);
+// src/api/shared.ts
+async function getRuntime(options) {
+  if (options?.runtime) {
+    return options.runtime;
+  }
+  return getDefaultRuntime();
+}
+async function invokeAndRequireData(runtime, toolName, args = {}) {
+  const result = await runtime.invokeTool(toolName, args);
+  const payload = getToolResultPayload(result);
+  if (!payload.ok) {
+    throw new Web3AgentError({
+      code: payload.error.code ?? "TOOL_ERROR",
+      message: payload.error.message ?? `Tool invocation failed: ${toolName}`,
+      details: payload.error.details
     });
-  });
-} else if (args.includes("--version")) {
-  process.stderr.write(`web3agent ${VERSION}
-`);
-  process.exit(0);
-} else if (args.includes("--help")) {
-  process.stderr.write(
-    `${[
-      "web3agent \u2014 Web3 MCP proxy server",
-      "",
-      "Usage:",
-      "  web3agent        Start MCP proxy server (stdio)",
-      "  web3agent init   Configure your AI agent host",
-      "",
-      "Options:",
-      "  --version        Print version",
-      "  --help           Print this help"
-    ].join("\n")}
-`
+  }
+  return payload.data;
+}
+
+// src/api/chains.ts
+function getChain(id) {
+  return getChainById(id);
+}
+function findChainByName(name) {
+  return getChainByName(name);
+}
+function isSupportedChain(chainId) {
+  return isSupported(chainId);
+}
+async function listSupportedChains(options) {
+  const runtime = await getRuntime(options);
+  return invokeAndRequireData(runtime, "list_supported_chains");
+}
+async function listSupportedChainEntries(options) {
+  const result = await listSupportedChains(options);
+  return result.chains;
+}
+
+// src/api/write-results.ts
+function isPendingConfirmation(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate.status === "pending_confirmation" && typeof candidate.id === "string" && typeof candidate.summary === "string";
+}
+function normalizeWriteResult(data) {
+  if (isPendingConfirmation(data)) {
+    return data;
+  }
+  return data ?? {};
+}
+
+// src/api/orders.ts
+async function placeLimitOrder(params, options) {
+  const runtime = await getRuntime(options);
+  const input = parseInput(orbsPlaceLimitSchema, params);
+  const data = await invokeAndRequireData(runtime, "orbs_place_limit", input);
+  return normalizeWriteResult(data);
+}
+async function placeTwapOrder(params, options) {
+  const runtime = await getRuntime(options);
+  const input = parseInput(orbsPlaceTwapSchema, params);
+  const data = await invokeAndRequireData(runtime, "orbs_place_twap", input);
+  return normalizeWriteResult(data);
+}
+async function listOrders(params, options) {
+  const runtime = await getRuntime(options);
+  const input = parseInput(orbsListOrdersSchema, params);
+  return invokeAndRequireData(runtime, "orbs_list_orders", input);
+}
+
+// src/api/swaps.ts
+async function getSwapQuote(params, options) {
+  const runtime = await getRuntime(options);
+  if ("fromChainId" in params) {
+    const input2 = parseInput(lifiGetQuoteSchema, params);
+    const quote2 = await invokeAndRequireData(
+      runtime,
+      "lifi_get_quote",
+      input2
+    );
+    return {
+      kind: "cross-chain",
+      provider: "lifi",
+      quote: quote2
+    };
+  }
+  const input = parseInput(orbsSwapSchema, params);
+  const quote = await invokeAndRequireData(
+    runtime,
+    "orbs_get_quote",
+    input
   );
-  process.exit(0);
-} else {
-  import("./startup-PHXZQ2SL.js").then(({ startServer }) => {
-    startServer().catch((e) => {
-      process.stderr.write(`Fatal: ${e.message}
-`);
-      process.exit(1);
+  return {
+    kind: "same-chain",
+    provider: "orbs",
+    chainId: input.chainId ?? getConfig().chainId,
+    quote
+  };
+}
+async function isTokenSwappable(params, options) {
+  try {
+    const quote = await getSwapQuote(params, options);
+    return {
+      swappable: true,
+      provider: quote.provider,
+      kind: quote.kind
+    };
+  } catch (error) {
+    if ("fromChainId" in params) {
+      return {
+        swappable: false,
+        provider: "lifi",
+        kind: "cross-chain",
+        reason: error instanceof Error ? error.message : String(error)
+      };
+    }
+    return {
+      swappable: false,
+      provider: "orbs",
+      kind: "same-chain",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function executeSameChainSwap(params, options) {
+  const runtime = await getRuntime(options);
+  const input = parseInput(orbsSwapSchema, params);
+  const data = await invokeAndRequireData(runtime, "orbs_swap", input);
+  return normalizeWriteResult(data);
+}
+async function executeBridge(params, options) {
+  const runtime = await getRuntime(options);
+  const input = parseInput(lifiExecuteBridgeSchema, params);
+  const data = await invokeAndRequireData(runtime, "lifi_execute_bridge", input);
+  return normalizeWriteResult(data);
+}
+async function getSwapStatus(params, options) {
+  const runtime = await getRuntime(options);
+  const input = parseInput(orbsSwapStatusSchema, params);
+  const status = await invokeAndRequireData(
+    runtime,
+    "orbs_swap_status",
+    input
+  );
+  return {
+    provider: "orbs",
+    status
+  };
+}
+function mapOperationType(operationType) {
+  if (operationType === "orbs_swap") return "orbs";
+  if (operationType === "lifi_execute_bridge") return "lifi";
+  return null;
+}
+async function getSwapHistory(_params = {}) {
+  const walletAddress = _params.walletAddress ?? getWalletState().address;
+  const pendingEntries = confirmationQueue.list().filter((operation) => mapOperationType(operation.type) !== null).filter(
+    (operation) => walletAddress ? operation.walletAddress?.toLowerCase() === walletAddress.toLowerCase() : true
+  ).map((operation) => ({
+    id: operation.id,
+    provider: mapOperationType(operation.type) ?? "orbs",
+    status: "pending_confirmation",
+    walletAddress: operation.walletAddress,
+    description: operation.description,
+    timestamp: operation.createdAt.toISOString()
+  }));
+  const auditEntries = await readAuditLog();
+  const historyEntries = auditEntries.filter((entry) => mapOperationType(entry.operationType) !== null).filter(
+    (entry) => walletAddress ? entry.walletAddress?.toLowerCase() === walletAddress.toLowerCase() : true
+  ).map((entry) => ({
+    id: entry.operationId,
+    provider: mapOperationType(entry.operationType) ?? "orbs",
+    status: entry.action === "CONFIRMED" ? "confirmed" : entry.action.toLowerCase(),
+    walletAddress: entry.walletAddress,
+    description: entry.description,
+    timestamp: entry.timestamp
+  }));
+  return {
+    walletAddress,
+    entries: [...pendingEntries, ...historyEntries].sort(
+      (a, b) => a.timestamp < b.timestamp ? 1 : -1
+    )
+  };
+}
+
+// src/api/tokens.ts
+async function resolveToken2(params) {
+  const { symbol, chainId } = parseInput(resolveTokenSchema, params);
+  const chain = getChainById(chainId);
+  if (!chain) {
+    throw new Web3AgentError({
+      code: "UNKNOWN_CHAIN",
+      message: `Chain ${chainId} is not a known EVM chain`
+    });
+  }
+  const result = await resolveToken(symbol, chainId);
+  if (!result) {
+    throw new Web3AgentError({
+      code: "TOKEN_NOT_FOUND",
+      message: `Token '${symbol}' not found on ${chain.name} (${chainId})`
+    });
+  }
+  return result;
+}
+async function resolveCanonicalToken2(params) {
+  const { symbol, chainId } = parseInput(resolveTokenSchema, params);
+  const chain = getChainById(chainId);
+  if (!chain) {
+    throw new Web3AgentError({
+      code: "UNKNOWN_CHAIN",
+      message: `Chain ${chainId} is not a known EVM chain`
+    });
+  }
+  const result = await resolveCanonicalToken(symbol, chainId);
+  if (!result) {
+    throw new Web3AgentError({
+      code: "TOKEN_NOT_FOUND",
+      message: `Canonical token '${symbol}' not found on ${chain.name} (${chainId}); call resolveToken() to use discovery fallback`
+    });
+  }
+  return result;
+}
+function resolveTokenSync2(params) {
+  const { symbol, chainId } = parseInput(resolveTokenSchema, params);
+  return resolveTokenSync(symbol, chainId);
+}
+function resolveCanonicalTokenSync2(params) {
+  const { symbol, chainId } = parseInput(resolveTokenSchema, params);
+  return resolveCanonicalTokenSync(symbol, chainId);
+}
+function listChainTokens(params) {
+  const { chainId } = parseInput(listChainTokensSchema, params);
+  const chain = getChainById(chainId);
+  if (!chain) {
+    throw new Web3AgentError({
+      code: "UNKNOWN_CHAIN",
+      message: `Chain ${chainId} is not a known EVM chain`
     });
-  });
+  }
+  return {
+    chainId,
+    chainName: chain.name,
+    tokens: listTokens(chainId)
+  };
 }
+export {
+  Web3AgentError,
+  clearTraceSupportCache,
+  executeBridge,
+  executeSameChainSwap,
+  findChainByName,
+  getChain,
+  getRequiredApprovals,
+  getSwapHistory,
+  getSwapQuote,
+  getSwapStatus,
+  isSupportedChain,
+  isTokenSwappable,
+  lifiExecuteBridgeSchema,
+  lifiGetQuoteSchema,
+  lifiPrepareBridgeIntentSchema,
+  listChainTokens,
+  listChainTokensSchema,
+  listOrders,
+  listSupportedChainEntries,
+  listSupportedChains,
+  normalizeEip712ForSigning,
+  operationActionResultSchema,
+  operationResumeStateSchema,
+  orbsGetQuoteSchema,
+  orbsGetRequiredApprovalsSchema,
+  orbsListOrdersSchema,
+  orbsPlaceLimitSchema,
+  orbsPlaceTwapSchema,
+  orbsPrepareLimitIntentSchema,
+  orbsPrepareSwapIntentSchema,
+  orbsPrepareTwapIntentSchema,
+  orbsSubmitSignedSwapSchema,
+  orbsSubmitSignedTwapOrderSchema,
+  orbsSwapSchema,
+  orbsSwapStatusSchema,
+  parseEnv,
+  placeLimitOrder,
+  placeTwapOrder,
+  pollSwapStatus,
+  prepareBridgeIntent,
+  prepareLimitIntent,
+  prepareOperation,
+  prepareOperationSchema,
+  prepareSwapIntent,
+  prepareTwapIntent,
+  resetConfig,
+  resolveCanonicalToken2 as resolveCanonicalToken,
+  resolveCanonicalTokenSync2 as resolveCanonicalTokenSync,
+  resolveToken2 as resolveToken,
+  resolveTokenSchema,
+  resolveTokenSync2 as resolveTokenSync,
+  resumeOperation,
+  resumeOperationSchema,
+  setConfig,
+  simulateTransaction,
+  submitSignedSwap,
+  submitSignedTwapOrder,
+  transactionConfirmSchema,
+  transactionDenySchema,
+  transactionSimulateSchema,
+  walletActivateSchema,
+  walletDeriveAddressesSchema,
+  walletFromMnemonicSchema,
+  walletSetConfirmationSchema
+};

package/dist/managed-runtime-DCLqOBjp.d.ts

@@ -0,0 +1,157 @@
+import { Tool, CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { b as RuntimeConfig, B as BackendStatus, j as BackendStatusCode, C as CreateRuntimeOptions, W as Web3AgentRuntime, k as WalletGenerateResult, l as WalletGenerateMnemonicResult, m as WalletAddressDerivationResult, n as WalletDerivedAddressEntry, o as WalletActiveResult, p as WalletDeactivationResult, q as WalletConfirmationResult, r as TransactionListResult, s as TransactionConfirmResult, t as TransactionDenyResult, R as RuntimeHealth, T as ToolCatalogEntry, c as RuntimeToolListener } from './types-B_VpZGqQ.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+
+interface GoatToolSnapshot {
+    listOfTools: Array<{
+        name: string;
+        description: string;
+        inputSchema: object;
+    }>;
+    toolHandler: (toolName: string, params: unknown) => Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    chainId: number;
+}
+
+declare class GoatProvider {
+    private snapshots;
+    private pluginResult;
+    private referenceSnapshot;
+    private generation;
+    private runtimeConfig?;
+    private walletChangeHandler?;
+    private rebuildPromise;
+    initialize(config: RuntimeConfig): Promise<void>;
+    /** Wait for any in-flight rebuild triggered by a wallet change. */
+    waitForRebuild(): Promise<void>;
+    shutdown(): void;
+    private buildSnapshot;
+    getOrBuildSnapshot(chainId: number): Promise<GoatToolSnapshot | undefined>;
+    getReferenceSnapshot(): GoatToolSnapshot | undefined;
+    getAllToolNames(): string[];
+    getLoadedPlugins(): string[];
+}
+
+interface PrefixedTool extends Tool {
+    upstreamName: string;
+    prefix: string;
+}
+interface AdapterHealth extends BackendStatus {
+    restartCount?: number;
+    pid?: number;
+    uptimeMs?: number;
+    lastRestartAt?: Date;
+}
+interface UpstreamAdapter {
+    name: string;
+    initialize(): Promise<void>;
+    getTools(): PrefixedTool[];
+    callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+    getHealth(): AdapterHealth;
+    shutdown(): Promise<void>;
+}
+
+interface RemoteMcpAdapterConfig {
+    name: string;
+    prefix: string;
+    url: string;
+    initialStatus?: BackendStatusCode;
+    initialMessage?: string;
+}
+declare abstract class RemoteMcpAdapter implements UpstreamAdapter {
+    readonly name: string;
+    protected client: Client;
+    protected tools: PrefixedTool[];
+    protected routeMap: Map<string, string>;
+    protected health: AdapterHealth;
+    private readonly prefix;
+    private readonly url;
+    constructor(config: RemoteMcpAdapterConfig);
+    protected shouldSkipInit(): boolean;
+    protected getTransportOptions(): RequestInit | undefined;
+    protected postConnect(): Promise<void>;
+    protected filterTools(tools: Tool[]): Tool[];
+    protected transformDescription(description: string): string;
+    initialize(): Promise<void>;
+    getTools(): PrefixedTool[];
+    callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+    getHealth(): AdapterHealth;
+    shutdown(): Promise<void>;
+}
+
+declare class BlockscoutAdapter extends RemoteMcpAdapter {
+    constructor(url?: string);
+    protected postConnect(): Promise<void>;
+    protected filterTools(tools: Tool[]): Tool[];
+    protected transformDescription(desc: string): string;
+}
+
+declare class EtherscanAdapter extends RemoteMcpAdapter {
+    private readonly apiKey;
+    constructor(url?: string, apiKey?: string);
+    protected shouldSkipInit(): boolean;
+    protected getTransportOptions(): RequestInit | undefined;
+}
+
+declare class ManagedRuntime implements Web3AgentRuntime {
+    readonly config: RuntimeConfig;
+    private readonly blockscoutAdapter;
+    private readonly etherscanAdapter;
+    readonly wallet: {
+        generate: () => Promise<WalletGenerateResult>;
+        generateMnemonic: () => Promise<WalletGenerateMnemonicResult>;
+        fromMnemonic: (params: Record<string, unknown>) => Promise<WalletAddressDerivationResult>;
+        deriveAddresses: (params: Record<string, unknown>) => Promise<WalletDerivedAddressEntry[]>;
+        getActive: () => Promise<WalletActiveResult>;
+        activate: (params: Record<string, unknown>) => Promise<WalletActiveResult>;
+        deactivate: () => Promise<WalletDeactivationResult>;
+        setConfirmation: (params: Record<string, unknown>) => Promise<WalletConfirmationResult>;
+    };
+    readonly transactions: {
+        list: () => Promise<TransactionListResult>;
+        confirm: (id: string) => Promise<TransactionConfirmResult>;
+        deny: (id: string) => Promise<TransactionDenyResult>;
+    };
+    readonly status: {
+        server: () => Promise<RuntimeHealth>;
+        supportedChains: () => Promise<unknown>;
+    };
+    readonly pendingOpsRestored: number;
+    private readonly frameworkTools;
+    private readonly lifiTools;
+    private readonly orbsTools;
+    private readonly tokenTools;
+    private readonly x402Tools;
+    private readonly erc8183Tools;
+    private readonly acpVirtualsTools;
+    private readonly agdpTools;
+    private readonly erc8004Tools;
+    private readonly evmTools;
+    private readonly goatProvider;
+    private readonly listeners;
+    private readonly health;
+    private readonly toolRecords;
+    private walletChangeHandler?;
+    private closed;
+    constructor(config: RuntimeConfig, blockscoutAdapter: BlockscoutAdapter, etherscanAdapter: EtherscanAdapter, goatProvider: GoatProvider, pendingOpsRestored: number);
+    initialize(): void;
+    listTools(): ToolCatalogEntry[];
+    getTool(name: string): ToolCatalogEntry | undefined;
+    getMcpTools(): Tool[];
+    invokeTool(name: string, args?: Record<string, unknown>): Promise<CallToolResult>;
+    getHealth(): RuntimeHealth;
+    onToolsChanged(listener: RuntimeToolListener): () => void;
+    shutdown(): Promise<void>;
+    private requireToolData;
+    private emitToolsChanged;
+    private refreshHealthStatus;
+    private rebuildToolRegistry;
+    private getFrameworkSource;
+}
+declare function createRuntime(options?: CreateRuntimeOptions): Promise<ManagedRuntime>;
+
+export { BlockscoutAdapter as B, EtherscanAdapter as E, GoatProvider as G, ManagedRuntime as M, createRuntime as c };

package/dist/mcp/index.d.ts

@@ -0,0 +1,21 @@
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { M as ManagedRuntime, B as BlockscoutAdapter, E as EtherscanAdapter, G as GoatProvider } from '../managed-runtime-DCLqOBjp.js';
+import '@modelcontextprotocol/sdk/types.js';
+import '../types-B_VpZGqQ.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+
+declare class ProxyServer {
+    private readonly server;
+    private removeToolsChangedListener?;
+    private readonly runtime;
+    constructor(runtimeOrBlockscout: ManagedRuntime | BlockscoutAdapter, etherscanAdapter?: EtherscanAdapter, goatProviderInstance?: GoatProvider);
+    private registerHandlers;
+    private getAggregatedTools;
+    shutdown(): Promise<void>;
+    connect(transport: StdioServerTransport): Promise<void>;
+    start(): Promise<void>;
+}
+
+declare function startServer(): Promise<void>;
+
+export { ProxyServer, startServer };