@elizaos/plugin-wallet 2.0.0-beta.1

package/src/analytics/token-info/service.ts

@@ -0,0 +1,168 @@
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import {
+  createBirdeyeTokenInfoProvider,
+  createCoinGeckoTokenInfoProvider,
+  createDexScreenerTokenInfoProvider,
+} from "./providers";
+import type {
+  TokenInfoDispatchContext,
+  TokenInfoProvider,
+  TokenInfoProviderMetadata,
+  TokenInfoRouteResult,
+  TokenInfoSubaction,
+} from "./types";
+
+export const TOKEN_INFO_SERVICE_TYPE = "token-info" as const;
+
+const DEFAULT_PROVIDER_BY_SUBACTION: Record<TokenInfoSubaction, string> = {
+  search: "dexscreener",
+  token: "dexscreener",
+  trending: "dexscreener",
+  "new-pairs": "dexscreener",
+  "chain-pairs": "dexscreener",
+  boosted: "dexscreener",
+  profiles: "dexscreener",
+  wallet: "birdeye",
+};
+
+function normalizeProviderKey(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[\s_-]+/g, "");
+}
+
+export class TokenInfoService extends Service {
+  static override serviceType = TOKEN_INFO_SERVICE_TYPE;
+
+  override capabilityDescription =
+    "Token information provider registry for DexScreener, Birdeye, CoinGecko, and future crypto data sources";
+
+  private readonly providers = new Map<string, TokenInfoProvider>();
+  private readonly aliases = new Map<string, string>();
+
+  static override async start(
+    runtime: IAgentRuntime,
+  ): Promise<TokenInfoService> {
+    const service = new TokenInfoService(runtime);
+    service.registerProvider(createDexScreenerTokenInfoProvider());
+    service.registerProvider(createBirdeyeTokenInfoProvider());
+    service.registerProvider(createCoinGeckoTokenInfoProvider());
+    return service;
+  }
+
+  registerProvider(provider: TokenInfoProvider): void {
+    const key = normalizeProviderKey(provider.name);
+    this.providers.set(key, provider);
+    for (const alias of [provider.name, ...provider.aliases]) {
+      this.aliases.set(normalizeProviderKey(alias), key);
+    }
+  }
+
+  listProviders(): TokenInfoProviderMetadata[] {
+    return [...this.providers.values()].map((provider) =>
+      this.toMetadata(provider),
+    );
+  }
+
+  getCapabilities(): {
+    readonly providers: readonly TokenInfoProviderMetadata[];
+  } {
+    return {
+      providers: this.listProviders(),
+    };
+  }
+
+  async route(
+    context: TokenInfoDispatchContext,
+  ): Promise<TokenInfoRouteResult> {
+    const providerResult = this.resolveProvider(
+      context.params.target,
+      context.params.subaction,
+    );
+    if (!providerResult.ok) {
+      return providerResult;
+    }
+
+    try {
+      return {
+        ok: true,
+        provider: this.toMetadata(providerResult.provider),
+        result: await providerResult.provider.execute(context),
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: "EXECUTION_FAILED",
+        detail: error instanceof Error ? error.message : String(error),
+        providers: [this.toMetadata(providerResult.provider)],
+      };
+    }
+  }
+
+  override async stop(): Promise<void> {
+    this.providers.clear();
+    this.aliases.clear();
+  }
+
+  private resolveProvider(
+    target: string | undefined,
+    subaction: TokenInfoSubaction,
+  ):
+    | { readonly ok: true; readonly provider: TokenInfoProvider }
+    | Extract<TokenInfoRouteResult, { readonly ok: false }> {
+    if (target) {
+      const key = this.aliases.get(normalizeProviderKey(target));
+      const provider = key ? this.providers.get(key) : undefined;
+      if (!provider) {
+        return {
+          ok: false,
+          error: "UNSUPPORTED_PROVIDER",
+          detail: `Unsupported token info provider "${target}".`,
+          providers: this.listProviders(),
+        };
+      }
+      if (!provider.supportedSubactions.includes(subaction)) {
+        return {
+          ok: false,
+          error: "UNSUPPORTED_SUBACTION",
+          detail: `${provider.name} does not support ${subaction}.`,
+          providers: [this.toMetadata(provider)],
+        };
+      }
+      return { ok: true, provider };
+    }
+
+    const preferred = DEFAULT_PROVIDER_BY_SUBACTION[subaction];
+    const provider = this.providers.get(preferred);
+    if (provider?.supportedSubactions.includes(subaction)) {
+      return { ok: true, provider };
+    }
+
+    const candidates = [...this.providers.values()].filter((candidate) =>
+      candidate.supportedSubactions.includes(subaction),
+    );
+    if (candidates.length === 1) {
+      return { ok: true, provider: candidates[0] };
+    }
+
+    return {
+      ok: false,
+      error: "UNSUPPORTED_SUBACTION",
+      detail:
+        candidates.length === 0
+          ? `No token info provider supports ${subaction}.`
+          : `Choose a token info provider for ${subaction}.`,
+      providers: candidates.map((candidate) => this.toMetadata(candidate)),
+    };
+  }
+
+  private toMetadata(provider: TokenInfoProvider): TokenInfoProviderMetadata {
+    return {
+      name: provider.name,
+      aliases: [...provider.aliases],
+      supportedSubactions: [...provider.supportedSubactions],
+      description: provider.description,
+    };
+  }
+}

package/src/analytics/token-info/types.ts

@@ -0,0 +1,74 @@
+import type {
+  ActionResult,
+  HandlerCallback,
+  HandlerOptions,
+  IAgentRuntime,
+  Memory,
+  State,
+} from "@elizaos/core";
+
+export const TOKEN_INFO_SUBACTIONS = [
+  "search",
+  "token",
+  "trending",
+  "new-pairs",
+  "chain-pairs",
+  "boosted",
+  "profiles",
+  "wallet",
+] as const;
+
+export type TokenInfoSubaction = (typeof TOKEN_INFO_SUBACTIONS)[number];
+
+export interface TokenInfoParams {
+  readonly target?: string;
+  readonly subaction: TokenInfoSubaction;
+  readonly query?: string;
+  readonly address?: string;
+  readonly tokenAddress?: string;
+  readonly chain?: string;
+  readonly timeframe?: "1h" | "6h" | "24h";
+  readonly limit?: number;
+  readonly offset?: number;
+  readonly sortBy?: "volume" | "liquidity" | "priceChange" | "txns";
+  readonly top?: boolean;
+  readonly kind?: "wallet-address" | "token-address" | "token-symbol";
+  readonly id?: string;
+}
+
+export interface TokenInfoProviderMetadata {
+  readonly name: string;
+  readonly aliases: readonly string[];
+  readonly supportedSubactions: readonly TokenInfoSubaction[];
+  readonly description?: string;
+}
+
+export interface TokenInfoProvider extends TokenInfoProviderMetadata {
+  execute(context: TokenInfoDispatchContext): Promise<ActionResult>;
+}
+
+export interface TokenInfoDispatchContext {
+  readonly runtime: IAgentRuntime;
+  readonly message: Memory;
+  readonly state?: State;
+  readonly options?: HandlerOptions | Record<string, unknown>;
+  readonly params: TokenInfoParams;
+  readonly callback?: HandlerCallback;
+}
+
+export type TokenInfoRouteResult =
+  | {
+      readonly ok: true;
+      readonly provider: TokenInfoProviderMetadata;
+      readonly result: ActionResult;
+    }
+  | {
+      readonly ok: false;
+      readonly error:
+        | "UNSUPPORTED_PROVIDER"
+        | "UNSUPPORTED_SUBACTION"
+        | "INVALID_PARAMS"
+        | "EXECUTION_FAILED";
+      readonly detail: string;
+      readonly providers?: readonly TokenInfoProviderMetadata[];
+    };

package/src/audit/audit-log.ts

@@ -0,0 +1,45 @@
+import type {
+  ActionFailureCode,
+  ValidateFailureCode,
+} from "../actions/failure-codes.js";
+import type { SignScope } from "../wallet/pending.js";
+
+export type AuditKind =
+  | "action_validate_start"
+  | "action_validate_end"
+  | "action_handler_start"
+  | "action_handler_end"
+  | "wallet_sign_request"
+  | "wallet_sign_result"
+  | "approval_requested"
+  | "approval_resolved"
+  | "automation_trigger_fired"
+  | "automation_trigger_skipped";
+
+export type AuditOutcome =
+  | "ok"
+  | "validate_fail"
+  | "handler_fail"
+  | "pending_approval"
+  | "approved"
+  | "rejected";
+
+/**
+ * Row shape for the append-only audit log (hash-chained at rest).
+ * Implementation + SQL migration land with Phase 1 runtime wiring.
+ */
+export interface AuditLogRow {
+  readonly id: bigint;
+  readonly ts: number;
+  readonly actor: "agent" | "user" | "automation";
+  readonly kind: AuditKind;
+  readonly scope: SignScope | null;
+  readonly actionName: string | null;
+  readonly paramsHash: string;
+  readonly approvalId: string | null;
+  readonly outcome: AuditOutcome;
+  readonly failureCode: ValidateFailureCode | ActionFailureCode | null;
+  readonly detail: string | null;
+  readonly prevHash: string;
+  readonly rowHash: string;
+}

package/src/browser-shim/build-shim.ts

@@ -0,0 +1,123 @@
+/**
+ * Build a self-contained JS string that, when evaluated in a page's MAIN
+ * world, registers the agent as a Wallet-Standard Solana wallet and an
+ * EIP-1193 EVM provider. All signing requests are forwarded to the wallet
+ * plugin's HTTP sign endpoints (gated by the bearer token).
+ *
+ * Consumers:
+ *   - browser-bridge extension content script (MAIN world, document_start)
+ *   - Playwright `page.addInitScript(buildWalletShim({...}))`
+ *   - plugin-browser `BROWSER eval` (post-load fallback)
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export interface WalletShimConfig {
+  /** Base URL of the wallet HTTP API (e.g. `http://127.0.0.1:31337`). */
+  apiBase: string;
+  /** Shared bearer token (matches `WALLET_BROWSER_SIGN_TOKEN`). */
+  signToken: string;
+  /** Display name shown to dApps. */
+  walletName?: string;
+  /** Optional data URL icon. */
+  walletIcon?: string;
+  /** Active Solana public key (base58). Pass null to disable Solana surface. */
+  solanaPublicKey: string | null;
+  /** Active EVM address (0x…). Pass null to disable EVM surface. */
+  evmAddress: string | null;
+  /** Default EVM chain id the provider reports until a switch is requested. */
+  evmChainId?: number;
+  /** Public RPC URLs the shim uses for read-only EVM calls, keyed by chainId. */
+  evmRpcByChainId?: Record<string, string>;
+}
+
+const DEFAULT_EVM_RPCS: Record<string, string> = {
+  // Ethereum mainnet
+  "1": "https://eth.llamarpc.com",
+  // Base
+  "8453": "https://mainnet.base.org",
+  // BSC
+  "56": "https://bsc-dataseed.bnbchain.org",
+  // Optimism
+  "10": "https://mainnet.optimism.io",
+  // Arbitrum
+  "42161": "https://arb1.arbitrum.io/rpc",
+  // Polygon
+  "137": "https://polygon-rpc.com",
+};
+
+const DEFAULT_ICON =
+  "data:image/svg+xml;base64," +
+  Buffer.from(
+    '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><rect width="32" height="32" rx="8" fill="#9b87f5"/><text x="16" y="22" font-family="Arial,sans-serif" font-size="18" fill="#fff" text-anchor="middle" font-weight="700">E</text></svg>',
+  ).toString("base64");
+
+let cachedTemplate: string | null = null;
+
+function readTemplate(): string {
+  if (cachedTemplate) return cachedTemplate;
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  // When loaded from src/ during dev, template lives next to this file.
+  // When loaded from dist/, the build copies it alongside.
+  const candidates = [
+    path.join(here, "shim.template.js"),
+    path.join(here, "..", "..", "src", "browser-shim", "shim.template.js"),
+  ];
+  for (const candidate of candidates) {
+    try {
+      cachedTemplate = fs.readFileSync(candidate, "utf8");
+      return cachedTemplate;
+    } catch {
+      // try next
+    }
+  }
+  throw new Error(
+    "wallet shim template not found in any of: " + candidates.join(", "),
+  );
+}
+
+export function buildWalletShim(config: WalletShimConfig): string {
+  if (!config.apiBase) throw new Error("buildWalletShim: apiBase required");
+  if (!config.signToken || config.signToken.length < 16) {
+    throw new Error(
+      "buildWalletShim: signToken must be ≥16 chars (WALLET_BROWSER_SIGN_TOKEN)",
+    );
+  }
+  const template = readTemplate();
+  const baked = {
+    apiBase: config.apiBase.replace(/\/+$/, ""),
+    signToken: config.signToken,
+    walletName: config.walletName ?? "Eliza Wallet",
+    walletIcon: config.walletIcon ?? DEFAULT_ICON,
+    solanaPublicKey: config.solanaPublicKey,
+    evmAddress: config.evmAddress,
+    evmChainId: config.evmChainId ?? 1,
+    evmRpcByChainId: { ...DEFAULT_EVM_RPCS, ...(config.evmRpcByChainId ?? {}) },
+  };
+  return template.replace(
+    "/*ELIZA_WALLET_SHIM_CONFIG_INSERT*/ null",
+    JSON.stringify(baked),
+  );
+}
+
+export function buildWalletShimFromTemplate(
+  template: string,
+  config: WalletShimConfig,
+): string {
+  const baked = {
+    apiBase: config.apiBase.replace(/\/+$/, ""),
+    signToken: config.signToken,
+    walletName: config.walletName ?? "Eliza Wallet",
+    walletIcon: config.walletIcon ?? DEFAULT_ICON,
+    solanaPublicKey: config.solanaPublicKey,
+    evmAddress: config.evmAddress,
+    evmChainId: config.evmChainId ?? 1,
+    evmRpcByChainId: { ...DEFAULT_EVM_RPCS, ...(config.evmRpcByChainId ?? {}) },
+  };
+  return template.replace(
+    "/*ELIZA_WALLET_SHIM_CONFIG_INSERT*/ null",
+    JSON.stringify(baked),
+  );
+}

package/src/browser-shim/index.ts

@@ -0,0 +1,5 @@
+export {
+  buildWalletShim,
+  buildWalletShimFromTemplate,
+  type WalletShimConfig,
+} from "./build-shim";