@elizaos/plugin-wallet 2.0.0-beta.1 → 2.0.3-beta.6

package/dist/lib/server-wallet-trade.d.ts

@@ -0,0 +1,22 @@
+import type http from "node:http";
+import type { WalletExportRequestBody } from "../contracts.js";
+import { type WalletExportRejection as CompatWalletExportRejection } from "./wallet-export-guard";
+export declare function normalizeCompatRejection<T extends {
+    status: number;
+    reason: string;
+} | null>(rejection: T): T;
+export declare function runWithCompatAuthContext<T>(req: Pick<http.IncomingMessage, "headers">, operation: () => T): T;
+export type TradePermissionMode = "user-sign-only" | "manual-local-key" | "agent-auto";
+export declare function resolveTradePermissionMode(config: {
+    features?: {
+        tradePermissionMode?: unknown;
+    } | null;
+}): TradePermissionMode;
+export declare function canUseLocalTradeExecution(mode: TradePermissionMode, isAgent: boolean): boolean;
+/**
+ * Hardened wallet export rejection function.
+ *
+ * Wraps the upstream token validation with per-IP rate limiting (1 per 10 min),
+ * audit logging (IP + UA), and a 10s confirmation delay via single-use nonces.
+ */
+export declare function resolveWalletExportRejection(req: http.IncomingMessage, body: WalletExportRequestBody): CompatWalletExportRejection | null;

package/dist/lib/server-wallet-trade.js

@@ -0,0 +1,333 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/lib/server-wallet-trade.ts
+import crypto2 from "node:crypto";
+import { syncAppEnvToEliza, syncElizaEnvAliases } from "@elizaos/core";
+
+// src/lib/wallet-export-guard.ts
+import crypto from "node:crypto";
+var RATE_LIMIT_WINDOW_MS = 10 * 60 * 1000;
+var RATE_LIMIT_SWEEP_INTERVAL_MS = 15 * 60 * 1000;
+var rateLimitMap = new Map;
+var sweepTimer = setInterval(() => {
+  const now = Date.now();
+  for (const [key, entry] of rateLimitMap) {
+    if (now - entry.lastExportAt > RATE_LIMIT_WINDOW_MS * 2) {
+      rateLimitMap.delete(key);
+    }
+  }
+}, RATE_LIMIT_SWEEP_INTERVAL_MS);
+if (typeof sweepTimer === "object" && "unref" in sweepTimer) {
+  sweepTimer.unref();
+}
+function getClientIp(req) {
+  return req.socket.remoteAddress ?? null;
+}
+function getUserAgent(req) {
+  return req.headers["user-agent"] ?? "unknown";
+}
+var auditLog = [];
+var MAX_AUDIT_ENTRIES = 100;
+function recordAudit(entry) {
+  auditLog.push(entry);
+  if (auditLog.length > MAX_AUDIT_ENTRIES) {
+    auditLog.shift();
+  }
+  const logLine = `[wallet-export-audit] ${entry.outcome} ip=${entry.ip} ua="${entry.userAgent}"${entry.reason ? ` reason="${entry.reason}"` : ""}`;
+  console.warn(logLine);
+}
+function getWalletExportAuditLog() {
+  return [...auditLog];
+}
+function _resetForTesting() {
+  if (false)
+    ;
+  rateLimitMap.clear();
+  pendingExportNonces.clear();
+  auditLog.length = 0;
+}
+var EXPORT_DELAY_MS = 1e4;
+var MAX_PENDING_NONCES_PER_IP = 3;
+var pendingExportNonces = new Map;
+var NONCE_TTL_MS = 5 * 60 * 1000;
+function issueExportNonce(ip) {
+  const now = Date.now();
+  for (const [key, value] of pendingExportNonces) {
+    if (now - value.issuedAt > NONCE_TTL_MS) {
+      pendingExportNonces.delete(key);
+    }
+  }
+  let countForIp = 0;
+  for (const entry of pendingExportNonces.values()) {
+    if (entry.ip === ip)
+      countForIp++;
+  }
+  if (countForIp >= MAX_PENDING_NONCES_PER_IP) {
+    return null;
+  }
+  const nonce = `wxn_${crypto.randomBytes(16).toString("hex")}`;
+  pendingExportNonces.set(nonce, { issuedAt: Date.now(), ip });
+  return nonce;
+}
+function validateExportNonce(nonce, ip) {
+  const entry = pendingExportNonces.get(nonce);
+  if (!entry) {
+    return { valid: false, reason: "Invalid or expired export nonce." };
+  }
+  if (entry.ip !== ip) {
+    return {
+      valid: false,
+      reason: "Export nonce was issued to a different client."
+    };
+  }
+  const elapsed = Date.now() - entry.issuedAt;
+  if (elapsed < EXPORT_DELAY_MS) {
+    const remaining = Math.ceil((EXPORT_DELAY_MS - elapsed) / 1000);
+    return {
+      valid: false,
+      reason: `Export confirmation delay not met. Wait ${remaining} more seconds.`
+    };
+  }
+  pendingExportNonces.delete(nonce);
+  return { valid: true };
+}
+function createHardenedExportGuard(upstream) {
+  return (req, body) => {
+    const ip = getClientIp(req);
+    const ua = getUserAgent(req);
+    if (!ip) {
+      recordAudit({
+        timestamp: new Date().toISOString(),
+        ip: "unknown",
+        userAgent: ua,
+        outcome: "rejected",
+        reason: "No client IP available on socket"
+      });
+      return {
+        status: 400,
+        reason: "Unable to determine client IP; request rejected."
+      };
+    }
+    const upstreamRejection = upstream(req, body);
+    if (upstreamRejection) {
+      recordAudit({
+        timestamp: new Date().toISOString(),
+        ip,
+        userAgent: ua,
+        outcome: "rejected",
+        reason: upstreamRejection.reason
+      });
+      return upstreamRejection;
+    }
+    if (body.requestNonce) {
+      const nonce = issueExportNonce(ip);
+      if (!nonce) {
+        recordAudit({
+          timestamp: new Date().toISOString(),
+          ip,
+          userAgent: ua,
+          outcome: "rejected",
+          reason: "Too many pending nonces for this IP"
+        });
+        return {
+          status: 429,
+          reason: `Too many pending export requests. Complete or wait for existing nonces to expire.`
+        };
+      }
+      recordAudit({
+        timestamp: new Date().toISOString(),
+        ip,
+        userAgent: ua,
+        outcome: "rejected",
+        reason: "Nonce issued, waiting for confirmation delay"
+      });
+      return {
+        status: 403,
+        reason: JSON.stringify({
+          countdown: true,
+          nonce,
+          delaySeconds: EXPORT_DELAY_MS / 1000,
+          message: `Export nonce issued. Wait ${EXPORT_DELAY_MS / 1000} seconds, then re-submit with exportNonce: "${nonce}".`
+        })
+      };
+    }
+    if (!body.exportNonce) {
+      recordAudit({
+        timestamp: new Date().toISOString(),
+        ip,
+        userAgent: ua,
+        outcome: "rejected",
+        reason: "Missing export nonce"
+      });
+      return {
+        status: 403,
+        reason: 'Export requires a confirmation delay. First send { "confirm": true, "exportToken": "...", "requestNonce": true } to start the countdown.'
+      };
+    }
+    const nonceResult = validateExportNonce(body.exportNonce, ip);
+    if (!nonceResult.valid) {
+      recordAudit({
+        timestamp: new Date().toISOString(),
+        ip,
+        userAgent: ua,
+        outcome: "rejected",
+        reason: nonceResult.reason
+      });
+      return { status: 403, reason: nonceResult.reason };
+    }
+    const rateLimitEntry = rateLimitMap.get(ip);
+    if (rateLimitEntry) {
+      const elapsed = Date.now() - rateLimitEntry.lastExportAt;
+      if (elapsed < RATE_LIMIT_WINDOW_MS) {
+        const retryAfter = Math.ceil((RATE_LIMIT_WINDOW_MS - elapsed) / 1000);
+        recordAudit({
+          timestamp: new Date().toISOString(),
+          ip,
+          userAgent: ua,
+          outcome: "rate-limited",
+          reason: `Rate limited, retry after ${retryAfter}s`
+        });
+        return {
+          status: 429,
+          reason: `Rate limit exceeded. One export per ${RATE_LIMIT_WINDOW_MS / 60000} minutes. Retry after ${retryAfter} seconds.`
+        };
+      }
+    }
+    rateLimitMap.set(ip, { lastExportAt: Date.now() });
+    recordAudit({
+      timestamp: new Date().toISOString(),
+      ip,
+      userAgent: ua,
+      outcome: "allowed"
+    });
+    return null;
+  };
+}
+
+// src/lib/server-wallet-trade.ts
+function normalizeCompatReason(reason) {
+  return reason;
+}
+function mirrorCompatHeaders(req) {
+  const HEADER_ALIASES = [
+    ["x-elizaos-token", "x-eliza-token"],
+    ["x-elizaos-export-token", "x-eliza-export-token"],
+    ["x-elizaos-client-id", "x-eliza-client-id"],
+    ["x-elizaos-terminal-token", "x-eliza-terminal-token"],
+    ["x-elizaos-ui-language", "x-eliza-ui-language"],
+    ["x-elizaos-agent-action", "x-eliza-agent-action"]
+  ];
+  for (const [appHeader, elizaHeader] of HEADER_ALIASES) {
+    const appValue = req.headers[appHeader];
+    const elizaValue = req.headers[elizaHeader];
+    if (appValue != null && elizaValue == null) {
+      req.headers[elizaHeader] = appValue;
+    }
+    if (elizaValue != null && appValue == null) {
+      req.headers[appHeader] = elizaValue;
+    }
+  }
+}
+function normalizeCompatRejection(rejection) {
+  if (!rejection) {
+    return rejection;
+  }
+  return {
+    ...rejection,
+    reason: normalizeCompatReason(rejection.reason)
+  };
+}
+function runWithCompatAuthContext(req, operation) {
+  syncElizaEnvAliases();
+  syncAppEnvToEliza();
+  mirrorCompatHeaders(req);
+  try {
+    return operation();
+  } finally {
+    syncAppEnvToEliza();
+    syncElizaEnvAliases();
+  }
+}
+function tokenMatches(expected, provided) {
+  const a = Buffer.from(expected, "utf8");
+  const b = Buffer.from(provided, "utf8");
+  if (a.length !== b.length)
+    return false;
+  return crypto2.timingSafeEqual(a, b);
+}
+function resolveBaseWalletExportRejection(req, body) {
+  if (!body.confirm) {
+    return {
+      status: 403,
+      reason: 'Export requires explicit confirmation. Send { "confirm": true } in the request body.'
+    };
+  }
+  const expected = process.env.ELIZA_WALLET_EXPORT_TOKEN?.trim();
+  if (!expected) {
+    return {
+      status: 403,
+      reason: "Wallet export is disabled. Set ELIZA_WALLET_EXPORT_TOKEN to enable secure exports."
+    };
+  }
+  const headerToken = typeof req.headers["x-eliza-export-token"] === "string" ? req.headers["x-eliza-export-token"].trim() : "";
+  const bodyToken = typeof body.exportToken === "string" ? body.exportToken.trim() : "";
+  const provided = headerToken || bodyToken;
+  if (!provided) {
+    return {
+      status: 401,
+      reason: "Missing export token. Provide X-Eliza-Export-Token header or exportToken in request body."
+    };
+  }
+  if (!tokenMatches(expected, provided)) {
+    return { status: 401, reason: "Invalid export token." };
+  }
+  return null;
+}
+function resolveCompatWalletExportRejection(req, body) {
+  return runWithCompatAuthContext(req, () => normalizeCompatRejection(resolveBaseWalletExportRejection(req, body)));
+}
+var hardenedGuard = createHardenedExportGuard(resolveCompatWalletExportRejection);
+function resolveTradePermissionMode(config) {
+  const raw = config.features?.tradePermissionMode;
+  if (raw === "user-sign-only" || raw === "manual-local-key" || raw === "agent-auto") {
+    return raw;
+  }
+  return "user-sign-only";
+}
+function canUseLocalTradeExecution(mode, isAgent) {
+  if (mode === "agent-auto") {
+    return true;
+  }
+  if (mode === "manual-local-key") {
+    return !isAgent;
+  }
+  return false;
+}
+function resolveWalletExportRejection(req, body) {
+  return runWithCompatAuthContext(req, () => normalizeCompatRejection(hardenedGuard(req, body)));
+}
+export {
+  runWithCompatAuthContext,
+  resolveWalletExportRejection,
+  resolveTradePermissionMode,
+  normalizeCompatRejection,
+  canUseLocalTradeExecution
+};
+
+//# debugId=1020875127A12AF164756E2164756E21

package/dist/lib/server-wallet-trade.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/lib/server-wallet-trade.ts", "../src/lib/wallet-export-guard.ts"],
+  "sourcesContent": [
+    "/**\n * Wallet / trade compat helpers — trade permission modes, local execution\n * guards, and wallet export rejection wrappers.\n *\n * Exported from the `@elizaos/plugin-wallet` barrel for package consumers.\n */\nimport crypto from \"node:crypto\";\nimport type http from \"node:http\";\nimport { syncAppEnvToEliza, syncElizaEnvAliases } from \"@elizaos/core\";\n\nimport type { WalletExportRequestBody } from \"../contracts.js\";\nimport {\n  type WalletExportRejection as CompatWalletExportRejection,\n  createHardenedExportGuard,\n} from \"./wallet-export-guard\";\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nfunction normalizeCompatReason(reason: string): string {\n  return reason;\n}\n\nfunction mirrorCompatHeaders(req: Pick<http.IncomingMessage, \"headers\">): void {\n  const HEADER_ALIASES = [\n    [\"x-elizaos-token\", \"x-eliza-token\"],\n    [\"x-elizaos-export-token\", \"x-eliza-export-token\"],\n    [\"x-elizaos-client-id\", \"x-eliza-client-id\"],\n    [\"x-elizaos-terminal-token\", \"x-eliza-terminal-token\"],\n    [\"x-elizaos-ui-language\", \"x-eliza-ui-language\"],\n    [\"x-elizaos-agent-action\", \"x-eliza-agent-action\"],\n  ] as const;\n\n  for (const [appHeader, elizaHeader] of HEADER_ALIASES) {\n    const appValue = req.headers[appHeader];\n    const elizaValue = req.headers[elizaHeader];\n\n    if (appValue != null && elizaValue == null) {\n      req.headers[elizaHeader] = appValue;\n    }\n\n    if (elizaValue != null && appValue == null) {\n      req.headers[appHeader] = elizaValue;\n    }\n  }\n}\n\nexport function normalizeCompatRejection<\n  T extends { status: number; reason: string } | null,\n>(rejection: T): T {\n  if (!rejection) {\n    return rejection;\n  }\n\n  return {\n    ...rejection,\n    reason: normalizeCompatReason(rejection.reason),\n  } as T;\n}\n\nexport function runWithCompatAuthContext<T>(\n  req: Pick<http.IncomingMessage, \"headers\">,\n  operation: () => T,\n): T {\n  syncElizaEnvAliases();\n  syncAppEnvToEliza();\n  mirrorCompatHeaders(req);\n\n  try {\n    return operation();\n  } finally {\n    syncAppEnvToEliza();\n    syncElizaEnvAliases();\n  }\n}\n\nfunction tokenMatches(expected: string, provided: string): boolean {\n  const a = Buffer.from(expected, \"utf8\");\n  const b = Buffer.from(provided, \"utf8\");\n  if (a.length !== b.length) return false;\n  return crypto.timingSafeEqual(a, b);\n}\n\nfunction resolveBaseWalletExportRejection(\n  req: http.IncomingMessage,\n  body: WalletExportRequestBody,\n): CompatWalletExportRejection | null {\n  if (!body.confirm) {\n    return {\n      status: 403,\n      reason:\n        'Export requires explicit confirmation. Send { \"confirm\": true } in the request body.',\n    };\n  }\n\n  const expected = process.env.ELIZA_WALLET_EXPORT_TOKEN?.trim();\n  if (!expected) {\n    return {\n      status: 403,\n      reason:\n        \"Wallet export is disabled. Set ELIZA_WALLET_EXPORT_TOKEN to enable secure exports.\",\n    };\n  }\n\n  const headerToken =\n    typeof req.headers[\"x-eliza-export-token\"] === \"string\"\n      ? req.headers[\"x-eliza-export-token\"].trim()\n      : \"\";\n  const bodyToken =\n    typeof body.exportToken === \"string\" ? body.exportToken.trim() : \"\";\n  const provided = headerToken || bodyToken;\n\n  if (!provided) {\n    return {\n      status: 401,\n      reason:\n        \"Missing export token. Provide X-Eliza-Export-Token header or exportToken in request body.\",\n    };\n  }\n\n  if (!tokenMatches(expected, provided)) {\n    return { status: 401, reason: \"Invalid export token.\" };\n  }\n\n  return null;\n}\n\nfunction resolveCompatWalletExportRejection(\n  req: http.IncomingMessage,\n  body: WalletExportRequestBody,\n): CompatWalletExportRejection | null {\n  return runWithCompatAuthContext(req, () =>\n    normalizeCompatRejection(resolveBaseWalletExportRejection(req, body)),\n  );\n}\n\n// Create the hardened guard with the compat rejection resolver\nconst hardenedGuard = createHardenedExportGuard(\n  resolveCompatWalletExportRejection,\n);\n\n// ---------------------------------------------------------------------------\n// Exported types and functions\n// ---------------------------------------------------------------------------\n\nexport type TradePermissionMode =\n  | \"user-sign-only\"\n  | \"manual-local-key\"\n  | \"agent-auto\";\n\nexport function resolveTradePermissionMode(config: {\n  features?: { tradePermissionMode?: unknown } | null;\n}): TradePermissionMode {\n  const raw = config.features?.tradePermissionMode;\n  if (\n    raw === \"user-sign-only\" ||\n    raw === \"manual-local-key\" ||\n    raw === \"agent-auto\"\n  ) {\n    return raw;\n  }\n  return \"user-sign-only\";\n}\n\nexport function canUseLocalTradeExecution(\n  mode: TradePermissionMode,\n  isAgent: boolean,\n): boolean {\n  if (mode === \"agent-auto\") {\n    return true;\n  }\n  if (mode === \"manual-local-key\") {\n    return !isAgent;\n  }\n  return false;\n}\n\n/**\n * Hardened wallet export rejection function.\n *\n * Wraps the upstream token validation with per-IP rate limiting (1 per 10 min),\n * audit logging (IP + UA), and a 10s confirmation delay via single-use nonces.\n */\nexport function resolveWalletExportRejection(\n  req: http.IncomingMessage,\n  body: WalletExportRequestBody,\n): CompatWalletExportRejection | null {\n  return runWithCompatAuthContext(req, () =>\n    normalizeCompatRejection(hardenedGuard(req, body)),\n  );\n}\n",
+    "/**\n * Hardened wallet private key export guard.\n *\n * Wraps the upstream resolveWalletExportRejection with:\n *   1. Per-IP rate limiting (1 successful export per 10 minutes)\n *   2. Audit logging with IP, User-Agent, and timestamp\n *   3. Forced confirmation delay (10s countdown)\n *\n * The upstream function validates the export token. This module adds\n * defence-in-depth so a compromised session cannot instantly extract\n * keys without leaving an audit trail and hitting rate limits.\n *\n * Exported from the `@elizaos/plugin-wallet` barrel for package consumers.\n */\n\nimport crypto from \"node:crypto\";\nimport type http from \"node:http\";\nimport type {\n  WalletExportRejection,\n  WalletExportRequestBody,\n} from \"../contracts.js\";\n\nexport type { WalletExportRejection };\n\ntype UpstreamRejectionFn = (\n  req: http.IncomingMessage,\n  body: WalletExportRequestBody,\n) => WalletExportRejection | null;\n\n// ── Rate limiter state ───────────────────────────────────────────────────────\n\ninterface RateLimitEntry {\n  lastExportAt: number;\n}\n\nconst RATE_LIMIT_WINDOW_MS = 10 * 60 * 1000; // 10 minutes\nconst RATE_LIMIT_SWEEP_INTERVAL_MS = 15 * 60 * 1000; // sweep stale entries\n\nconst rateLimitMap = new Map<string, RateLimitEntry>();\n\n// Periodic sweep to prevent unbounded memory growth\nconst sweepTimer = setInterval(() => {\n  const now = Date.now();\n  for (const [key, entry] of rateLimitMap) {\n    if (now - entry.lastExportAt > RATE_LIMIT_WINDOW_MS * 2) {\n      rateLimitMap.delete(key);\n    }\n  }\n}, RATE_LIMIT_SWEEP_INTERVAL_MS);\n\n// Allow the process to exit without this timer holding it\nif (typeof sweepTimer === \"object\" && \"unref\" in sweepTimer) {\n  sweepTimer.unref();\n}\n\n// ── Helpers ──────────────────────────────────────────────────────────────────\n\n/**\n * Get client IP from the socket directly. X-Forwarded-For is not trusted\n * because this is a local server — trusting XFF would let attackers spoof\n * IPs to bypass rate limits and nonce IP binding.\n */\nfunction getClientIp(req: http.IncomingMessage): string | null {\n  return req.socket.remoteAddress ?? null;\n}\n\nfunction getUserAgent(req: http.IncomingMessage): string {\n  return (req.headers[\"user-agent\"] as string) ?? \"unknown\";\n}\n\n// ── Audit log ────────────────────────────────────────────────────────────────\n\nexport interface WalletExportAuditEntry {\n  timestamp: string;\n  ip: string;\n  userAgent: string;\n  outcome: \"allowed\" | \"rate-limited\" | \"rejected\";\n  reason?: string;\n}\n\n// Keep last 100 entries in memory for diagnostics; also write to logger\nconst auditLog: WalletExportAuditEntry[] = [];\nconst MAX_AUDIT_ENTRIES = 100;\n\nfunction recordAudit(entry: WalletExportAuditEntry): void {\n  auditLog.push(entry);\n  if (auditLog.length > MAX_AUDIT_ENTRIES) {\n    auditLog.shift();\n  }\n\n  const logLine = `[wallet-export-audit] ${entry.outcome} ip=${entry.ip} ua=\"${entry.userAgent}\"${entry.reason ? ` reason=\"${entry.reason}\"` : \"\"}`;\n  console.warn(logLine);\n}\n\n/** Read-only snapshot of the audit log for diagnostics endpoints. */\nexport function getWalletExportAuditLog(): ReadonlyArray<WalletExportAuditEntry> {\n  return [...auditLog];\n}\n\n/** Reset all internal state (rate limits, nonces, audit log). Test-only. */\nexport function _resetForTesting(): void {\n  if (process.env.NODE_ENV === \"production\") return;\n  rateLimitMap.clear();\n  pendingExportNonces.clear();\n  auditLog.length = 0;\n}\n\n// ── Confirmation delay ───────────────────────────────────────────────────────\n\nconst EXPORT_DELAY_MS = 10_000; // 10 seconds\nconst MAX_PENDING_NONCES_PER_IP = 3;\n\n/**\n * Issue a time-limited export nonce.  The client must wait at least\n * EXPORT_DELAY_MS before submitting the actual export request with this nonce.\n */\nconst pendingExportNonces = new Map<string, { issuedAt: number; ip: string }>();\nconst NONCE_TTL_MS = 5 * 60 * 1000; // 5 minutes\n\nfunction issueExportNonce(ip: string): string | null {\n  // Sweep expired nonces\n  const now = Date.now();\n  for (const [key, value] of pendingExportNonces) {\n    if (now - value.issuedAt > NONCE_TTL_MS) {\n      pendingExportNonces.delete(key);\n    }\n  }\n\n  // Cap pending nonces per IP to prevent unbounded growth from repeated\n  // requestNonce calls (which are rate-limit-exempt).\n  let countForIp = 0;\n  for (const entry of pendingExportNonces.values()) {\n    if (entry.ip === ip) countForIp++;\n  }\n  if (countForIp >= MAX_PENDING_NONCES_PER_IP) {\n    return null;\n  }\n\n  const nonce = `wxn_${crypto.randomBytes(16).toString(\"hex\")}`;\n  pendingExportNonces.set(nonce, { issuedAt: Date.now(), ip });\n\n  return nonce;\n}\n\nfunction validateExportNonce(\n  nonce: string,\n  ip: string,\n): { valid: true } | { valid: false; reason: string } {\n  const entry = pendingExportNonces.get(nonce);\n  if (!entry) {\n    return { valid: false, reason: \"Invalid or expired export nonce.\" };\n  }\n\n  if (entry.ip !== ip) {\n    return {\n      valid: false,\n      reason: \"Export nonce was issued to a different client.\",\n    };\n  }\n\n  const elapsed = Date.now() - entry.issuedAt;\n  if (elapsed < EXPORT_DELAY_MS) {\n    const remaining = Math.ceil((EXPORT_DELAY_MS - elapsed) / 1000);\n    return {\n      valid: false,\n      reason: `Export confirmation delay not met. Wait ${remaining} more seconds.`,\n    };\n  }\n\n  // Nonce consumed — delete it\n  pendingExportNonces.delete(nonce);\n  return { valid: true };\n}\n\n// ── Extended request body (adds nonce field) ─────────────────────────────────\n\ninterface HardenedExportRequestBody extends WalletExportRequestBody {\n  exportNonce?: string;\n  /** Client sends requestNonce: true to start the countdown flow. */\n  requestNonce?: boolean;\n}\n\n// ── Main guard ───────────────────────────────────────────────────────────────\n\n/**\n * Create a hardened wallet export rejection function that wraps the upstream\n * token validation with rate limiting, audit logging, and a forced delay.\n *\n * Two-phase export flow:\n *   1. POST /api/wallet/export  { confirm: true, exportToken: \"...\", requestNonce: true }\n *      → 403 with { nonce, delaySeconds } — client must wait\n *   2. POST /api/wallet/export  { confirm: true, exportToken: \"...\", exportNonce: \"wxn_...\" }\n *      → 200 with keys (if delay elapsed and rate limit not hit)\n */\nexport function createHardenedExportGuard(\n  upstream: UpstreamRejectionFn,\n): (\n  req: http.IncomingMessage,\n  body: HardenedExportRequestBody,\n) => WalletExportRejection | null {\n  return (\n    req: http.IncomingMessage,\n    body: HardenedExportRequestBody,\n  ): WalletExportRejection | null => {\n    const ip = getClientIp(req);\n    const ua = getUserAgent(req);\n\n    // Reject requests with no identifiable client IP — without an IP,\n    // rate-limit and nonce-binding keys collapse, letting unrelated\n    // requests share a single bucket.\n    if (!ip) {\n      recordAudit({\n        timestamp: new Date().toISOString(),\n        ip: \"unknown\",\n        userAgent: ua,\n        outcome: \"rejected\",\n        reason: \"No client IP available on socket\",\n      });\n      return {\n        status: 400,\n        reason: \"Unable to determine client IP; request rejected.\",\n      };\n    }\n\n    // 1. Run upstream validation first (token check, confirm flag)\n    const upstreamRejection = upstream(req, body);\n    if (upstreamRejection) {\n      recordAudit({\n        timestamp: new Date().toISOString(),\n        ip,\n        userAgent: ua,\n        outcome: \"rejected\",\n        reason: upstreamRejection.reason,\n      });\n      return upstreamRejection;\n    }\n\n    // 2. Nonce/delay flow — nonce requests are always allowed (no rate limit)\n    if (body.requestNonce) {\n      const nonce = issueExportNonce(ip);\n      if (!nonce) {\n        recordAudit({\n          timestamp: new Date().toISOString(),\n          ip,\n          userAgent: ua,\n          outcome: \"rejected\",\n          reason: \"Too many pending nonces for this IP\",\n        });\n        return {\n          status: 429,\n          reason: `Too many pending export requests. Complete or wait for existing nonces to expire.`,\n        };\n      }\n      recordAudit({\n        timestamp: new Date().toISOString(),\n        ip,\n        userAgent: ua,\n        outcome: \"rejected\",\n        reason: \"Nonce issued, waiting for confirmation delay\",\n      });\n      return {\n        status: 403,\n        reason: JSON.stringify({\n          countdown: true,\n          nonce,\n          delaySeconds: EXPORT_DELAY_MS / 1000,\n          message: `Export nonce issued. Wait ${EXPORT_DELAY_MS / 1000} seconds, then re-submit with exportNonce: \"${nonce}\".`,\n        }),\n      };\n    }\n\n    if (!body.exportNonce) {\n      recordAudit({\n        timestamp: new Date().toISOString(),\n        ip,\n        userAgent: ua,\n        outcome: \"rejected\",\n        reason: \"Missing export nonce\",\n      });\n      return {\n        status: 403,\n        reason:\n          'Export requires a confirmation delay. First send { \"confirm\": true, \"exportToken\": \"...\", \"requestNonce\": true } to start the countdown.',\n      };\n    }\n\n    const nonceResult = validateExportNonce(body.exportNonce, ip);\n    if (!nonceResult.valid) {\n      recordAudit({\n        timestamp: new Date().toISOString(),\n        ip,\n        userAgent: ua,\n        outcome: \"rejected\",\n        reason: nonceResult.reason,\n      });\n      return { status: 403, reason: nonceResult.reason };\n    }\n\n    // 3. Rate limit check (after nonce validation, before key export)\n    const rateLimitEntry = rateLimitMap.get(ip);\n    if (rateLimitEntry) {\n      const elapsed = Date.now() - rateLimitEntry.lastExportAt;\n      if (elapsed < RATE_LIMIT_WINDOW_MS) {\n        const retryAfter = Math.ceil((RATE_LIMIT_WINDOW_MS - elapsed) / 1000);\n        recordAudit({\n          timestamp: new Date().toISOString(),\n          ip,\n          userAgent: ua,\n          outcome: \"rate-limited\",\n          reason: `Rate limited, retry after ${retryAfter}s`,\n        });\n        return {\n          status: 429,\n          reason: `Rate limit exceeded. One export per ${RATE_LIMIT_WINDOW_MS / 60_000} minutes. Retry after ${retryAfter} seconds.`,\n        };\n      }\n    }\n\n    // 4. All checks passed — record rate limit + audit\n    rateLimitMap.set(ip, { lastExportAt: Date.now() });\n    recordAudit({\n      timestamp: new Date().toISOString(),\n      ip,\n      userAgent: ua,\n      outcome: \"allowed\",\n    });\n\n    return null; // allow export\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "1020875127A12AF164756E2164756E21",
+  "names": []
+}

package/dist/lib/wallet-export-guard.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Hardened wallet private key export guard.
+ *
+ * Wraps the upstream resolveWalletExportRejection with:
+ *   1. Per-IP rate limiting (1 successful export per 10 minutes)
+ *   2. Audit logging with IP, User-Agent, and timestamp
+ *   3. Forced confirmation delay (10s countdown)
+ *
+ * The upstream function validates the export token. This module adds
+ * defence-in-depth so a compromised session cannot instantly extract
+ * keys without leaving an audit trail and hitting rate limits.
+ *
+ * Exported from the `@elizaos/plugin-wallet` barrel for package consumers.
+ */
+import type http from "node:http";
+import type { WalletExportRejection, WalletExportRequestBody } from "../contracts.js";
+export type { WalletExportRejection };
+type UpstreamRejectionFn = (req: http.IncomingMessage, body: WalletExportRequestBody) => WalletExportRejection | null;
+export interface WalletExportAuditEntry {
+    timestamp: string;
+    ip: string;
+    userAgent: string;
+    outcome: "allowed" | "rate-limited" | "rejected";
+    reason?: string;
+}
+/** Read-only snapshot of the audit log for diagnostics endpoints. */
+export declare function getWalletExportAuditLog(): ReadonlyArray<WalletExportAuditEntry>;
+/** Reset all internal state (rate limits, nonces, audit log). Test-only. */
+export declare function _resetForTesting(): void;
+interface HardenedExportRequestBody extends WalletExportRequestBody {
+    exportNonce?: string;
+    /** Client sends requestNonce: true to start the countdown flow. */
+    requestNonce?: boolean;
+}
+/**
+ * Create a hardened wallet export rejection function that wraps the upstream
+ * token validation with rate limiting, audit logging, and a forced delay.
+ *
+ * Two-phase export flow:
+ *   1. POST /api/wallet/export  { confirm: true, exportToken: "...", requestNonce: true }
+ *      → 403 with { nonce, delaySeconds } — client must wait
+ *   2. POST /api/wallet/export  { confirm: true, exportToken: "...", exportNonce: "wxn_..." }
+ *      → 200 with keys (if delay elapsed and rate limit not hit)
+ */
+export declare function createHardenedExportGuard(upstream: UpstreamRejectionFn): (req: http.IncomingMessage, body: HardenedExportRequestBody) => WalletExportRejection | null;

package/dist/lp/actions/liquidity.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "@elizaos/core";
+export declare const liquidityAction: Action;

package/dist/lp/e2e/real-token-tests.d.ts

@@ -0,0 +1,6 @@
+import type { TestSuite } from "@elizaos/core";
+/**
+ * Defines a suite of E2E tests for real token interactions.
+ * These tests interact with actual DEX protocols on Solana mainnet.
+ */
+export declare const realTokenTestsSuite: TestSuite;

package/dist/lp/e2e/scenarios.d.ts

@@ -0,0 +1,9 @@
+import type { TestSuite } from "@elizaos/core";
+/**
+ * Defines a suite of E2E tests for LP Manager plugin real-world Discord/Telegram scenarios.
+ *
+ * These scenarios simulate authentic user interactions with the LP management agent,
+ * covering the complete user journey from onboarding to advanced yield optimization.
+ */
+export declare const lpManagerScenariosSuite: TestSuite;
+export default lpManagerScenariosSuite;

package/dist/lp/e2e/test-utils.d.ts

@@ -0,0 +1,28 @@
+import { type Content, type Entity, type IAgentRuntime, type Room, type World } from "@elizaos/core";
+/**
+ * Sets up a standard scenario environment for an E2E test.
+ *
+ * This function creates a world, a user, and a room, providing an
+ * isolated environment for each test case.
+ *
+ * @param runtime The live IAgentRuntime instance provided by the TestRunner.
+ * @returns A promise that resolves to an object containing the created world, user, and room.
+ */
+export declare function setupScenario(runtime: IAgentRuntime): Promise<{
+    user: Entity;
+    room: Room;
+    world: World;
+}>;
+/**
+ * Simulates a user sending a message and waits for the agent's response.
+ *
+ * This function abstracts the event-driven nature of the message handler
+ * into a simple async function, making tests easier to write and read.
+ *
+ * @param runtime The live IAgentRuntime instance.
+ * @param room The room where the message is sent.
+ * @param user The user entity sending the message.
+ * @param text The content of the message.
+ * @returns A promise that resolves with the agent's response content.
+ */
+export declare function sendMessageAndWaitForResponse(runtime: IAgentRuntime, room: Room, user: Entity, text: string): Promise<Content>;

package/dist/lp/lp-manager-entry.d.ts

@@ -0,0 +1,18 @@
+import { type Plugin } from "@elizaos/core";
+import { liquidityAction } from "./actions/liquidity.ts";
+import { ConcentratedLiquidityService } from "./services/ConcentratedLiquidityService.ts";
+import { DexInteractionService } from "./services/DexInteractionService.ts";
+import { LpManagementService } from "./services/LpManagementService.ts";
+import { UserLpProfileService } from "./services/UserLpProfileService.ts";
+import { VaultService } from "./services/VaultService.ts";
+import { YieldOptimizationService } from "./services/YieldOptimizationService.ts";
+export declare const LP_MANAGER_PLUGIN_NAME = "@elizaos/plugin-lp-manager";
+declare const lpManagerPlugin: Plugin;
+export default lpManagerPlugin;
+export { AerodromeLpService, aerodromePlugin, } from "../chains/evm/dex/aerodrome/index.ts";
+export { PancakeSwapV3LpService, pancakeswapPlugin, } from "../chains/evm/dex/pancakeswp/index.ts";
+export { UniswapV3LpService, uniswapPlugin, } from "../chains/evm/dex/uniswap/index.ts";
+export { orcaPlugin } from "../chains/solana/dex/orca/index.ts";
+export { raydiumPlugin } from "../chains/solana/dex/raydium/index.ts";
+export * from "./types.ts";
+export { ConcentratedLiquidityService, DexInteractionService, LpManagementService, liquidityAction, UserLpProfileService, VaultService, YieldOptimizationService, };

package/dist/lp/services/ConcentratedLiquidityService.d.ts

@@ -0,0 +1,32 @@
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import type { IConcentratedLiquidityService, IConcentratedPosition, IRangeParams } from "../types";
+/**
+ * ConcentratedLiquidityService exposes the concentrated-liquidity surface while
+ * DEX-specific providers add position creation and rebalancing support.
+ */
+export declare class ConcentratedLiquidityService extends Service implements IConcentratedLiquidityService {
+    static readonly serviceType = "concentrated-liquidity";
+    readonly capabilityDescription = "Manages concentrated liquidity positions with range selection and automated rebalancing";
+    static start(runtime: IAgentRuntime): Promise<ConcentratedLiquidityService>;
+    static stop(_runtime: IAgentRuntime): Promise<void>;
+    start(_runtime: IAgentRuntime): Promise<void>;
+    stop(): Promise<void>;
+    createConcentratedPosition(_userId: string, _params: IRangeParams): Promise<IConcentratedPosition>;
+    getConcentratedPositions(userId: string): Promise<IConcentratedPosition[]>;
+    rebalanceConcentratedPosition(_userId: string, _positionId: string, _newRangeParams?: Partial<IRangeParams>): Promise<IConcentratedPosition>;
+    /**
+     * Calculate optimal price range based on volatility and target utilization
+     */
+    calculateOptimalRange(currentPrice: number, rangeWidthPercent: number, _targetUtilization?: number): {
+        priceLower: number;
+        priceUpper: number;
+    };
+    /**
+     * Check if current price is within the position's range
+     */
+    isPriceInRange(currentPrice: number, priceLower: number, priceUpper: number): boolean;
+    /**
+     * Calculate how much of the liquidity is currently active
+     */
+    calculateUtilization(currentPrice: number, priceLower: number, priceUpper: number): number;
+}

package/dist/lp/services/DexInteractionService.d.ts

@@ -0,0 +1,34 @@
+import { type IAgentRuntime, Service } from "@elizaos/core";
+import type { AddLiquidityConfig, IEvmLpService, ILpService, LpPositionDetails, PoolInfo, RemoveLiquidityConfig, TransactionResult } from "../types.ts";
+/**
+ * Backward-compatible facade for older LP manager internals.
+ * New routing and protocol ownership live in LpManagementService.
+ */
+export interface IDexInteractionService extends Service {
+    registerDexService(dexService: ILpService | IEvmLpService): void;
+    getPools(dexName?: string, tokenAMint?: string, tokenBMint?: string): Promise<PoolInfo[]>;
+    addLiquidity(config: AddLiquidityConfig): Promise<TransactionResult>;
+    removeLiquidity(config: RemoveLiquidityConfig): Promise<TransactionResult>;
+    getLpPosition(userId: string, poolIdOrPositionIdentifier: string, dexName: string): Promise<LpPositionDetails | null>;
+    getAllUserLpPositions(userId: string): Promise<LpPositionDetails[]>;
+}
+export declare class DexInteractionService extends Service implements IDexInteractionService {
+    static readonly serviceType = "dex-interaction";
+    readonly capabilityDescription = "Compatibility facade for registered LP protocol providers.";
+    private lpManagementService;
+    private userLpProfileService;
+    static start(runtime: IAgentRuntime): Promise<DexInteractionService>;
+    static stop(_runtime: IAgentRuntime): Promise<void>;
+    start(runtime: IAgentRuntime): Promise<void>;
+    stop(): Promise<void>;
+    rediscoverServices(): void;
+    registerDexService(dexService: ILpService | IEvmLpService): void;
+    getLpService(dexName: string): ILpService | IEvmLpService | undefined;
+    getLpServices(): Array<ILpService | IEvmLpService>;
+    getDexService(dexName: string): ILpService | IEvmLpService;
+    getPools(dexName?: string, tokenAMint?: string, tokenBMint?: string): Promise<PoolInfo[]>;
+    addLiquidity(config: AddLiquidityConfig): Promise<TransactionResult>;
+    removeLiquidity(config: RemoveLiquidityConfig): Promise<TransactionResult>;
+    getLpPosition(userId: string, poolIdOrPositionIdentifier: string, dexName: string): Promise<LpPositionDetails | null>;
+    getAllUserLpPositions(userId: string): Promise<LpPositionDetails[]>;
+}