miladyai 2.0.0-alpha.27

package/dist/api/trigger-routes.js

@@ -0,0 +1,246 @@
+import { DISABLED_TRIGGER_INTERVAL_MS, buildTriggerConfig, buildTriggerMetadata, normalizeTriggerDraft } from "../triggers/scheduling.js";
+import { TRIGGER_TASK_NAME, TRIGGER_TASK_TAGS, executeTriggerTask, getTriggerHealthSnapshot, getTriggerLimit, listTriggerTasks, readTriggerConfig, readTriggerRuns, taskToTriggerSummary, triggersFeatureEnabled } from "../triggers/runtime.js";
+import { stringToUuid } from "@elizaos/core";
+import crypto from "node:crypto";
+
+//#region src/api/trigger-routes.ts
+function trim(s) {
+	return s.trim().replace(/\s+/g, " ");
+}
+async function findTask(runtime, id) {
+	return (await listTriggerTasks(runtime)).find((t) => {
+		return readTriggerConfig(t)?.triggerId === id || t.id === id;
+	}) ?? null;
+}
+async function handleTriggerRoutes(ctx) {
+	const { method, pathname, req, res, runtime, readJsonBody, json, error } = 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") {
+		json(res, { triggers: (await listTriggerTasks(runtime)).map(taskToTriggerSummary).filter((s) => s !== null).sort((a, b) => a.displayName.localeCompare(b.displayName)) });
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/triggers") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		const creator = trim(body.createdBy ?? "") || "api";
+		const normalized = normalizeTriggerDraft({
+			input: {
+				...body,
+				enabled: body.enabled ?? true,
+				createdBy: creator
+			},
+			fallback: {
+				displayName: trim(body.displayName ?? "") || "New Trigger",
+				instructions: trim(body.instructions ?? ""),
+				triggerType: body.triggerType ?? "interval",
+				wakeMode: body.wakeMode ?? "inject_now",
+				enabled: body.enabled ?? true,
+				createdBy: creator
+			}
+		});
+		if (!normalized.draft) {
+			error(res, normalized.error ?? "Invalid trigger request", 400);
+			return true;
+		}
+		const existingTasks = await listTriggerTasks(runtime);
+		const activeCount = existingTasks.filter((t) => {
+			const tr = readTriggerConfig(t);
+			return tr?.enabled && tr.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
+		});
+		if (existingTasks.find((t) => {
+			const et = readTriggerConfig(t);
+			return et?.enabled && et.dedupeKey && et.dedupeKey === trigger.dedupeKey;
+		})?.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
+		});
+		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]));
+		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]));
+		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);
+		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);
+		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);
+		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 normalized = normalizeTriggerDraft({
+			input: {
+				...body,
+				createdBy: current.createdBy,
+				intervalMs: body.intervalMs ?? current.intervalMs,
+				scheduledAtIso: body.scheduledAtIso ?? current.scheduledAtIso,
+				cronExpression: body.cronExpression ?? current.cronExpression,
+				maxRuns: body.maxRuns ?? current.maxRuns
+			},
+			fallback: {
+				displayName: current.displayName,
+				instructions: current.instructions,
+				triggerType: current.triggerType,
+				wakeMode: current.wakeMode,
+				enabled: body.enabled ?? current.enabled,
+				createdBy: current.createdBy
+			}
+		});
+		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;
+}
+
+//#endregion
+export { handleTriggerRoutes };

package/dist/api/twitter-verify.js

@@ -0,0 +1,134 @@
+import { resolveStateDir } from "../config/paths.js";
+import path from "node:path";
+import { logger } from "@elizaos/core";
+import fs from "node:fs";
+
+//#region src/api/twitter-verify.ts
+/**
+* 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.
+*/
+const WHITELIST_FILE = "whitelist.json";
+function generateVerificationMessage(agentName, walletAddress) {
+	return `Verifying my Milady agent "${agentName}" | ${`${walletAddress.slice(0, 6)}...${walletAddress.slice(-4)}`} #MiladyAgent`;
+}
+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]
+	};
+}
+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}`;
+	let response;
+	try {
+		response = await fetch(apiUrl, {
+			headers: { "User-Agent": "MiladyVerifier/1.0" },
+			signal: AbortSignal.timeout(15e3)
+		});
+	} catch (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) return {
+			verified: false,
+			error: "Tweet not found. Make sure the URL is correct and the tweet is public.",
+			handle: null
+		};
+		return {
+			verified: false,
+			error: `Tweet fetch failed (HTTP ${response.status})`,
+			handle: null
+		};
+	}
+	let data;
+	try {
+		data = await response.json();
+	} catch {
+		return {
+			verified: false,
+			error: "Invalid response from verification service",
+			handle: null
+		};
+	}
+	if (!data.tweet?.text) 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
+	};
+	return {
+		verified: true,
+		error: null,
+		handle
+	};
+}
+function whitelistPath() {
+	return path.join(resolveStateDir(), WHITELIST_FILE);
+}
+function loadWhitelist() {
+	const filePath = whitelistPath();
+	if (!fs.existsSync(filePath)) return { verified: {} };
+	const raw = fs.readFileSync(filePath, "utf-8");
+	return JSON.parse(raw);
+}
+function saveWhitelist(data) {
+	const filePath = whitelistPath();
+	const dir = path.dirname(filePath);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	fs.writeFileSync(filePath, JSON.stringify(data, null, 2), {
+		encoding: "utf-8",
+		mode: 384
+	});
+}
+function markAddressVerified(address, tweetUrl, handle) {
+	const wl = loadWhitelist();
+	wl.verified[address.toLowerCase()] = {
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		tweetUrl,
+		handle
+	};
+	saveWhitelist(wl);
+	logger.info(`[twitter-verify] Address ${address} verified via @${handle}`);
+}
+function isAddressWhitelisted(address) {
+	const wl = loadWhitelist();
+	return address.toLowerCase() in wl.verified;
+}
+
+//#endregion
+export { generateVerificationMessage, isAddressWhitelisted, markAddressVerified, verifyTweet };

package/dist/api/tx-service.js

@@ -0,0 +1,108 @@
+import { logger } from "@elizaos/core";
+import { ethers } from "ethers";
+
+//#region src/api/tx-service.ts
+/**
+* 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.
+*/
+/**
+* Validate that a private key is a valid 32-byte hex string.
+*/
+function isValidPrivateKey(key) {
+	const normalized = key.startsWith("0x") ? key.slice(2) : key;
+	if (normalized.length !== 64) return false;
+	return /^[0-9a-fA-F]+$/.test(normalized);
+}
+var TxService = class {
+	constructor(rpcUrl, privateKey) {
+		this.rpcUrl = rpcUrl;
+		this.provider = new ethers.JsonRpcProvider(rpcUrl);
+		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.`);
+		}
+		const normalizedKey = privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
+		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 freshProvider = new ethers.JsonRpcProvider(this.rpcUrl);
+		try {
+			return await freshProvider.getTransactionCount(this.wallet.address, "pending");
+		} 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 = 12e4) {
+		const receipt = await this.provider.waitForTransaction(txHash, confirmations, timeoutMs);
+		if (!receipt) throw new Error(`Transaction ${txHash} timed out after ${timeoutMs}ms`);
+		if (receipt.status === 0) throw new Error(`Transaction ${txHash} reverted`);
+		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 costWei = gasLimit * (feeData.gasPrice ?? feeData.maxFeePerGas ?? 0n);
+		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();
+		return balance >= value + gasEstimate * (feeData.gasPrice ?? feeData.maxFeePerGas ?? 0n);
+	}
+	/**
+	* 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`);
+	}
+};
+
+//#endregion
+export { TxService };