@elizaos/agent 2.0.0-alpha.97 → 2.0.0-beta.1

package/dist/packages/agent/src/api/terminal-run-limits.js

@@ -0,0 +1,20 @@
+import { parseClampedInteger } from "../utils/number-parsing.js";
+const TERMINAL_RUN_MAX_CONCURRENT_DEFAULT = 2;
+const TERMINAL_RUN_MAX_CONCURRENT_CAP = 16;
+const TERMINAL_RUN_MAX_DURATION_MS_DEFAULT = 5 * 60 * 1000;
+const TERMINAL_RUN_MAX_DURATION_MS_CAP = 60 * 60 * 1000;
+export function resolveTerminalRunLimits() {
+    const maxConcurrentRaw = process.env.ELIZA_TERMINAL_MAX_CONCURRENT;
+    const maxConcurrent = parseClampedInteger(maxConcurrentRaw, {
+        fallback: TERMINAL_RUN_MAX_CONCURRENT_DEFAULT,
+        min: 1,
+        max: TERMINAL_RUN_MAX_CONCURRENT_CAP,
+    });
+    const maxDurationMsRaw = process.env.ELIZA_TERMINAL_MAX_DURATION_MS;
+    const maxDurationMs = parseClampedInteger(maxDurationMsRaw, {
+        fallback: TERMINAL_RUN_MAX_DURATION_MS_DEFAULT,
+        min: 1_000,
+        max: TERMINAL_RUN_MAX_DURATION_MS_CAP,
+    });
+    return { maxConcurrent, maxDurationMs };
+}

package/dist/packages/agent/src/api/trade-safety.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Pure trade safety utilities — no heavy dependencies.
+ * Extracted so they can be unit-tested without pulling in the full server.
+ */
+/** Maximum number of autonomous agent trades allowed per calendar day. */
+export declare const AGENT_AUTO_MAX_DAILY_TRADES = 25;
+/** Maximum age of a trade quote before it is considered stale. */
+export declare const QUOTE_MAX_AGE_MS = 60000;
+/** Tracks autonomous trade count for rate-limiting in agent-auto mode. */
+export declare const agentAutoDailyTrades: {
+    count: number;
+    resetDate: string;
+};
+export declare function getAgentAutoTradeDate(): string;
+/**
+ * Record an autonomous agent trade. Returns true if allowed, false if
+ * the daily limit has been reached. Resets the counter on a new calendar day.
+ */
+export declare function recordAgentAutoTrade(log?: (msg: string) => void): boolean;
+export type TradePermissionMode = "user-sign-only" | "agent-auto" | "manual-local-key" | "disabled";
+type LocalTradeExecutionOptions = {
+    consumeAgentQuota?: boolean;
+};
+/**
+ * Returns true if local-key execution is permitted for the given actor.
+ */
+export declare function canUseLocalTradeExecution(mode: TradePermissionMode, isAgent: boolean, log?: (msg: string) => void, options?: LocalTradeExecutionOptions): boolean;
+/**
+ * Assert that a trade quote is still fresh. Throws if the quote is older
+ * than QUOTE_MAX_AGE_MS. Silently passes if `quotedAt` is undefined
+ * (backwards compatibility with quotes that lack the field).
+ */
+export declare function assertQuoteFresh(quotedAt: number | undefined, now?: number): void;
+export {};
+//# sourceMappingURL=trade-safety.d.ts.map

package/dist/packages/agent/src/api/trade-safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trade-safety.d.ts","sourceRoot":"","sources":["../../../../../src/api/trade-safety.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,0EAA0E;AAC1E,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAE9C,kEAAkE;AAClE,eAAO,MAAM,gBAAgB,QAAS,CAAC;AAEvC,0EAA0E;AAC1E,eAAO,MAAM,oBAAoB;;;CAA8B,CAAC;AAEhE,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAiBzE;AAED,MAAM,MAAM,mBAAmB,GAC3B,gBAAgB,GAChB,YAAY,GACZ,kBAAkB,GAClB,UAAU,CAAC;AAEf,KAAK,0BAA0B,GAAG;IAChC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,mBAAmB,EACzB,OAAO,EAAE,OAAO,EAChB,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,EAC3B,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAgBT;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,GAAG,GAAE,MAAmB,GACvB,IAAI,CAIN"}

package/dist/packages/agent/src/api/trade-safety.js

@@ -0,0 +1,62 @@
+/**
+ * Pure trade safety utilities — no heavy dependencies.
+ * Extracted so they can be unit-tested without pulling in the full server.
+ */
+/** Maximum number of autonomous agent trades allowed per calendar day. */
+export const AGENT_AUTO_MAX_DAILY_TRADES = 25;
+/** Maximum age of a trade quote before it is considered stale. */
+export const QUOTE_MAX_AGE_MS = 60_000; // 60 seconds
+/** Tracks autonomous trade count for rate-limiting in agent-auto mode. */
+export const agentAutoDailyTrades = { count: 0, resetDate: "" };
+export function getAgentAutoTradeDate() {
+    return new Date().toISOString().slice(0, 10);
+}
+/**
+ * Record an autonomous agent trade. Returns true if allowed, false if
+ * the daily limit has been reached. Resets the counter on a new calendar day.
+ */
+export function recordAgentAutoTrade(log) {
+    const today = getAgentAutoTradeDate();
+    if (agentAutoDailyTrades.resetDate !== today) {
+        agentAutoDailyTrades.count = 0;
+        agentAutoDailyTrades.resetDate = today;
+    }
+    if (agentAutoDailyTrades.count >= AGENT_AUTO_MAX_DAILY_TRADES) {
+        log?.(`[trade] Agent-auto daily trade limit reached (${AGENT_AUTO_MAX_DAILY_TRADES}). Rejecting autonomous trade.`);
+        return false;
+    }
+    agentAutoDailyTrades.count += 1;
+    log?.(`[trade] Agent-auto autonomous trade ${agentAutoDailyTrades.count}/${AGENT_AUTO_MAX_DAILY_TRADES} for ${today}`);
+    return true;
+}
+/**
+ * Returns true if local-key execution is permitted for the given actor.
+ */
+export function canUseLocalTradeExecution(mode, isAgent, log, options = {}) {
+    if (mode === "agent-auto") {
+        if (isAgent) {
+            if (options.consumeAgentQuota === false) {
+                const today = getAgentAutoTradeDate();
+                if (agentAutoDailyTrades.resetDate !== today) {
+                    return true;
+                }
+                return agentAutoDailyTrades.count < AGENT_AUTO_MAX_DAILY_TRADES;
+            }
+            return recordAgentAutoTrade(log);
+        }
+        return true;
+    }
+    if (mode === "manual-local-key")
+        return !isAgent;
+    return false;
+}
+/**
+ * Assert that a trade quote is still fresh. Throws if the quote is older
+ * than QUOTE_MAX_AGE_MS. Silently passes if `quotedAt` is undefined
+ * (backwards compatibility with quotes that lack the field).
+ */
+export function assertQuoteFresh(quotedAt, now = Date.now()) {
+    if (quotedAt && now - quotedAt > QUOTE_MAX_AGE_MS) {
+        throw new Error("Quote expired — please request a fresh quote");
+    }
+}

package/dist/packages/agent/src/api/training-service-like.d.ts

@@ -0,0 +1,39 @@
+import type { Trajectory, TrajectoryListResult } from "../types/trajectory.ts";
+export interface TrainingServiceLike {
+    getStatus(): Record<string, unknown>;
+    listTrajectories(options: {
+        limit?: number;
+        offset?: number;
+    }): Promise<TrajectoryListResult>;
+    getTrajectoryById(trajectoryId: string): Promise<Trajectory | null>;
+    listDatasets(): Record<string, unknown>[];
+    buildDataset(options: {
+        limit?: number;
+        minLlmCallsPerTrajectory?: number;
+    }): Promise<Record<string, unknown>>;
+    listJobs(): Record<string, unknown>[];
+    startTrainingJob(options: {
+        datasetId?: string;
+        maxTrajectories?: number;
+        backend?: "mlx" | "cuda" | "cpu";
+        model?: string;
+        iterations?: number;
+        batchSize?: number;
+        learningRate?: number;
+    }): Promise<Record<string, unknown>>;
+    getJob(jobId: string): Record<string, unknown> | null;
+    cancelJob(jobId: string): Promise<Record<string, unknown>>;
+    listModels(): Record<string, unknown>[];
+    importModelToOllama(modelId: string, body: {
+        modelName?: string;
+        baseModel?: string;
+        ollamaUrl?: string;
+    }): Promise<Record<string, unknown>>;
+    activateModel(modelId: string, providerModel?: string): Promise<Record<string, unknown>>;
+    benchmarkModel(modelId: string): Promise<Record<string, unknown>>;
+}
+export interface TrainingServiceWithRuntime extends TrainingServiceLike {
+    initialize(): Promise<void>;
+    subscribe(listener: (event: unknown) => void): () => void;
+}
+//# sourceMappingURL=training-service-like.d.ts.map

package/dist/packages/agent/src/api/training-service-like.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"training-service-like.d.ts","sourceRoot":"","sources":["../../../../../src/api/training-service-like.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE/E,MAAM,WAAW,mBAAmB;IAClC,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,gBAAgB,CAAC,OAAO,EAAE;QACxB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAClC,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IACpE,YAAY,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAC1C,YAAY,CAAC,OAAO,EAAE;QACpB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,wBAAwB,CAAC,EAAE,MAAM,CAAC;KACnC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACrC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACtC,gBAAgB,CAAC,OAAO,EAAE;QACxB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,OAAO,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,CAAC;QACjC,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACrC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACtD,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3D,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACxC,mBAAmB,CACjB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE;QACJ,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,GACA,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACpC,aAAa,CACX,OAAO,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACpC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACnE;AAED,MAAM,WAAW,0BAA2B,SAAQ,mBAAmB;IACrE,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CAC3D"}

package/dist/packages/agent/src/api/travel-provider-relay-routes.d.ts

@@ -0,0 +1,9 @@
+import type http from "node:http";
+import { type IAgentRuntime } from "@elizaos/core";
+import type { CloudProxyConfigLike } from "../types/config-like.ts";
+export interface TravelProviderRelayRouteState {
+    config: CloudProxyConfigLike;
+    runtime?: IAgentRuntime | null;
+}
+export declare function handleTravelProviderRelayRoute(req: http.IncomingMessage, res: http.ServerResponse, pathname: string, method: string, state: TravelProviderRelayRouteState): Promise<boolean>;
+//# sourceMappingURL=travel-provider-relay-routes.d.ts.map

package/dist/packages/agent/src/api/travel-provider-relay-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"travel-provider-relay-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/travel-provider-relay-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,KAAK,aAAa,EAA+B,MAAM,eAAe,CAAC;AAOhF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEpE,MAAM,WAAW,6BAA6B;IAC5C,MAAM,EAAE,oBAAoB,CAAC;IAC7B,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;CAChC;AA+HD,wBAAsB,8BAA8B,CAClD,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,6BAA6B,GACnC,OAAO,CAAC,OAAO,CAAC,CAwDlB"}

package/dist/packages/agent/src/api/travel-provider-relay-routes.js

@@ -0,0 +1,143 @@
+import { sendJsonError } from "@elizaos/core";
+import { normalizeCloudSiteUrl, resolveCloudApiKey, validateCloudBaseUrl, } from "@elizaos/plugin-elizacloud";
+import { sendJson } from "@elizaos/shared";
+const PROXY_TIMEOUT_MS = 30_000;
+const MAX_BODY_BYTES = 1_048_576;
+const TRAVEL_PROVIDER_PATH_RE = /^\/api\/cloud\/travel-providers\/([a-z0-9][a-z0-9-]*)(\/.*)$/;
+function normalizeCloudApiKey(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.toUpperCase() === "[REDACTED]")
+        return null;
+    return trimmed;
+}
+function resolveProxyApiKey(state) {
+    const cloudAuth = state.runtime
+        ? state.runtime.getService("CLOUD_AUTH")
+        : null;
+    const runtimeApiKey = cloudAuth?.isAuthenticated() === true
+        ? normalizeCloudApiKey(cloudAuth.getApiKey?.())
+        : null;
+    return runtimeApiKey ?? resolveCloudApiKey(state.config, state.runtime);
+}
+function buildAuthHeaders(config, apiKey) {
+    const serviceKey = config.cloud?.serviceKey?.trim();
+    const headers = {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+    };
+    if (serviceKey)
+        headers["X-Service-Key"] = serviceKey;
+    return headers;
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > MAX_BODY_BYTES) {
+                reject(new Error("Request body too large"));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => resolve(chunks.length > 0 ? Buffer.concat(chunks).toString("utf-8") : undefined));
+        req.on("error", reject);
+    });
+}
+async function readJsonResponse(response) {
+    return response.json().catch(async () => ({
+        success: response.ok,
+        error: await response
+            .text()
+            .catch(() => "Travel-provider relay request failed"),
+    }));
+}
+function parseTravelProviderPath(pathname) {
+    const match = TRAVEL_PROVIDER_PATH_RE.exec(pathname);
+    if (!match)
+        return null;
+    const [, provider, providerPath] = match;
+    return provider ? { provider, providerPath } : null;
+}
+function buildUpstreamPath(localPath) {
+    const parsed = parseTravelProviderPath(localPath);
+    if (!parsed) {
+        throw new Error("Invalid travel-provider relay path");
+    }
+    return `/api/v1/${parsed.provider}${parsed.providerPath}`;
+}
+const TRAVEL_PROVIDER_RELAY_ROUTES = [
+    { method: "POST", pattern: /^\/offer-requests$/ },
+    { method: "GET", pattern: /^\/offers\/[^/]+$/ },
+    { method: "POST", pattern: /^\/orders$/ },
+    { method: "GET", pattern: /^\/orders\/[^/]+$/ },
+    { method: "POST", pattern: /^\/payments$/ },
+];
+function matchRoute(method, pathname) {
+    const parsed = parseTravelProviderPath(pathname);
+    if (!parsed)
+        return false;
+    return TRAVEL_PROVIDER_RELAY_ROUTES.some((route) => route.method === method && route.pattern.test(parsed.providerPath));
+}
+async function forward402(res, upstream) {
+    const wwwAuth = upstream.headers.get("www-authenticate");
+    const contentType = upstream.headers.get("content-type") ?? "application/json";
+    const bodyText = await upstream.text();
+    res.statusCode = 402;
+    res.setHeader("Content-Type", contentType);
+    if (wwwAuth)
+        res.setHeader("WWW-Authenticate", wwwAuth);
+    res.end(bodyText);
+}
+export async function handleTravelProviderRelayRoute(req, res, pathname, method, state) {
+    const parsed = parseTravelProviderPath(pathname);
+    if (!parsed)
+        return false;
+    if (!matchRoute(method, pathname)) {
+        sendJsonError(res, "Unknown travel-provider relay route", 404);
+        return true;
+    }
+    const apiKey = resolveProxyApiKey(state);
+    if (!apiKey) {
+        sendJsonError(res, "Not connected to Eliza Cloud. Sign in to use travel search.", 401);
+        return true;
+    }
+    const baseUrl = normalizeCloudSiteUrl(state.config.cloud?.baseUrl);
+    const urlError = await validateCloudBaseUrl(baseUrl);
+    if (urlError) {
+        sendJsonError(res, urlError, 502);
+        return true;
+    }
+    const headers = buildAuthHeaders(state.config, apiKey);
+    let body;
+    if (method === "POST") {
+        try {
+            body = await readBody(req);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Failed to read body";
+            sendJsonError(res, msg, 413);
+            return true;
+        }
+    }
+    const fullUrl = new URL(req.url ?? pathname, "http://localhost");
+    const upstreamUrl = `${baseUrl}${buildUpstreamPath(pathname)}${fullUrl.search}`;
+    const upstreamResponse = await fetch(upstreamUrl, {
+        method,
+        headers,
+        body,
+        redirect: "manual",
+        signal: AbortSignal.timeout(PROXY_TIMEOUT_MS),
+    });
+    if (upstreamResponse.status === 402) {
+        await forward402(res, upstreamResponse);
+        return true;
+    }
+    const payload = await readJsonResponse(upstreamResponse);
+    sendJson(res, payload, upstreamResponse.status);
+    return true;
+}

package/dist/packages/agent/src/api/tx-service.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Ethereum transaction signing and contract interaction layer.
+ *
+ * Provides the missing transaction capability to Eliza's wallet system,
+ * which currently only handles key generation and balance fetching.
+ * Used by the registry and drop services for on-chain operations.
+ */
+import { ethers } from "ethers";
+export interface JsonRpcEndpointProbeResult {
+    ok: boolean;
+    reason?: string;
+}
+export declare function normalizeJsonRpcUrl(rpcUrl: string): string;
+export declare function probeJsonRpcEndpoint(rpcUrl: string, timeoutMs?: number): Promise<JsonRpcEndpointProbeResult>;
+export declare class TxService {
+    private readonly provider;
+    private readonly wallet;
+    private readonly rpcUrl;
+    constructor(rpcUrl: string, privateKey: string);
+    /**
+     * Get fresh nonce for the wallet address.
+     * Always fetches from blockchain using a fresh provider to avoid caching issues.
+     * This ensures we always get the correct nonce even after failed transactions.
+     */
+    getFreshNonce(): Promise<number>;
+    get address(): string;
+    getBalance(): Promise<bigint>;
+    getBalanceFormatted(): Promise<string>;
+    getChainId(): Promise<number>;
+    getContract(address: string, abi: ethers.InterfaceAbi): ethers.Contract;
+    getReadOnlyContract(address: string, abi: ethers.InterfaceAbi): ethers.Contract;
+    estimateGas(tx: ethers.TransactionRequest): Promise<bigint>;
+    getFeeData(): Promise<ethers.FeeData>;
+    /**
+     * Wait for a transaction to be mined and return the receipt.
+     * Throws if the transaction fails or times out.
+     */
+    waitForTransaction(txHash: string, confirmations?: number, timeoutMs?: number): Promise<ethers.TransactionReceipt>;
+    /**
+     * Estimate the gas cost in ETH for a contract call.
+     * Useful for showing users how much gas they'll need.
+     */
+    estimateGasCostEth(tx: ethers.TransactionRequest): Promise<string>;
+    /**
+     * Check whether the wallet has enough balance for a given value + estimated gas.
+     */
+    hasEnoughBalance(value: bigint, gasEstimate: bigint): Promise<boolean>;
+    /**
+     * Log a summary of the tx service state for diagnostics.
+     */
+    logStatus(): Promise<void>;
+}
+//# sourceMappingURL=tx-service.d.ts.map

package/dist/packages/agent/src/api/tx-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx-service.d.ts","sourceRoot":"","sources":["../../../../../src/api/tx-service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAaD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAsB1D;AAED,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,SAAS,SAAQ,GAChB,OAAO,CAAC,0BAA0B,CAAC,CAoDrC;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAwB9C;;;;OAIG;IACG,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC;IAsBtC,IAAI,OAAO,IAAI,MAAM,CAEpB;IAEK,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAI7B,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC;IAKtC,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAKnC,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,YAAY,GAAG,MAAM,CAAC,QAAQ;IAIvE,mBAAmB,CACjB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,CAAC,YAAY,GACvB,MAAM,CAAC,QAAQ;IAIZ,WAAW,CAAC,EAAE,EAAE,MAAM,CAAC,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IAI3D,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;IAI3C;;;OAGG;IACG,kBAAkB,CACtB,MAAM,EAAE,MAAM,EACd,aAAa,GAAE,MAAU,EACzB,SAAS,GAAE,MAAgB,GAC1B,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAiCrC;;;OAGG;IACG,kBAAkB,CAAC,EAAE,EAAE,MAAM,CAAC,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IAQxE;;OAEG;IACG,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ5E;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CASjC"}

package/dist/packages/agent/src/api/tx-service.js

@@ -0,0 +1,217 @@
+/**
+ * Ethereum transaction signing and contract interaction layer.
+ *
+ * Provides the missing transaction capability to Eliza's wallet system,
+ * which currently only handles key generation and balance fetching.
+ * Used by the registry and drop services for on-chain operations.
+ */
+import { logger } from "@elizaos/core";
+import { ethers } from "ethers";
+import { createIntegrationTelemetrySpan } from "../diagnostics/integration-observability.js";
+/**
+ * Validate that a private key is a valid 32-byte hex string.
+ */
+function isValidPrivateKey(key) {
+    const normalized = key.startsWith("0x") ? key.slice(2) : key;
+    // Must be 64 hex characters (32 bytes)
+    if (normalized.length !== 64)
+        return false;
+    // Must be valid hex
+    return /^[0-9a-fA-F]+$/.test(normalized);
+}
+export function normalizeJsonRpcUrl(rpcUrl) {
+    const trimmed = rpcUrl.trim();
+    if (!trimmed) {
+        throw new Error("EVM JSON-RPC URL is required.");
+    }
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        throw new Error(`Invalid EVM JSON-RPC URL "${trimmed}": expected an http(s) URL.`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`Invalid EVM JSON-RPC URL "${trimmed}": expected http: or https:.`);
+    }
+    return parsed.toString();
+}
+export async function probeJsonRpcEndpoint(rpcUrl, timeoutMs = 2_000) {
+    const normalizedRpcUrl = normalizeJsonRpcUrl(rpcUrl);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(normalizedRpcUrl, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "eth_chainId",
+                params: [],
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                reason: `HTTP ${response.status} ${response.statusText}`.trim(),
+            };
+        }
+        const body = (await response.json());
+        if (typeof body.result === "string" &&
+            /^0x[0-9a-fA-F]+$/.test(body.result)) {
+            return { ok: true };
+        }
+        const errorMessage = typeof body.error?.message === "string"
+            ? body.error.message
+            : "missing eth_chainId result";
+        return { ok: false, reason: errorMessage };
+    }
+    catch (err) {
+        const message = err instanceof Error && err.name === "AbortError"
+            ? `timed out after ${timeoutMs}ms`
+            : err instanceof Error
+                ? err.message
+                : String(err);
+        return { ok: false, reason: message };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export class TxService {
+    provider;
+    wallet;
+    rpcUrl;
+    constructor(rpcUrl, privateKey) {
+        // Validate private key before attempting to create wallet
+        if (!isValidPrivateKey(privateKey)) {
+            const preview = privateKey.length > 10
+                ? `${privateKey.slice(0, 6)}...${privateKey.slice(-4)}`
+                : "(empty or too short)";
+            throw new Error(`Invalid EVM_PRIVATE_KEY: expected 64-character hex string, got ${preview}. ` +
+                `Please set a valid private key in your environment or .env file.`);
+        }
+        this.rpcUrl = normalizeJsonRpcUrl(rpcUrl);
+        this.provider = new ethers.JsonRpcProvider(this.rpcUrl);
+        const normalizedKey = privateKey.startsWith("0x")
+            ? privateKey
+            : `0x${privateKey}`;
+        // Create wallet with provider
+        this.wallet = new ethers.Wallet(normalizedKey, this.provider);
+    }
+    /**
+     * Get fresh nonce for the wallet address.
+     * Always fetches from blockchain using a fresh provider to avoid caching issues.
+     * This ensures we always get the correct nonce even after failed transactions.
+     */
+    async getFreshNonce() {
+        const span = createIntegrationTelemetrySpan({
+            boundary: "wallet",
+            operation: "rpc_get_nonce",
+        });
+        // Use a fresh provider for each nonce lookup to avoid ethers.js v6 caching
+        const freshProvider = new ethers.JsonRpcProvider(this.rpcUrl);
+        try {
+            const nonce = await freshProvider.getTransactionCount(this.wallet.address, "pending");
+            span.success();
+            return nonce;
+        }
+        catch (err) {
+            span.failure({ error: err });
+            throw err;
+        }
+        finally {
+            freshProvider.destroy();
+        }
+    }
+    get address() {
+        return this.wallet.address;
+    }
+    async getBalance() {
+        return this.provider.getBalance(this.wallet.address);
+    }
+    async getBalanceFormatted() {
+        const balance = await this.getBalance();
+        return ethers.formatEther(balance);
+    }
+    async getChainId() {
+        const network = await this.provider.getNetwork();
+        return Number(network.chainId);
+    }
+    getContract(address, abi) {
+        return new ethers.Contract(address, abi, this.wallet);
+    }
+    getReadOnlyContract(address, abi) {
+        return new ethers.Contract(address, abi, this.provider);
+    }
+    async estimateGas(tx) {
+        return this.provider.estimateGas(tx);
+    }
+    async getFeeData() {
+        return this.provider.getFeeData();
+    }
+    /**
+     * Wait for a transaction to be mined and return the receipt.
+     * Throws if the transaction fails or times out.
+     */
+    async waitForTransaction(txHash, confirmations = 1, timeoutMs = 120_000) {
+        const span = createIntegrationTelemetrySpan({
+            boundary: "wallet",
+            operation: "rpc_wait_for_transaction",
+            timeoutMs,
+        });
+        let receipt;
+        try {
+            receipt = await this.provider.waitForTransaction(txHash, confirmations, timeoutMs);
+        }
+        catch (err) {
+            span.failure({ error: err });
+            throw err;
+        }
+        if (!receipt) {
+            const err = new Error(`Transaction ${txHash} timed out after ${timeoutMs}ms`);
+            span.failure({ error: err, errorKind: "timeout" });
+            throw err;
+        }
+        if (receipt.status === 0) {
+            const err = new Error(`Transaction ${txHash} reverted`);
+            span.failure({ error: err, errorKind: "tx_reverted" });
+            throw err;
+        }
+        span.success();
+        return receipt;
+    }
+    /**
+     * Estimate the gas cost in ETH for a contract call.
+     * Useful for showing users how much gas they'll need.
+     */
+    async estimateGasCostEth(tx) {
+        const gasLimit = await this.estimateGas(tx);
+        const feeData = await this.getFeeData();
+        const gasPrice = feeData.gasPrice ?? feeData.maxFeePerGas ?? 0n;
+        const costWei = gasLimit * gasPrice;
+        return ethers.formatEther(costWei);
+    }
+    /**
+     * Check whether the wallet has enough balance for a given value + estimated gas.
+     */
+    async hasEnoughBalance(value, gasEstimate) {
+        const balance = await this.getBalance();
+        const feeData = await this.getFeeData();
+        const gasPrice = feeData.gasPrice ?? feeData.maxFeePerGas ?? 0n;
+        const gasCost = gasEstimate * gasPrice;
+        return balance >= value + gasCost;
+    }
+    /**
+     * Log a summary of the tx service state for diagnostics.
+     */
+    async logStatus() {
+        const [balance, chainId] = await Promise.all([
+            this.getBalanceFormatted(),
+            this.getChainId(),
+        ]);
+        logger.info(`[tx-service] address=${this.address} chain=${chainId} balance=${balance} ETH`);
+    }
+}

package/dist/packages/agent/src/api/update-routes.d.ts

@@ -0,0 +1,19 @@
+import type http from "node:http";
+import type { ReadJsonBodyOptions } from "@elizaos/core";
+import type { ElizaConfig } from "../config/config.ts";
+export interface UpdateRouteContext {
+    req: http.IncomingMessage;
+    res: http.ServerResponse;
+    method: string;
+    pathname: string;
+    url: URL;
+    state: {
+        config: ElizaConfig;
+    };
+    json: (res: http.ServerResponse, data: unknown, status?: number) => void;
+    error: (res: http.ServerResponse, message: string, status?: number) => void;
+    readJsonBody: <T extends object>(req: http.IncomingMessage, res: http.ServerResponse, options?: ReadJsonBodyOptions) => Promise<T | null>;
+    saveElizaConfig: (config: ElizaConfig) => void;
+}
+export declare function handleUpdateRoutes(ctx: UpdateRouteContext): Promise<boolean>;
+//# sourceMappingURL=update-routes.d.ts.map

package/dist/packages/agent/src/api/update-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/update-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAMvD,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,IAAI,CAAC,eAAe,CAAC;IAC1B,GAAG,EAAE,IAAI,CAAC,cAAc,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,GAAG,CAAC;IACT,KAAK,EAAE;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,CAAC;IAC/B,IAAI,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACzE,KAAK,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5E,YAAY,EAAE,CAAC,CAAC,SAAS,MAAM,EAC7B,GAAG,EAAE,IAAI,CAAC,eAAe,EACzB,GAAG,EAAE,IAAI,CAAC,cAAc,EACxB,OAAO,CAAC,EAAE,mBAAmB,KAC1B,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACvB,eAAe,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;CAChD;AAMD,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,kBAAkB,GACtB,OAAO,CAAC,OAAO,CAAC,CA2DlB"}