@elizaos/plugin-steward-app 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/api/wallet.js

@@ -0,0 +1,617 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { logger, resolveStateDir } from "@elizaos/core";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import * as ethers from "ethers";
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readStringField(record, key) {
+  const value = record[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readStewardAgentWalletPayload(value) {
+  const envelope = isRecord(value) ? value : {};
+  const payload = isRecord(envelope.data) ? envelope.data : envelope;
+  const walletAddresses = isRecord(payload.walletAddresses) ? {
+    evm: readStringField(payload.walletAddresses, "evm"),
+    solana: readStringField(payload.walletAddresses, "solana")
+  } : void 0;
+  return {
+    walletAddress: readStringField(payload, "walletAddress"),
+    walletAddresses
+  };
+}
+import {
+  computeValueUsd,
+  DEX_PRICE_TIMEOUT_MS,
+  DEXPAPRIKA_CHAIN_MAP,
+  DEXSCREENER_CHAIN_MAP,
+  fetchDexPaprikaPrices,
+  fetchDexPrices,
+  fetchDexScreenerPrices,
+  WRAPPED_NATIVE
+} from "./wallet-dex-prices.js";
+import {
+  DEFAULT_EVM_CHAINS,
+  fetchEvmBalances,
+  resolveEvmProviderKeys
+} from "./wallet-evm-balance.js";
+const FETCH_TIMEOUT_MS = 15e3;
+const MANAGED_EVM_ADDRESS_ENV_KEY = "ELIZA_MANAGED_EVM_ADDRESS";
+const MANAGED_SOLANA_ADDRESS_ENV_KEY = "ELIZA_MANAGED_SOLANA_ADDRESS";
+let stewardAddressCache = null;
+function generateEvmPrivateKey() {
+  return `0x${crypto.randomBytes(32).toString("hex")}`;
+}
+function deriveEvmAddress(privateKeyHex) {
+  const cleaned = privateKeyHex.startsWith("0x") ? privateKeyHex.slice(2) : privateKeyHex;
+  const pubKey = secp256k1.getPublicKey(Buffer.from(cleaned, "hex"), false);
+  const pubNoPrefix = pubKey.subarray(1);
+  const hash = ethers.keccak256(pubNoPrefix);
+  const raw = hash.slice(26);
+  return ethers.getAddress(`0x${raw}`);
+}
+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(privateKeyString) {
+  const secretBytes = decodeSolanaPrivateKey(privateKeyString);
+  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"
+    });
+    const pubDer = crypto.createPublicKey(keyObj).export({ type: "spki", format: "der" });
+    return base58Encode(pubDer.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 ENV_SENTINEL_RE = /^\[?\s*(REDACTED|PLACEHOLDER|T(?:O)D(?:O)|CHANGEME|EMPTY)\s*]?$/i;
+function decodeSolanaPrivateKey(key) {
+  if (ENV_SENTINEL_RE.test(key)) {
+    throw new Error("sentinel env value");
+  }
+  if (key.startsWith("[") && key.endsWith("]") && /^\[\s*\d/.test(key)) {
+    try {
+      const parsed = JSON.parse(key);
+      if (!Array.isArray(parsed) || !parsed.every((v) => typeof v === "number")) {
+        throw new Error("not a numeric array");
+      }
+      return Buffer.from(parsed);
+    } catch {
+      throw new Error("Invalid JSON byte-array format");
+    }
+  }
+  return base58Decode(key);
+}
+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: ${String(err)}`
+    };
+  }
+}
+function validateSolanaPrivateKey(key) {
+  try {
+    const bytes = decodeSolanaPrivateKey(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: ${String(err)}`
+    };
+  }
+}
+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 maskSecret(value) {
+  if (!value || value.length <= 8) return "****";
+  return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+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
+  };
+}
+function syncSolanaPublicKeyEnv(privateKey = process.env.SOLANA_PRIVATE_KEY) {
+  const trimmed = privateKey?.trim();
+  if (!trimmed || ENV_SENTINEL_RE.test(trimmed)) {
+    return null;
+  }
+  try {
+    const publicKey = deriveSolanaAddress(trimmed);
+    process.env.SOLANA_PUBLIC_KEY = publicKey;
+    process.env.WALLET_PUBLIC_KEY = publicKey;
+    return publicKey;
+  } catch {
+    return null;
+  }
+}
+function setSolanaWalletEnv(privateKey) {
+  const trimmed = privateKey.trim();
+  process.env.SOLANA_PRIVATE_KEY = trimmed;
+  return syncSolanaPublicKeyEnv(trimmed);
+}
+function importWallet(chain, privateKey) {
+  const trimmed = privateKey.trim();
+  if (chain === "evm") {
+    const v2 = validateEvmPrivateKey(trimmed);
+    if (!v2.valid)
+      return { success: false, chain, address: null, error: v2.error };
+    process.env.EVM_PRIVATE_KEY = trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
+    logger.info(`[wallet] Imported EVM wallet: ${v2.address}`);
+    return { success: true, chain, address: v2.address, error: null };
+  }
+  const v = validateSolanaPrivateKey(trimmed);
+  if (!v.valid) return { success: false, chain, address: null, error: v.error };
+  setSolanaWalletEnv(trimmed);
+  logger.info(`[wallet] Imported Solana wallet: ${v.address}`);
+  return { success: true, chain, address: v.address, error: null };
+}
+const STEWARD_EVM_ADDRESS_ENV_KEY = "STEWARD_EVM_ADDRESS";
+const STEWARD_SOLANA_ADDRESS_ENV_KEY = "STEWARD_SOLANA_ADDRESS";
+function resolveStewardCredentialsPath() {
+  return path.join(resolveStateDir(), "steward-credentials.json");
+}
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function readPersistedStewardCredentials() {
+  const credentialsPath = resolveStewardCredentialsPath();
+  try {
+    if (!fs.existsSync(credentialsPath)) {
+      return null;
+    }
+    const parsed = JSON.parse(
+      fs.readFileSync(credentialsPath, "utf8")
+    );
+    return {
+      apiUrl: normalizeOptionalString(parsed.apiUrl),
+      tenantId: normalizeOptionalString(parsed.tenantId),
+      agentId: normalizeOptionalString(parsed.agentId),
+      apiKey: normalizeOptionalString(parsed.apiKey),
+      agentToken: normalizeOptionalString(parsed.agentToken)
+    };
+  } catch {
+    return null;
+  }
+}
+async function initStewardWalletCache() {
+  const persisted = readPersistedStewardCredentials();
+  const stewardApiUrl = normalizeOptionalString(process.env.STEWARD_API_URL) ?? persisted?.apiUrl;
+  if (!stewardApiUrl) return;
+  const agentId = normalizeOptionalString(process.env.STEWARD_AGENT_ID) || normalizeOptionalString(process.env.ELIZA_STEWARD_AGENT_ID) || persisted?.agentId || null;
+  if (!agentId) return;
+  try {
+    const headers = { Accept: "application/json" };
+    const bearerToken = normalizeOptionalString(process.env.STEWARD_AGENT_TOKEN) ?? persisted?.agentToken;
+    const apiKey = normalizeOptionalString(process.env.STEWARD_API_KEY) ?? persisted?.apiKey;
+    const tenantId = normalizeOptionalString(process.env.STEWARD_TENANT_ID) ?? persisted?.tenantId;
+    if (bearerToken) {
+      headers.Authorization = `Bearer ${bearerToken}`;
+    } else if (apiKey) {
+      headers["X-Steward-Key"] = apiKey;
+    }
+    if (tenantId) {
+      headers["X-Steward-Tenant"] = tenantId;
+    }
+    const res = await fetch(
+      `${stewardApiUrl}/agents/${encodeURIComponent(agentId)}`,
+      { headers, signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) }
+    );
+    if (!res.ok) {
+      logger.warn(
+        `[wallet] Steward wallet cache init: agent lookup returned ${res.status}`
+      );
+      return;
+    }
+    const agent = readStewardAgentWalletPayload(await res.json());
+    const stewardEvm = agent?.walletAddresses?.evm?.trim() || agent?.walletAddress?.trim() || null;
+    const stewardSolana = agent?.walletAddresses?.solana?.trim() || null;
+    stewardAddressCache = { evm: stewardEvm, solana: stewardSolana };
+    if (stewardEvm) {
+      process.env[STEWARD_EVM_ADDRESS_ENV_KEY] = stewardEvm;
+    } else {
+      delete process.env[STEWARD_EVM_ADDRESS_ENV_KEY];
+    }
+    if (stewardSolana) {
+      process.env[STEWARD_SOLANA_ADDRESS_ENV_KEY] = stewardSolana;
+      if (!process.env.SOLANA_PUBLIC_KEY?.trim()) {
+        process.env.SOLANA_PUBLIC_KEY = stewardSolana;
+      }
+      if (!process.env.WALLET_PUBLIC_KEY?.trim()) {
+        process.env.WALLET_PUBLIC_KEY = stewardSolana;
+      }
+    } else {
+      delete process.env[STEWARD_SOLANA_ADDRESS_ENV_KEY];
+    }
+    if (stewardEvm) {
+      logger.info(`[wallet] Steward EVM address cached: ${stewardEvm}`);
+    }
+    if (stewardSolana) {
+      logger.info(`[wallet] Steward Solana address cached: ${stewardSolana}`);
+    }
+  } catch (err) {
+    logger.debug(`[wallet] Steward wallet cache init unavailable: ${err}`);
+  }
+}
+function getWalletAddresses() {
+  let evmAddress = null;
+  let solanaAddress = null;
+  const stewardEvm = stewardAddressCache?.evm?.trim() ?? process.env[STEWARD_EVM_ADDRESS_ENV_KEY]?.trim();
+  if (stewardEvm && /^0x[0-9a-fA-F]{40}$/.test(stewardEvm)) {
+    evmAddress = stewardEvm;
+  }
+  const stewardSolana = stewardAddressCache?.solana?.trim() ?? process.env[STEWARD_SOLANA_ADDRESS_ENV_KEY]?.trim();
+  if (stewardSolana) {
+    try {
+      const decoded = base58Decode(stewardSolana);
+      if (decoded.length === 32) {
+        solanaAddress = stewardSolana;
+      }
+    } catch {
+    }
+  }
+  if (!evmAddress) {
+    const evmKey = process.env.EVM_PRIVATE_KEY;
+    if (evmKey && !ENV_SENTINEL_RE.test(evmKey)) {
+      try {
+        evmAddress = deriveEvmAddress(evmKey);
+      } catch (e) {
+        logger.warn(`Bad EVM key: ${e}`);
+      }
+    }
+  }
+  if (!solanaAddress) {
+    const solKey = process.env.SOLANA_PRIVATE_KEY;
+    if (solKey && !ENV_SENTINEL_RE.test(solKey)) {
+      try {
+        solanaAddress = deriveSolanaAddress(solKey);
+      } catch (e) {
+        logger.warn(`Bad SOL key: ${e}`);
+      }
+    }
+  }
+  if (!evmAddress) {
+    const managedEvmAddress = process.env[MANAGED_EVM_ADDRESS_ENV_KEY];
+    if (managedEvmAddress) {
+      const trimmed = managedEvmAddress.trim();
+      if (/^0x[0-9a-fA-F]{40}$/.test(trimmed)) {
+        evmAddress = trimmed;
+      } else {
+        logger.warn("Bad managed EVM address in env");
+      }
+    }
+  }
+  if (!solanaAddress) {
+    const managedSolanaAddress = process.env[MANAGED_SOLANA_ADDRESS_ENV_KEY];
+    if (managedSolanaAddress) {
+      const trimmed = managedSolanaAddress.trim();
+      try {
+        const decoded = base58Decode(trimmed);
+        if (decoded.length === 32) {
+          solanaAddress = trimmed;
+        } else {
+          logger.warn("Bad managed Solana address in env");
+        }
+      } catch {
+        logger.warn("Bad managed Solana address in env");
+      }
+    }
+  }
+  return { evmAddress, solanaAddress };
+}
+async function getWalletAddressesWithSteward() {
+  const base = getWalletAddresses();
+  const stewardApiUrl = process.env.STEWARD_API_URL?.trim();
+  if (!stewardApiUrl) {
+    return base;
+  }
+  const agentId = process.env.STEWARD_AGENT_ID?.trim() || process.env.ELIZA_STEWARD_AGENT_ID?.trim() || base.evmAddress?.trim() || null;
+  if (!agentId) {
+    return base;
+  }
+  try {
+    const headers = {
+      Accept: "application/json"
+    };
+    const bearerToken = process.env.STEWARD_AGENT_TOKEN?.trim();
+    const apiKey = process.env.STEWARD_API_KEY?.trim();
+    const tenantId = process.env.STEWARD_TENANT_ID?.trim();
+    if (bearerToken) {
+      headers.Authorization = `Bearer ${bearerToken}`;
+    } else if (apiKey) {
+      headers["X-Steward-Key"] = apiKey;
+    }
+    if (tenantId) {
+      headers["X-Steward-Tenant"] = tenantId;
+    }
+    const res = await fetch(
+      `${stewardApiUrl}/agents/${encodeURIComponent(agentId)}`,
+      { headers, signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) }
+    );
+    if (!res.ok) {
+      logger.warn(`Steward agent lookup returned ${res.status}`);
+      return base;
+    }
+    const agent = readStewardAgentWalletPayload(await res.json());
+    const stewardEvm = agent?.walletAddresses?.evm?.trim() || agent?.walletAddress?.trim() || null;
+    const stewardSolana = agent?.walletAddresses?.solana?.trim() || null;
+    return {
+      evmAddress: base.evmAddress ?? stewardEvm,
+      solanaAddress: base.solanaAddress ?? stewardSolana,
+      stewardEvmAddress: stewardEvm,
+      stewardSolanaAddress: stewardSolana
+    };
+  } catch (err) {
+    logger.warn(`Steward wallet address lookup failed: ${err}`);
+    return base;
+  }
+}
+function rpcJsonRequest(body) {
+  return {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    body
+  };
+}
+function describeRpcEndpoint(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return "rpc";
+  }
+}
+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 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: ${String(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: ${String(err)}`);
+  }
+  return { solBalance, solValueUsd: "0", tokens };
+}
+async function fetchSolanaNativeBalanceViaRpc(address, rpcUrls) {
+  const urls = [...new Set(rpcUrls)].filter((u) => Boolean(u?.trim()));
+  const errors = [];
+  for (const rpcUrl of urls) {
+    try {
+      const data = await jsonOrThrow(
+        await fetch(
+          rpcUrl,
+          rpcJsonRequest(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              id: 1,
+              method: "getBalance",
+              params: [address]
+            })
+          )
+        )
+      );
+      if (data.error?.message) throw new Error(data.error.message);
+      const solBalance = ((data.result?.value ?? 0) / 1e9).toFixed(9);
+      return { solBalance, solValueUsd: "0", tokens: [] };
+    } catch (err) {
+      const msg = String(err);
+      errors.push(`${describeRpcEndpoint(rpcUrl)}: ${msg}`);
+    }
+  }
+  throw new Error(errors.join(" | ").slice(0, 400) || "Solana RPC unavailable");
+}
+export {
+  DEFAULT_EVM_CHAINS,
+  DEXPAPRIKA_CHAIN_MAP,
+  DEXSCREENER_CHAIN_MAP,
+  DEX_PRICE_TIMEOUT_MS,
+  MANAGED_EVM_ADDRESS_ENV_KEY,
+  MANAGED_SOLANA_ADDRESS_ENV_KEY,
+  STEWARD_EVM_ADDRESS_ENV_KEY,
+  STEWARD_SOLANA_ADDRESS_ENV_KEY,
+  WRAPPED_NATIVE,
+  computeValueUsd,
+  deriveEvmAddress,
+  deriveSolanaAddress,
+  fetchDexPaprikaPrices,
+  fetchDexPrices,
+  fetchDexScreenerPrices,
+  fetchEvmBalances,
+  fetchSolanaBalances,
+  fetchSolanaNativeBalanceViaRpc,
+  generateWalletForChain,
+  generateWalletKeys,
+  getWalletAddresses,
+  getWalletAddressesWithSteward,
+  importWallet,
+  initStewardWalletCache,
+  maskSecret,
+  resolveEvmProviderKeys,
+  setSolanaWalletEnv,
+  syncSolanaPublicKeyEnv,
+  validateEvmPrivateKey,
+  validatePrivateKey,
+  validateSolanaPrivateKey
+};
+//# sourceMappingURL=wallet.js.map