miladyai 2.0.0-alpha.27

package/dist/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 };

package/dist/utils/exec-safety.js

@@ -0,0 +1,17 @@
+//#region src/utils/exec-safety.ts
+const UNSAFE_CHARS = /[\0\r\n;&|`$<>"']/;
+const BARE_NAME = /^[A-Za-z0-9._+-]+$/;
+function isLikelyPath(value) {
+	return value.startsWith(".") || value.startsWith("~") || value.includes("/") || value.includes("\\") || /^[A-Za-z]:[\\/]/.test(value);
+}
+function isSafeExecutableValue(value) {
+	const trimmed = value?.trim();
+	if (!trimmed) return false;
+	if (UNSAFE_CHARS.test(trimmed)) return false;
+	if (isLikelyPath(trimmed)) return true;
+	if (trimmed.startsWith("-")) return false;
+	return BARE_NAME.test(trimmed);
+}
+
+//#endregion
+export { isSafeExecutableValue };

package/dist/utils/globals.js

@@ -0,0 +1,20 @@
+import "../terminal/theme.js";
+import { logger } from "@elizaos/core";
+
+//#region src/utils/globals.ts
+const TRUTHY_VALUES = new Set([
+	"true",
+	"1",
+	"yes",
+	"on"
+]);
+function isTruthyEnvValue(value) {
+	return TRUTHY_VALUES.has((value ?? "").trim().toLowerCase());
+}
+let globalVerbose = false;
+function setVerbose(v) {
+	globalVerbose = v;
+}
+
+//#endregion
+export { isTruthyEnvValue, setVerbose };

package/dist/utils/milady-root.js

@@ -0,0 +1,61 @@
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import fs$1 from "node:fs/promises";
+
+//#region src/utils/milady-root.ts
+const CORE_PACKAGE_NAME = "milady";
+function readPackageNameSync(dir) {
+	try {
+		const raw = fs.readFileSync(path.join(dir, "package.json"), "utf-8");
+		const parsed = JSON.parse(raw);
+		return typeof parsed.name === "string" ? parsed.name : null;
+	} catch {
+		return null;
+	}
+}
+function listAncestorDirs(startDir, maxDepth = 12) {
+	const dirs = [];
+	let current = path.resolve(startDir);
+	for (let i = 0; i < maxDepth; i += 1) {
+		dirs.push(current);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return dirs;
+}
+function findPackageRootSync(startDir, maxDepth = 12) {
+	for (const candidate of listAncestorDirs(startDir, maxDepth)) if (readPackageNameSync(candidate) === CORE_PACKAGE_NAME) return candidate;
+	return null;
+}
+function candidateDirsFromArgv1(argv1) {
+	const normalized = path.resolve(argv1);
+	const candidates = [path.dirname(normalized)];
+	const parts = normalized.split(path.sep);
+	const binIndex = parts.lastIndexOf(".bin");
+	if (binIndex > 0 && parts[binIndex - 1] === "node_modules") {
+		const binName = path.basename(normalized);
+		const nodeModulesDir = parts.slice(0, binIndex).join(path.sep);
+		candidates.push(path.join(nodeModulesDir, binName));
+	}
+	return candidates;
+}
+function candidateDirsFromOptions(opts) {
+	const candidates = [];
+	if (opts.moduleUrl) candidates.push(path.dirname(fileURLToPath(opts.moduleUrl)));
+	if (opts.argv1) candidates.push(...candidateDirsFromArgv1(opts.argv1));
+	if (opts.cwd) candidates.push(opts.cwd);
+	return candidates;
+}
+function resolveMiladyPackageRootSync(opts) {
+	const candidates = candidateDirsFromOptions(opts);
+	for (const candidate of candidates) {
+		const found = findPackageRootSync(candidate);
+		if (found) return found;
+	}
+	return null;
+}
+
+//#endregion
+export { resolveMiladyPackageRootSync };

package/dist/utils/number-parsing.js

@@ -0,0 +1,37 @@
+//#region src/utils/number-parsing.ts
+function sanitizeNumericText(value) {
+	return value == null ? "" : value.trim();
+}
+function normalizeFallback(fallback) {
+	return Number.isFinite(fallback) ? fallback : void 0;
+}
+function parsePositiveInteger(value, fallback) {
+	const raw = sanitizeNumericText(value);
+	if (!raw) return normalizeFallback(fallback);
+	const parsed = Number(raw);
+	if (!Number.isFinite(parsed) || parsed <= 0) return normalizeFallback(fallback);
+	return Math.max(1, Math.floor(parsed));
+}
+function parseClampedFloat(value, options = {}) {
+	const raw = sanitizeNumericText(value);
+	if (!raw) return normalizeFallback(options.fallback);
+	const parsed = Number(raw);
+	if (!Number.isFinite(parsed)) return normalizeFallback(options.fallback);
+	const min = options.min ?? -Infinity;
+	const max = options.max ?? Infinity;
+	return Math.max(min, Math.min(max, parsed));
+}
+function parseClampedInteger(value, options = {}) {
+	const raw = sanitizeNumericText(value);
+	if (!raw) return normalizeFallback(options.fallback);
+	const parsed = Number.parseInt(raw, 10);
+	if (!Number.isFinite(parsed)) return normalizeFallback(options.fallback);
+	const min = options.min;
+	if (min !== void 0 && parsed < min) return min;
+	const max = options.max;
+	if (max !== void 0 && parsed > max) return max;
+	return parsed;
+}
+
+//#endregion
+export { parseClampedFloat, parseClampedInteger, parsePositiveInteger };

package/dist/version-resolver.js

@@ -0,0 +1,37 @@
+import { createRequire } from "node:module";
+import process from "node:process";
+
+//#region src/version-resolver.ts
+const PACKAGE_JSON_CANDIDATE = "../../package.json";
+const BUILD_INFO_CANDIDATES = [
+	"../../build-info.json",
+	"../build-info.json",
+	"./build-info.json"
+];
+function isModuleNotFound(err) {
+	return typeof err === "object" && err !== null && "code" in err && err.code === "MODULE_NOT_FOUND";
+}
+function readVersionFromPackageJson(requireFn) {
+	try {
+		return requireFn(PACKAGE_JSON_CANDIDATE).version ?? null;
+	} catch (err) {
+		if (isModuleNotFound(err)) return null;
+		throw err;
+	}
+}
+function readVersionFromBuildInfo(requireFn) {
+	for (const candidate of BUILD_INFO_CANDIDATES) try {
+		const info = requireFn(candidate);
+		if (info.version) return info.version;
+	} catch (err) {
+		if (!isModuleNotFound(err)) throw err;
+	}
+	return null;
+}
+function resolveMiladyVersion(moduleUrl) {
+	const requireFn = createRequire(moduleUrl);
+	return typeof __MILADY_VERSION__ === "string" && __MILADY_VERSION__ || process.env.MILADY_BUNDLED_VERSION || readVersionFromPackageJson(requireFn) || readVersionFromBuildInfo(requireFn) || "0.0.0";
+}
+
+//#endregion
+export { resolveMiladyVersion };

package/dist/version.js

@@ -0,0 +1,7 @@
+import { resolveMiladyVersion } from "./version-resolver.js";
+
+//#region src/runtime/version.ts
+const VERSION = resolveMiladyVersion(import.meta.url);
+
+//#endregion
+export { VERSION };

package/dist/wallet-routes.js

@@ -0,0 +1,266 @@
+import { fetchEvmBalances, fetchEvmNfts, fetchSolanaBalances, fetchSolanaNfts, generateWalletForChain, getWalletAddresses, importWallet, validatePrivateKey } from "./wallet.js";
+import { createIntegrationTelemetrySpan } from "./diagnostics/integration-observability.js";
+import { logger } from "@elizaos/core";
+
+//#region src/api/wallet-routes.ts
+const DEFAULT_WALLET_ROUTE_DEPENDENCIES = {
+	getWalletAddresses,
+	fetchEvmBalances,
+	fetchSolanaBalances,
+	fetchEvmNfts,
+	fetchSolanaNfts,
+	validatePrivateKey,
+	importWallet,
+	generateWalletForChain
+};
+async function handleWalletRoutes(ctx) {
+	const { req, res, method, pathname, config, saveConfig, ensureWalletKeysInEnvAndConfig, resolveWalletExportRejection, readJsonBody, json, error } = ctx;
+	const deps = ctx.deps ?? DEFAULT_WALLET_ROUTE_DEPENDENCIES;
+	if (method === "GET" && pathname === "/api/wallet/addresses") {
+		json(res, deps.getWalletAddresses());
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/wallet/balances") {
+		const addresses = deps.getWalletAddresses();
+		const alchemyKey = process.env.ALCHEMY_API_KEY;
+		const heliusKey = process.env.HELIUS_API_KEY;
+		const result = {
+			evm: null,
+			solana: null
+		};
+		if (addresses.evmAddress && alchemyKey) {
+			const evmBalancesSpan = createIntegrationTelemetrySpan({
+				boundary: "wallet",
+				operation: "fetch_evm_balances"
+			});
+			try {
+				const chains = await deps.fetchEvmBalances(addresses.evmAddress, alchemyKey);
+				result.evm = {
+					address: addresses.evmAddress,
+					chains
+				};
+				evmBalancesSpan.success();
+			} catch (err) {
+				evmBalancesSpan.failure({ error: err });
+				logger.warn(`[wallet] EVM balance fetch failed: ${err}`);
+			}
+		}
+		if (addresses.solanaAddress && heliusKey) {
+			const solanaBalancesSpan = createIntegrationTelemetrySpan({
+				boundary: "wallet",
+				operation: "fetch_solana_balances"
+			});
+			try {
+				const solanaData = await deps.fetchSolanaBalances(addresses.solanaAddress, heliusKey);
+				result.solana = {
+					address: addresses.solanaAddress,
+					...solanaData
+				};
+				solanaBalancesSpan.success();
+			} catch (err) {
+				solanaBalancesSpan.failure({ error: err });
+				logger.warn(`[wallet] Solana balance fetch failed: ${err}`);
+			}
+		}
+		json(res, result);
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/wallet/nfts") {
+		const addresses = deps.getWalletAddresses();
+		const alchemyKey = process.env.ALCHEMY_API_KEY;
+		const heliusKey = process.env.HELIUS_API_KEY;
+		const result = {
+			evm: [],
+			solana: null
+		};
+		if (addresses.evmAddress && alchemyKey) {
+			const evmNftsSpan = createIntegrationTelemetrySpan({
+				boundary: "wallet",
+				operation: "fetch_evm_nfts"
+			});
+			try {
+				result.evm = await deps.fetchEvmNfts(addresses.evmAddress, alchemyKey);
+				evmNftsSpan.success();
+			} catch (err) {
+				evmNftsSpan.failure({ error: err });
+				logger.warn(`[wallet] EVM NFT fetch failed: ${err}`);
+			}
+		}
+		if (addresses.solanaAddress && heliusKey) {
+			const solanaNftsSpan = createIntegrationTelemetrySpan({
+				boundary: "wallet",
+				operation: "fetch_solana_nfts"
+			});
+			try {
+				result.solana = { nfts: await deps.fetchSolanaNfts(addresses.solanaAddress, heliusKey) };
+				solanaNftsSpan.success();
+			} catch (err) {
+				solanaNftsSpan.failure({ error: err });
+				logger.warn(`[wallet] Solana NFT fetch failed: ${err}`);
+			}
+		}
+		json(res, result);
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/wallet/import") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		if (!body.privateKey?.trim()) {
+			error(res, "privateKey is required");
+			return true;
+		}
+		let chain;
+		if (body.chain === "evm" || body.chain === "solana") chain = body.chain;
+		else if (body.chain) {
+			error(res, `Unsupported chain: ${body.chain}. Must be "evm" or "solana".`);
+			return true;
+		} else chain = deps.validatePrivateKey(body.privateKey.trim()).chain;
+		const result = deps.importWallet(chain, body.privateKey.trim());
+		if (!result.success) {
+			error(res, result.error ?? "Import failed", 422);
+			return true;
+		}
+		if (!config.env) config.env = {};
+		const envKey = chain === "evm" ? "EVM_PRIVATE_KEY" : "SOLANA_PRIVATE_KEY";
+		config.env[envKey] = process.env[envKey] ?? "";
+		try {
+			saveConfig(config);
+		} catch (err) {
+			logger.warn(`[api] Config save failed: ${err instanceof Error ? err.message : err}`);
+		}
+		json(res, {
+			ok: true,
+			chain,
+			address: result.address
+		});
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/wallet/generate") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		const chain = body.chain;
+		if (chain && ![
+			"evm",
+			"solana",
+			"both"
+		].includes(chain)) {
+			error(res, `Unsupported chain: ${chain}. Must be "evm", "solana", or "both".`);
+			return true;
+		}
+		const targetChain = chain ?? "both";
+		if (!config.env) config.env = {};
+		const generated = [];
+		if (targetChain === "both" || targetChain === "evm") {
+			const result = deps.generateWalletForChain("evm");
+			process.env.EVM_PRIVATE_KEY = result.privateKey;
+			config.env.EVM_PRIVATE_KEY = result.privateKey;
+			generated.push({
+				chain: "evm",
+				address: result.address
+			});
+			logger.info(`[milady-api] Generated EVM wallet: ${result.address}`);
+		}
+		if (targetChain === "both" || targetChain === "solana") {
+			const result = deps.generateWalletForChain("solana");
+			process.env.SOLANA_PRIVATE_KEY = result.privateKey;
+			config.env.SOLANA_PRIVATE_KEY = result.privateKey;
+			generated.push({
+				chain: "solana",
+				address: result.address
+			});
+			logger.info(`[milady-api] Generated Solana wallet: ${result.address}`);
+		}
+		try {
+			saveConfig(config);
+		} catch (err) {
+			logger.warn(`[api] Config save failed: ${err instanceof Error ? err.message : err}`);
+		}
+		json(res, {
+			ok: true,
+			wallets: generated
+		});
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/wallet/config") {
+		const addresses = deps.getWalletAddresses();
+		json(res, {
+			alchemyKeySet: Boolean(process.env.ALCHEMY_API_KEY),
+			infuraKeySet: Boolean(process.env.INFURA_API_KEY),
+			ankrKeySet: Boolean(process.env.ANKR_API_KEY),
+			heliusKeySet: Boolean(process.env.HELIUS_API_KEY),
+			birdeyeKeySet: Boolean(process.env.BIRDEYE_API_KEY),
+			evmChains: [
+				"Ethereum",
+				"Base",
+				"Arbitrum",
+				"Optimism",
+				"Polygon"
+			],
+			evmAddress: addresses.evmAddress,
+			solanaAddress: addresses.solanaAddress
+		});
+		return true;
+	}
+	if (method === "PUT" && pathname === "/api/wallet/config") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		const allowedKeys = [
+			"ALCHEMY_API_KEY",
+			"INFURA_API_KEY",
+			"ANKR_API_KEY",
+			"HELIUS_API_KEY",
+			"BIRDEYE_API_KEY"
+		];
+		if (!config.env) config.env = {};
+		for (const key of allowedKeys) {
+			const value = body[key];
+			if (typeof value === "string" && value.trim()) {
+				process.env[key] = value.trim();
+				config.env[key] = value.trim();
+			}
+		}
+		const heliusValue = body.HELIUS_API_KEY;
+		if (typeof heliusValue === "string" && heliusValue.trim()) {
+			const rpcUrl = `https://mainnet.helius-rpc.com/?api-key=${heliusValue.trim()}`;
+			process.env.SOLANA_RPC_URL = rpcUrl;
+			config.env.SOLANA_RPC_URL = rpcUrl;
+		}
+		ensureWalletKeysInEnvAndConfig(config);
+		try {
+			saveConfig(config);
+		} catch (err) {
+			logger.warn(`[api] Config save failed: ${err instanceof Error ? err.message : err}`);
+		}
+		json(res, { ok: true });
+		ctx.scheduleRuntimeRestart?.("Wallet configuration updated");
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/wallet/export") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		const rejection = resolveWalletExportRejection(req, body);
+		if (rejection) {
+			error(res, rejection.reason, rejection.status);
+			return true;
+		}
+		const evmKey = process.env.EVM_PRIVATE_KEY ?? null;
+		const solanaKey = process.env.SOLANA_PRIVATE_KEY ?? null;
+		const addresses = deps.getWalletAddresses();
+		logger.warn("[wallet] Private keys exported via API");
+		json(res, {
+			evm: evmKey ? {
+				privateKey: evmKey,
+				address: addresses.evmAddress
+			} : null,
+			solana: solanaKey ? {
+				privateKey: solanaKey,
+				address: addresses.solanaAddress
+			} : null
+		});
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleWalletRoutes };