miladyai 2.0.0-alpha.27

package/dist/wallet.js

@@ -0,0 +1,568 @@
+import crypto from "node:crypto";
+import { logger } from "@elizaos/core";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+
+//#region src/api/wallet.ts
+/**
+* Wallet key generation, address derivation, and balance/NFT fetching.
+* Uses Node crypto primitives (no viem/@solana/web3.js dependency).
+* Balance data from Alchemy (EVM) and Helius (Solana) REST APIs.
+*/
+const FETCH_TIMEOUT_MS = 15e3;
+const DEFAULT_EVM_CHAINS = [
+	{
+		name: "Ethereum",
+		subdomain: "eth-mainnet",
+		chainId: 1,
+		nativeSymbol: "ETH"
+	},
+	{
+		name: "Base",
+		subdomain: "base-mainnet",
+		chainId: 8453,
+		nativeSymbol: "ETH"
+	},
+	{
+		name: "Arbitrum",
+		subdomain: "arb-mainnet",
+		chainId: 42161,
+		nativeSymbol: "ETH"
+	},
+	{
+		name: "Optimism",
+		subdomain: "opt-mainnet",
+		chainId: 10,
+		nativeSymbol: "ETH"
+	},
+	{
+		name: "Polygon",
+		subdomain: "polygon-mainnet",
+		chainId: 137,
+		nativeSymbol: "POL"
+	}
+];
+function generateEvmPrivateKey() {
+	return `0x${crypto.randomBytes(32).toString("hex")}`;
+}
+function deriveEvmAddress(privateKeyHex) {
+	const cleaned = privateKeyHex.startsWith("0x") ? privateKeyHex.slice(2) : privateKeyHex;
+	return toChecksumAddress(`0x${keccak256(secp256k1.getPublicKey(Buffer.from(cleaned, "hex"), false).subarray(1)).subarray(12).toString("hex")}`);
+}
+const RC = [
+	1n,
+	32898n,
+	9223372036854808714n,
+	9223372039002292224n,
+	32907n,
+	2147483649n,
+	9223372039002292353n,
+	9223372036854808585n,
+	138n,
+	136n,
+	2147516425n,
+	2147483658n,
+	2147516555n,
+	9223372036854775947n,
+	9223372036854808713n,
+	9223372036854808579n,
+	9223372036854808578n,
+	9223372036854775936n,
+	32778n,
+	9223372039002259466n,
+	9223372039002292353n,
+	9223372036854808704n,
+	2147483649n,
+	9223372039002292232n
+];
+const ROT = [
+	[
+		0,
+		36,
+		3,
+		41,
+		18
+	],
+	[
+		1,
+		44,
+		10,
+		45,
+		2
+	],
+	[
+		62,
+		6,
+		43,
+		15,
+		61
+	],
+	[
+		28,
+		55,
+		25,
+		21,
+		56
+	],
+	[
+		27,
+		20,
+		39,
+		8,
+		14
+	]
+];
+function keccak256(data) {
+	const rate = 136;
+	const state = Array.from({ length: 5 }, () => Array.from({ length: 5 }, () => 0n));
+	const q = rate - data.length % rate;
+	const padded = Buffer.alloc(data.length + q);
+	padded.set(data);
+	padded[data.length] = 1;
+	padded[padded.length - 1] |= 128;
+	for (let off = 0; off < padded.length; off += rate) {
+		for (let i = 0; i < rate / 8; i++) {
+			let w = 0n;
+			for (let b = 0; b < 8; b++) w |= BigInt(padded[off + i * 8 + b]) << BigInt(b * 8);
+			state[i % 5][Math.floor(i / 5)] ^= w;
+		}
+		keccakF1600(state);
+	}
+	const out = Buffer.alloc(32);
+	for (let i = 0; i < 4; i++) {
+		const v = state[i % 5][Math.floor(i / 5)];
+		for (let b = 0; b < 8; b++) out[i * 8 + b] = Number(v >> BigInt(b * 8) & 255n);
+	}
+	return out;
+}
+function keccakF1600(state) {
+	const M = (1n << 64n) - 1n;
+	const rot = (v, s) => s === 0 ? v : (v << BigInt(s) | v >> BigInt(64 - s)) & M;
+	for (let round = 0; round < 24; round++) {
+		const c = [];
+		for (let x = 0; x < 5; x++) c[x] = state[x][0] ^ state[x][1] ^ state[x][2] ^ state[x][3] ^ state[x][4];
+		for (let x = 0; x < 5; x++) {
+			const d = c[(x + 4) % 5] ^ rot(c[(x + 1) % 5], 1);
+			for (let y = 0; y < 5; y++) state[x][y] = (state[x][y] ^ d) & M;
+		}
+		const b = Array.from({ length: 5 }, () => Array.from({ length: 5 }, () => 0n));
+		for (let x = 0; x < 5; x++) for (let y = 0; y < 5; y++) b[y][(2 * x + 3 * y) % 5] = rot(state[x][y], ROT[x][y]);
+		for (let x = 0; x < 5; x++) for (let y = 0; y < 5; y++) state[x][y] = (b[x][y] ^ ~b[(x + 1) % 5][y] & M & b[(x + 2) % 5][y]) & M;
+		state[0][0] = (state[0][0] ^ RC[round]) & M;
+	}
+}
+function toChecksumAddress(address) {
+	const addr = address.toLowerCase().replace("0x", "");
+	const hash = keccak256(Buffer.from(addr, "utf8")).toString("hex");
+	let out = "0x";
+	for (let i = 0; i < 40; i++) out += Number.parseInt(hash[i], 16) >= 8 ? addr[i].toUpperCase() : addr[i];
+	return out;
+}
+function generateSolanaKeypair() {
+	const { privateKey, publicKey } = crypto.generateKeyPairSync("ed25519");
+	const privBytes = privateKey.export({
+		type: "pkcs8",
+		format: "der"
+	});
+	const pubBytes = publicKey.export({
+		type: "spki",
+		format: "der"
+	});
+	const seed = privBytes.subarray(16, 48);
+	const pubRaw = pubBytes.subarray(12, 44);
+	return {
+		privateKey: base58Encode(Buffer.concat([seed, pubRaw])),
+		publicKey: base58Encode(pubRaw)
+	};
+}
+function deriveSolanaAddress(privateKeyBase58) {
+	const secretBytes = base58Decode(privateKeyBase58);
+	if (secretBytes.length === 64) return base58Encode(secretBytes.subarray(32));
+	if (secretBytes.length === 32) {
+		const keyObj = crypto.createPrivateKey({
+			key: Buffer.concat([Buffer.from("302e020100300506032b657004220420", "hex"), secretBytes]),
+			format: "der",
+			type: "pkcs8"
+		});
+		return base58Encode(crypto.createPublicKey(keyObj).export({
+			type: "spki",
+			format: "der"
+		}).subarray(12, 44));
+	}
+	throw new Error(`Invalid Solana secret key length: ${secretBytes.length}`);
+}
+const B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Encode(data) {
+	let num = BigInt(`0x${Buffer.from(data).toString("hex")}`);
+	const chars = [];
+	while (num > 0n) {
+		chars.unshift(B58[Number(num % 58n)]);
+		num /= 58n;
+	}
+	for (const byte of data) if (byte === 0) chars.unshift("1");
+	else break;
+	return chars.join("") || "1";
+}
+function base58Decode(str) {
+	if (str.length === 0) return Buffer.alloc(0);
+	let num = 0n;
+	for (const c of str) {
+		const i = B58.indexOf(c);
+		if (i === -1) throw new Error(`Invalid base58: ${c}`);
+		num = num * 58n + BigInt(i);
+	}
+	const hex = num.toString(16).padStart(2, "0");
+	const bytes = Buffer.from(hex.length % 2 ? `0${hex}` : hex, "hex");
+	let zeros = 0;
+	for (const c of str) if (c === "1") zeros++;
+	else break;
+	return zeros > 0 ? Buffer.concat([Buffer.alloc(zeros), bytes]) : bytes;
+}
+const HEX_RE = /^[0-9a-fA-F]+$/;
+function validateEvmPrivateKey(key) {
+	const cleaned = key.startsWith("0x") ? key.slice(2) : key;
+	if (cleaned.length !== 64) return {
+		valid: false,
+		chain: "evm",
+		address: null,
+		error: "Must be 64 hex characters"
+	};
+	if (!HEX_RE.test(cleaned)) return {
+		valid: false,
+		chain: "evm",
+		address: null,
+		error: "Invalid hex characters"
+	};
+	try {
+		return {
+			valid: true,
+			chain: "evm",
+			address: deriveEvmAddress(key),
+			error: null
+		};
+	} catch (err) {
+		return {
+			valid: false,
+			chain: "evm",
+			address: null,
+			error: `Derivation failed: ${err instanceof Error ? err.message : err}`
+		};
+	}
+}
+function validateSolanaPrivateKey(key) {
+	try {
+		const bytes = base58Decode(key);
+		if (bytes.length !== 64 && bytes.length !== 32) return {
+			valid: false,
+			chain: "solana",
+			address: null,
+			error: `Must be 32 or 64 bytes, got ${bytes.length}`
+		};
+		return {
+			valid: true,
+			chain: "solana",
+			address: deriveSolanaAddress(key),
+			error: null
+		};
+	} catch (err) {
+		return {
+			valid: false,
+			chain: "solana",
+			address: null,
+			error: `Invalid key: ${err instanceof Error ? err.message : err}`
+		};
+	}
+}
+/** Auto-detect chain from key format and validate. */
+function validatePrivateKey(key) {
+	const trimmed = key.trim();
+	if (trimmed.startsWith("0x") || trimmed.length === 64 && HEX_RE.test(trimmed)) return validateEvmPrivateKey(trimmed);
+	return validateSolanaPrivateKey(trimmed);
+}
+function generateWalletKeys() {
+	const evmPrivateKey = generateEvmPrivateKey();
+	const solana = generateSolanaKeypair();
+	return {
+		evmPrivateKey,
+		evmAddress: deriveEvmAddress(evmPrivateKey),
+		solanaPrivateKey: solana.privateKey,
+		solanaAddress: solana.publicKey
+	};
+}
+function generateWalletForChain(chain) {
+	if (chain === "evm") {
+		const pk = generateEvmPrivateKey();
+		return {
+			chain,
+			address: deriveEvmAddress(pk),
+			privateKey: pk
+		};
+	}
+	const sol = generateSolanaKeypair();
+	return {
+		chain: "solana",
+		address: sol.publicKey,
+		privateKey: sol.privateKey
+	};
+}
+/** Validate key, store in process.env. Caller persists to config if needed. */
+function importWallet(chain, privateKey) {
+	const trimmed = privateKey.trim();
+	if (chain === "evm") {
+		const v = validateEvmPrivateKey(trimmed);
+		if (!v.valid) return {
+			success: false,
+			chain,
+			address: null,
+			error: v.error
+		};
+		process.env.EVM_PRIVATE_KEY = trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
+		logger.info(`[wallet] Imported EVM wallet: ${v.address}`);
+		return {
+			success: true,
+			chain,
+			address: v.address,
+			error: null
+		};
+	}
+	const v = validateSolanaPrivateKey(trimmed);
+	if (!v.valid) return {
+		success: false,
+		chain,
+		address: null,
+		error: v.error
+	};
+	process.env.SOLANA_PRIVATE_KEY = trimmed;
+	logger.info(`[wallet] Imported Solana wallet: ${v.address}`);
+	return {
+		success: true,
+		chain,
+		address: v.address,
+		error: null
+	};
+}
+/** Derive addresses from env keys. Works without a running runtime. */
+function getWalletAddresses() {
+	let evmAddress = null;
+	let solanaAddress = null;
+	const evmKey = process.env.EVM_PRIVATE_KEY;
+	if (evmKey) try {
+		evmAddress = deriveEvmAddress(evmKey);
+	} catch (e) {
+		logger.warn(`Bad EVM key: ${e}`);
+	}
+	const solKey = process.env.SOLANA_PRIVATE_KEY;
+	if (solKey) try {
+		solanaAddress = deriveSolanaAddress(solKey);
+	} catch (e) {
+		logger.warn(`Bad SOL key: ${e}`);
+	}
+	return {
+		evmAddress,
+		solanaAddress
+	};
+}
+/** Parse JSON from a fetch response. If the body isn't JSON, throw with the raw text. */
+async function jsonOrThrow(res) {
+	const text = await res.text();
+	if (!res.ok) throw new Error(text.slice(0, 200) || `HTTP ${res.status}`);
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw new Error(text.slice(0, 200) || "Invalid JSON");
+	}
+}
+async function fetchEvmBalances(address, alchemyKey) {
+	return Promise.all(DEFAULT_EVM_CHAINS.map(async (chain) => {
+		const fail = (msg) => ({
+			chain: chain.name,
+			chainId: chain.chainId,
+			nativeBalance: "0",
+			nativeSymbol: chain.nativeSymbol,
+			nativeValueUsd: "0",
+			tokens: [],
+			error: msg
+		});
+		try {
+			const url = `https://${chain.subdomain}.g.alchemy.com/v2/${alchemyKey}`;
+			const rpc = (body) => ({
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+				body
+			});
+			const nativeData = await jsonOrThrow(await fetch(url, rpc(JSON.stringify({
+				jsonrpc: "2.0",
+				id: 1,
+				method: "eth_getBalance",
+				params: [address, "latest"]
+			}))));
+			const nativeBalance = formatWei(nativeData.result ? BigInt(nativeData.result) : 0n, 18);
+			const nonZero = ((await jsonOrThrow(await fetch(url, rpc(JSON.stringify({
+				jsonrpc: "2.0",
+				id: 2,
+				method: "alchemy_getTokenBalances",
+				params: [address, "DEFAULT_TOKENS"]
+			}))))).result?.tokenBalances ?? []).filter((t) => t.tokenBalance && t.tokenBalance !== "0x0" && t.tokenBalance !== "0x");
+			const tokens = (await Promise.allSettled(nonZero.slice(0, 50).map(async (tok) => {
+				const meta = (await jsonOrThrow(await fetch(url, rpc(JSON.stringify({
+					jsonrpc: "2.0",
+					id: 3,
+					method: "alchemy_getTokenMetadata",
+					params: [tok.contractAddress]
+				}))))).result;
+				const decimals = meta?.decimals ?? 18;
+				return {
+					symbol: meta?.symbol ?? "???",
+					name: meta?.name ?? "Unknown Token",
+					contractAddress: tok.contractAddress,
+					balance: formatWei(BigInt(tok.tokenBalance), decimals),
+					decimals,
+					valueUsd: "0",
+					logoUrl: meta?.logo ?? ""
+				};
+			}))).filter((r) => r.status === "fulfilled").map((r) => r.value);
+			return {
+				chain: chain.name,
+				chainId: chain.chainId,
+				nativeBalance,
+				nativeSymbol: chain.nativeSymbol,
+				nativeValueUsd: "0",
+				tokens,
+				error: null
+			};
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			logger.warn(`EVM balance fetch failed for ${chain.name}: ${msg}`);
+			return fail(msg);
+		}
+	}));
+}
+async function fetchEvmNfts(address, alchemyKey) {
+	return Promise.all(DEFAULT_EVM_CHAINS.map(async (chain) => {
+		try {
+			const data = await jsonOrThrow(await fetch(`https://${chain.subdomain}.g.alchemy.com/nft/v3/${alchemyKey}/getNFTsForOwner?owner=${address}&withMetadata=true&pageSize=50`, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) }));
+			return {
+				chain: chain.name,
+				nfts: (data.ownedNfts ?? []).map((nft) => ({
+					contractAddress: nft.contract?.address ?? "",
+					tokenId: nft.tokenId ?? "",
+					name: nft.name ?? "Untitled",
+					description: (nft.description ?? "").slice(0, 200),
+					imageUrl: nft.image?.cachedUrl ?? nft.image?.thumbnailUrl ?? nft.image?.originalUrl ?? "",
+					collectionName: nft.contract?.openSeaMetadata?.collectionName ?? nft.contract?.name ?? "",
+					tokenType: nft.tokenType ?? "ERC721"
+				}))
+			};
+		} catch (err) {
+			logger.warn(`EVM NFT fetch failed for ${chain.name}: ${err}`);
+			return {
+				chain: chain.name,
+				nfts: []
+			};
+		}
+	}));
+}
+async function fetchSolanaBalances(address, heliusKey) {
+	const url = `https://mainnet.helius-rpc.com/?api-key=${heliusKey}`;
+	const rpc = (body) => ({
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+		body
+	});
+	let solBalance = "0";
+	try {
+		const data = await jsonOrThrow(await fetch(url, rpc(JSON.stringify({
+			jsonrpc: "2.0",
+			id: 1,
+			method: "getBalance",
+			params: [address]
+		}))));
+		if (data.error?.message) throw new Error(data.error.message);
+		solBalance = ((data.result?.value ?? 0) / 1e9).toFixed(9);
+	} catch (err) {
+		logger.warn(`SOL balance fetch failed: ${err instanceof Error ? err.message : err}`);
+	}
+	const tokens = [];
+	try {
+		const data = await jsonOrThrow(await fetch(url, rpc(JSON.stringify({
+			jsonrpc: "2.0",
+			id: 2,
+			method: "getAssetsByOwner",
+			params: {
+				ownerAddress: address,
+				displayOptions: {
+					showFungible: true,
+					showNativeBalance: true
+				},
+				page: 1,
+				limit: 100
+			}
+		}))));
+		if (data.error?.message) throw new Error(data.error.message);
+		for (const item of data.result?.items ?? []) {
+			if (item.interface !== "FungibleToken" && item.interface !== "FungibleAsset") continue;
+			const dec = item.token_info?.decimals ?? 0;
+			const raw = item.token_info?.balance ?? 0;
+			tokens.push({
+				symbol: item.token_info?.symbol ?? item.content?.metadata?.symbol ?? "???",
+				name: item.content?.metadata?.name ?? "Unknown",
+				mint: item.id,
+				balance: dec > 0 ? (raw / 10 ** dec).toString() : raw.toString(),
+				decimals: dec,
+				valueUsd: item.token_info?.price_info?.total_price?.toFixed(2) ?? "0",
+				logoUrl: item.content?.links?.image ?? ""
+			});
+		}
+	} catch (err) {
+		logger.warn(`Solana token fetch failed: ${err instanceof Error ? err.message : err}`);
+	}
+	return {
+		solBalance,
+		solValueUsd: "0",
+		tokens
+	};
+}
+async function fetchSolanaNfts(address, heliusKey) {
+	const url = `https://mainnet.helius-rpc.com/?api-key=${heliusKey}`;
+	try {
+		const data = await jsonOrThrow(await fetch(url, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: 1,
+				method: "getAssetsByOwner",
+				params: {
+					ownerAddress: address,
+					displayOptions: { showFungible: false },
+					page: 1,
+					limit: 100
+				}
+			})
+		}));
+		if (data.error?.message) throw new Error(data.error.message);
+		return (data.result?.items ?? []).filter((i) => i.interface === "V1_NFT" || i.interface === "ProgrammableNFT" || i.interface === "V2_NFT").map((i) => ({
+			mint: i.id,
+			name: i.content?.metadata?.name ?? "Untitled",
+			description: (i.content?.metadata?.description ?? "").slice(0, 200),
+			imageUrl: i.content?.links?.image ?? "",
+			collectionName: i.grouping?.find((g) => g.group_key === "collection")?.collection_metadata?.name ?? ""
+		}));
+	} catch (err) {
+		logger.warn(`Solana NFT fetch failed: ${err}`);
+		return [];
+	}
+}
+function formatWei(wei, decimals) {
+	if (wei <= 0n || decimals <= 0) return wei <= 0n ? "0" : wei.toString();
+	const divisor = 10n ** BigInt(decimals);
+	const whole = wei / divisor;
+	const rem = wei % divisor;
+	if (rem === 0n) return whole.toString();
+	return `${whole}.${rem.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
+}
+
+//#endregion
+export { deriveEvmAddress, deriveSolanaAddress, fetchEvmBalances, fetchEvmNfts, fetchSolanaBalances, fetchSolanaNfts, generateWalletForChain, generateWalletKeys, getWalletAddresses, importWallet, validatePrivateKey };