@elizaos/autonomous 2.0.0-alpha.37

package/dist/packages/autonomous/src/api/trigger-routes.d.ts

@@ -0,0 +1,75 @@
+import { type AgentRuntime, type Task } from "@elizaos/core";
+import type { RouteHelpers, RouteRequestContext } from "./route-helpers";
+export type TriggerRouteHelpers = RouteHelpers;
+interface TriggerConfigLike {
+    triggerId: string;
+    displayName: string;
+    instructions: string;
+    triggerType: string;
+    wakeMode: string;
+    enabled: boolean;
+    createdBy: string;
+    dedupeKey?: string;
+    intervalMs?: number;
+    scheduledAtIso?: string;
+    cronExpression?: string;
+    maxRuns?: number;
+    nextRunAtMs?: number;
+}
+type TriggerTaskMetadataLike = Record<string, unknown> & {
+    triggerRuns?: unknown[];
+};
+type TriggerSummaryLike = Record<string, unknown> & {
+    id?: string;
+    displayName?: string;
+    enabled?: boolean;
+};
+type TriggerDraftLike = {
+    displayName: string;
+    instructions: string;
+    triggerType: string;
+    wakeMode: string;
+    enabled: boolean;
+    createdBy: string;
+    intervalMs?: number;
+    scheduledAtIso?: string;
+    cronExpression?: string;
+    maxRuns?: number;
+};
+export interface TriggerRouteContext extends RouteRequestContext {
+    runtime: AgentRuntime | null;
+    executeTriggerTask: (runtime: AgentRuntime, task: Task, options: {
+        source: string;
+        force: boolean;
+    }) => Promise<unknown>;
+    getTriggerHealthSnapshot: (runtime: AgentRuntime) => Promise<object>;
+    getTriggerLimit: (runtime: AgentRuntime) => number;
+    listTriggerTasks: (runtime: AgentRuntime) => Promise<Task[]>;
+    readTriggerConfig: (task: Task) => TriggerConfigLike | null;
+    readTriggerRuns: (task: Task) => unknown[];
+    taskToTriggerSummary: (task: Task) => TriggerSummaryLike | null;
+    triggersFeatureEnabled: (runtime: AgentRuntime) => boolean;
+    buildTriggerConfig: (params: {
+        draft: TriggerDraftLike;
+        triggerId: string;
+        previous?: TriggerConfigLike;
+    }) => TriggerConfigLike;
+    buildTriggerMetadata: (params: {
+        existingMetadata?: TriggerTaskMetadataLike;
+        trigger: TriggerConfigLike;
+        nowMs: number;
+    }) => TriggerTaskMetadataLike | null;
+    normalizeTriggerDraft: (params: {
+        input: Record<string, unknown>;
+        fallback: TriggerDraftLike;
+    }) => {
+        draft?: TriggerDraftLike;
+        error?: string;
+    };
+    DISABLED_TRIGGER_INTERVAL_MS: number;
+    TRIGGER_TASK_NAME: string;
+    TRIGGER_TASK_TAGS: string[];
+}
+export declare function handleTriggerRoutes(ctx: TriggerRouteContext): Promise<boolean>;
+export {};
+//# sourceMappingURL=trigger-routes.d.ts.map

package/dist/packages/autonomous/src/api/trigger-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/trigger-routes.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,IAAI,EAEV,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEzE,MAAM,MAAM,mBAAmB,GAAG,YAAY,CAAC;AAE/C,UAAU,iBAAiB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,KAAK,uBAAuB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACvD,WAAW,CAAC,EAAE,OAAO,EAAE,CAAC;CACzB,CAAC;AAEF,KAAK,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAClD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,WAAW,mBAAoB,SAAQ,mBAAmB;IAC9D,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;IAC7B,kBAAkB,EAAE,CAClB,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,KACxC,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,wBAAwB,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrE,eAAe,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,MAAM,CAAC;IACnD,gBAAgB,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7D,iBAAiB,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,iBAAiB,GAAG,IAAI,CAAC;IAC5D,eAAe,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,EAAE,CAAC;IAC3C,oBAAoB,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,kBAAkB,GAAG,IAAI,CAAC;IAChE,sBAAsB,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC;IAC3D,kBAAkB,EAAE,CAAC,MAAM,EAAE;QAC3B,KAAK,EAAE,gBAAgB,CAAC;QACxB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;KAC9B,KAAK,iBAAiB,CAAC;IACxB,oBAAoB,EAAE,CAAC,MAAM,EAAE;QAC7B,gBAAgB,CAAC,EAAE,uBAAuB,CAAC;QAC3C,OAAO,EAAE,iBAAiB,CAAC;QAC3B,KAAK,EAAE,MAAM,CAAC;KACf,KAAK,uBAAuB,GAAG,IAAI,CAAC;IACrC,qBAAqB,EAAE,CAAC,MAAM,EAAE;QAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC/B,QAAQ,EAAE,gBAAgB,CAAC;KAC5B,KAAK;QAAE,KAAK,CAAC,EAAE,gBAAgB,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,4BAA4B,EAAE,MAAM,CAAC;IACrC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B;AAqBD,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,mBAAmB,GACvB,OAAO,CAAC,OAAO,CAAC,CAmVlB"}

package/dist/packages/autonomous/src/api/trigger-routes.js

@@ -0,0 +1,268 @@
+import crypto from "node:crypto";
+import { stringToUuid, } from "@elizaos/core";
+function trim(value) {
+    return value.trim().replace(/\s+/g, " ");
+}
+async function findTask(runtime, id, listTriggerTasks, readTriggerConfig) {
+    const tasks = await listTriggerTasks(runtime);
+    return (tasks.find((task) => {
+        const trigger = readTriggerConfig(task);
+        return trigger?.triggerId === id || task.id === id;
+    }) ?? null);
+}
+export async function handleTriggerRoutes(ctx) {
+    const { method, pathname, req, res, runtime, readJsonBody, json, error, executeTriggerTask, getTriggerHealthSnapshot, getTriggerLimit, listTriggerTasks, readTriggerConfig, readTriggerRuns, taskToTriggerSummary, triggersFeatureEnabled, buildTriggerConfig, buildTriggerMetadata, normalizeTriggerDraft, DISABLED_TRIGGER_INTERVAL_MS, TRIGGER_TASK_NAME, TRIGGER_TASK_TAGS, } = ctx;
+    if (!pathname.startsWith("/api/triggers"))
+        return false;
+    if (!runtime) {
+        error(res, "Agent is not running", 503);
+        return true;
+    }
+    if (!triggersFeatureEnabled(runtime) && pathname !== "/api/triggers/health") {
+        error(res, "Triggers are disabled by configuration", 503);
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/triggers/health") {
+        json(res, await getTriggerHealthSnapshot(runtime));
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/triggers") {
+        const tasks = await listTriggerTasks(runtime);
+        const triggers = tasks
+            .map(taskToTriggerSummary)
+            .filter((summary) => summary !== null)
+            .sort((a, b) => String(a.displayName ?? "").localeCompare(String(b.displayName ?? "")));
+        json(res, { triggers });
+        return true;
+    }
+    if (method === "POST" && pathname === "/api/triggers") {
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        const creator = typeof body.createdBy === "string"
+            ? trim(body.createdBy) || "api"
+            : "api";
+        const normalized = normalizeTriggerDraft({
+            input: { ...body, enabled: body.enabled ?? true, createdBy: creator },
+            fallback: {
+                displayName: typeof body.displayName === "string" && trim(body.displayName)
+                    ? trim(body.displayName)
+                    : "New Trigger",
+                instructions: typeof body.instructions === "string" ? trim(body.instructions) : "",
+                triggerType: typeof body.triggerType === "string" ? body.triggerType : "interval",
+                wakeMode: typeof body.wakeMode === "string" ? body.wakeMode : "inject_now",
+                enabled: body.enabled === undefined ? true : body.enabled === true,
+                createdBy: creator,
+                intervalMs: typeof body.intervalMs === "number" ? body.intervalMs : undefined,
+                scheduledAtIso: typeof body.scheduledAtIso === "string"
+                    ? body.scheduledAtIso
+                    : undefined,
+                cronExpression: typeof body.cronExpression === "string"
+                    ? body.cronExpression
+                    : undefined,
+                maxRuns: typeof body.maxRuns === "number" ? body.maxRuns : undefined,
+            },
+        });
+        if (!normalized.draft) {
+            error(res, normalized.error ?? "Invalid trigger request", 400);
+            return true;
+        }
+        const existingTasks = await listTriggerTasks(runtime);
+        const activeCount = existingTasks.filter((task) => {
+            const trigger = readTriggerConfig(task);
+            return trigger?.enabled && trigger.createdBy === creator;
+        }).length;
+        const limit = getTriggerLimit(runtime);
+        if (activeCount >= limit) {
+            error(res, `Active trigger limit reached (${limit})`, 429);
+            return true;
+        }
+        const triggerId = stringToUuid(crypto.randomUUID());
+        const trigger = buildTriggerConfig({ draft: normalized.draft, triggerId });
+        const duplicate = existingTasks.find((task) => {
+            const existingTrigger = readTriggerConfig(task);
+            return (existingTrigger?.enabled &&
+                existingTrigger.dedupeKey &&
+                existingTrigger.dedupeKey === trigger.dedupeKey);
+        });
+        if (duplicate?.id) {
+            error(res, "Equivalent trigger already exists", 409);
+            return true;
+        }
+        const metadata = buildTriggerMetadata({ trigger, nowMs: Date.now() });
+        if (!metadata) {
+            error(res, "Unable to compute trigger schedule", 400);
+            return true;
+        }
+        const roomId = runtime.getService("AUTONOMY")?.getAutonomousRoomId?.();
+        const taskId = await runtime.createTask({
+            name: TRIGGER_TASK_NAME,
+            description: trigger.displayName,
+            roomId,
+            tags: [...TRIGGER_TASK_TAGS],
+            metadata: metadata,
+        });
+        const created = await runtime.getTask(taskId);
+        const summary = created ? taskToTriggerSummary(created) : null;
+        if (!summary) {
+            error(res, "Trigger created but summary could not be generated", 500);
+            return true;
+        }
+        json(res, { trigger: summary }, 201);
+        return true;
+    }
+    const runsMatch = /^\/api\/triggers\/([^/]+)\/runs$/.exec(pathname);
+    if (method === "GET" && runsMatch) {
+        const task = await findTask(runtime, decodeURIComponent(runsMatch[1]), listTriggerTasks, readTriggerConfig);
+        if (!task) {
+            error(res, "Trigger not found", 404);
+            return true;
+        }
+        json(res, { runs: readTriggerRuns(task) });
+        return true;
+    }
+    const execMatch = /^\/api\/triggers\/([^/]+)\/execute$/.exec(pathname);
+    if (method === "POST" && execMatch) {
+        const task = await findTask(runtime, decodeURIComponent(execMatch[1]), listTriggerTasks, readTriggerConfig);
+        if (!task) {
+            error(res, "Trigger not found", 404);
+            return true;
+        }
+        const result = await executeTriggerTask(runtime, task, {
+            source: "manual",
+            force: true,
+        });
+        const refreshed = task.id ? await runtime.getTask(task.id) : null;
+        json(res, {
+            ok: true,
+            result,
+            trigger: refreshed ? taskToTriggerSummary(refreshed) : null,
+        });
+        return true;
+    }
+    const itemMatch = /^\/api\/triggers\/([^/]+)$/.exec(pathname);
+    if (!itemMatch)
+        return false;
+    const triggerId = decodeURIComponent(itemMatch[1]);
+    if (method === "GET") {
+        const task = await findTask(runtime, triggerId, listTriggerTasks, readTriggerConfig);
+        if (!task) {
+            error(res, "Trigger not found", 404);
+            return true;
+        }
+        const summary = taskToTriggerSummary(task);
+        if (!summary) {
+            error(res, "Trigger metadata is invalid", 500);
+            return true;
+        }
+        json(res, { trigger: summary });
+        return true;
+    }
+    if (method === "DELETE") {
+        const task = await findTask(runtime, triggerId, listTriggerTasks, readTriggerConfig);
+        if (!task?.id) {
+            error(res, "Trigger not found", 404);
+            return true;
+        }
+        await runtime.deleteTask(task.id);
+        json(res, { ok: true });
+        return true;
+    }
+    if (method === "PUT") {
+        const task = await findTask(runtime, triggerId, listTriggerTasks, readTriggerConfig);
+        if (!task?.id) {
+            error(res, "Trigger not found", 404);
+            return true;
+        }
+        const current = readTriggerConfig(task);
+        if (!current) {
+            error(res, "Trigger metadata is invalid", 500);
+            return true;
+        }
+        const body = await readJsonBody(req, res);
+        if (!body)
+            return true;
+        const merged = {
+            ...body,
+            createdBy: current.createdBy,
+            intervalMs: typeof body.intervalMs === "number"
+                ? body.intervalMs
+                : current.intervalMs,
+            scheduledAtIso: typeof body.scheduledAtIso === "string"
+                ? body.scheduledAtIso
+                : current.scheduledAtIso,
+            cronExpression: typeof body.cronExpression === "string"
+                ? body.cronExpression
+                : current.cronExpression,
+            maxRuns: typeof body.maxRuns === "number" ? body.maxRuns : current.maxRuns,
+        };
+        const normalized = normalizeTriggerDraft({
+            input: merged,
+            fallback: {
+                displayName: current.displayName,
+                instructions: current.instructions,
+                triggerType: current.triggerType,
+                wakeMode: current.wakeMode,
+                enabled: body.enabled === undefined ? current.enabled : body.enabled === true,
+                createdBy: current.createdBy,
+                intervalMs: current.intervalMs,
+                scheduledAtIso: current.scheduledAtIso,
+                cronExpression: current.cronExpression,
+                maxRuns: current.maxRuns,
+            },
+        });
+        if (!normalized.draft) {
+            error(res, normalized.error ?? "Invalid update", 400);
+            return true;
+        }
+        const nextTrigger = buildTriggerConfig({
+            draft: normalized.draft,
+            triggerId: current.triggerId,
+            previous: current,
+        });
+        const existingMeta = (task.metadata ?? {});
+        const existingRuns = readTriggerRuns(task);
+        let nextMeta;
+        if (!nextTrigger.enabled) {
+            nextMeta = {
+                ...existingMeta,
+                updatedAt: Date.now(),
+                updateInterval: DISABLED_TRIGGER_INTERVAL_MS,
+                trigger: {
+                    ...nextTrigger,
+                    nextRunAtMs: Date.now() + DISABLED_TRIGGER_INTERVAL_MS,
+                },
+                triggerRuns: existingRuns,
+            };
+        }
+        else {
+            const built = buildTriggerMetadata({
+                existingMetadata: existingMeta,
+                trigger: nextTrigger,
+                nowMs: Date.now(),
+            });
+            if (!built) {
+                error(res, "Unable to compute trigger schedule", 400);
+                return true;
+            }
+            nextMeta = built;
+        }
+        await runtime.updateTask(task.id, {
+            description: nextTrigger.displayName,
+            metadata: nextMeta,
+        });
+        const refreshed = await runtime.getTask(task.id);
+        if (!refreshed) {
+            error(res, "Trigger updated but no longer available", 500);
+            return true;
+        }
+        const summary = taskToTriggerSummary(refreshed);
+        if (!summary) {
+            error(res, "Trigger metadata is invalid", 500);
+            return true;
+        }
+        json(res, { trigger: summary });
+        return true;
+    }
+    return false;
+}

package/dist/packages/autonomous/src/api/twitter-verify.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Twitter/X verification for whitelist eligibility.
+ *
+ * Users post a verification message on X containing their agent name and
+ * wallet address. The app verifies the tweet exists using the FxTwitter API
+ * (free, no auth required). Verified addresses are stored locally and can
+ * be collected into a Merkle tree for on-chain whitelist proofs.
+ */
+import type { VerificationResult } from "../contracts/verification";
+export type { VerificationResult } from "../contracts/verification";
+interface WhitelistEntry {
+    timestamp: string;
+    tweetUrl: string;
+    handle: string;
+}
+interface WhitelistData {
+    verified: Record<string, WhitelistEntry>;
+}
+export declare function generateVerificationMessage(agentName: string, walletAddress: string): string;
+export declare function verifyTweet(tweetUrl: string, walletAddress: string): Promise<VerificationResult>;
+export declare function loadWhitelist(): WhitelistData;
+export declare function markAddressVerified(address: string, tweetUrl: string, handle: string): void;
+export declare function isAddressWhitelisted(address: string): boolean;
+export declare function getVerifiedAddresses(): string[];
+//# sourceMappingURL=twitter-verify.d.ts.map

package/dist/packages/autonomous/src/api/twitter-verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"twitter-verify.d.ts","sourceRoot":"","sources":["../../../../../src/api/twitter-verify.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAGpE,YAAY,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAMpE,UAAU,cAAc;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC1C;AAID,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,GACpB,MAAM,CAGR;AAYD,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,kBAAkB,CAAC,CAiH7B;AAQD,wBAAgB,aAAa,IAAI,aAAa,CAY7C;AAcD,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,IAAI,CASN;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAG7D;AAED,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAG/C"}

package/dist/packages/autonomous/src/api/twitter-verify.js

@@ -0,0 +1,168 @@
+/**
+ * Twitter/X verification for whitelist eligibility.
+ *
+ * Users post a verification message on X containing their agent name and
+ * wallet address. The app verifies the tweet exists using the FxTwitter API
+ * (free, no auth required). Verified addresses are stored locally and can
+ * be collected into a Merkle tree for on-chain whitelist proofs.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { logger } from "@elizaos/core";
+import { resolveStateDir } from "../config/paths";
+import { createIntegrationTelemetrySpan } from "../diagnostics/integration-observability";
+const WHITELIST_FILE = "whitelist.json";
+// ── Verification Message ─────────────────────────────────────────────────
+export function generateVerificationMessage(agentName, walletAddress) {
+    const shortAddr = `${walletAddress.slice(0, 6)}...${walletAddress.slice(-4)}`;
+    return `Verifying my Milady agent "${agentName}" | ${shortAddr} #MiladyAgent`;
+}
+// ── Tweet Verification ───────────────────────────────────────────────────
+function parseTweetUrl(url) {
+    const match = url.match(/(?:twitter\.com|x\.com)\/(\w+)\/status\/(\d+)/);
+    if (!match)
+        return null;
+    return { screenName: match[1], tweetId: match[2] };
+}
+export async function verifyTweet(tweetUrl, walletAddress) {
+    const parsed = parseTweetUrl(tweetUrl);
+    if (!parsed) {
+        return {
+            verified: false,
+            error: "Invalid tweet URL. Use a twitter.com or x.com status URL.",
+            handle: null,
+        };
+    }
+    const apiUrl = `https://api.fxtwitter.com/${parsed.screenName}/status/${parsed.tweetId}`;
+    const verifySpan = createIntegrationTelemetrySpan({
+        boundary: "marketplace",
+        operation: "verify_tweet",
+        timeoutMs: 15_000,
+    });
+    let response;
+    try {
+        response = await fetch(apiUrl, {
+            headers: { "User-Agent": "MiladyVerifier/1.0" },
+            signal: AbortSignal.timeout(15_000),
+        });
+    }
+    catch (err) {
+        verifySpan.failure({ error: err });
+        logger.warn(`[twitter-verify] FxTwitter fetch failed: ${err}`);
+        return {
+            verified: false,
+            error: "Could not reach tweet verification service. Try again later.",
+            handle: null,
+        };
+    }
+    if (!response.ok) {
+        if (response.status === 404) {
+            verifySpan.success({ statusCode: 404 });
+            return {
+                verified: false,
+                error: "Tweet not found. Make sure the URL is correct and the tweet is public.",
+                handle: null,
+            };
+        }
+        verifySpan.failure({
+            statusCode: response.status,
+            errorKind: "http_error",
+        });
+        return {
+            verified: false,
+            error: `Tweet fetch failed (HTTP ${response.status})`,
+            handle: null,
+        };
+    }
+    let data;
+    try {
+        data = (await response.json());
+    }
+    catch (err) {
+        verifySpan.failure({ error: err, statusCode: response.status });
+        return {
+            verified: false,
+            error: "Invalid response from verification service",
+            handle: null,
+        };
+    }
+    if (!data.tweet?.text) {
+        verifySpan.failure({
+            statusCode: response.status,
+            errorKind: "empty_content",
+        });
+        return {
+            verified: false,
+            error: "Could not read tweet content",
+            handle: null,
+        };
+    }
+    const tweetText = data.tweet.text;
+    const handle = data.tweet.author?.screen_name ?? parsed.screenName;
+    const shortAddr = `${walletAddress.slice(0, 6)}...${walletAddress.slice(-4)}`;
+    const hasAddress = tweetText.includes(shortAddr) ||
+        tweetText.toLowerCase().includes(walletAddress.toLowerCase().slice(0, 10));
+    const hasHashtag = tweetText.includes("#MiladyAgent");
+    if (!hasAddress) {
+        return {
+            verified: false,
+            error: "Tweet does not contain your wallet address. Make sure you copied the full verification message.",
+            handle,
+        };
+    }
+    if (!hasHashtag) {
+        return {
+            verified: false,
+            error: "Tweet is missing #MiladyAgent hashtag.",
+            handle,
+        };
+    }
+    verifySpan.success({ statusCode: response.status });
+    return { verified: true, error: null, handle };
+}
+// ── Whitelist Storage ────────────────────────────────────────────────────
+function whitelistPath() {
+    return path.join(resolveStateDir(), WHITELIST_FILE);
+}
+export function loadWhitelist() {
+    const filePath = whitelistPath();
+    if (!fs.existsSync(filePath))
+        return { verified: {} };
+    const raw = fs.readFileSync(filePath, "utf-8");
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        logger.warn(`[twitter-verify] Corrupt whitelist file, resetting: ${filePath}`);
+        return { verified: {} };
+    }
+}
+function saveWhitelist(data) {
+    const filePath = whitelistPath();
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+}
+export function markAddressVerified(address, tweetUrl, handle) {
+    const wl = loadWhitelist();
+    wl.verified[address.toLowerCase()] = {
+        timestamp: new Date().toISOString(),
+        tweetUrl,
+        handle,
+    };
+    saveWhitelist(wl);
+    logger.info(`[twitter-verify] Address ${address} verified via @${handle}`);
+}
+export function isAddressWhitelisted(address) {
+    const wl = loadWhitelist();
+    return address.toLowerCase() in wl.verified;
+}
+export function getVerifiedAddresses() {
+    const wl = loadWhitelist();
+    return Object.keys(wl.verified);
+}

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

@@ -0,0 +1,47 @@
+/**
+ * Ethereum transaction signing and contract interaction layer.
+ *
+ * Provides the missing transaction capability to Milady'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 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/autonomous/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;AAchC,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"}