@elizaos/autonomous 2.0.0-alpha.37

package/src/api/wallet-routes.ts

@@ -0,0 +1,450 @@
+import type http from "node:http";
+import { logger } from "@elizaos/core";
+import type { MiladyConfig } from "../config/config";
+import { createIntegrationTelemetrySpan } from "../diagnostics/integration-observability";
+import type { RouteHelpers, RouteRequestMeta } from "./route-helpers";
+import {
+  fetchEvmBalances,
+  fetchEvmNfts,
+  fetchSolanaBalances,
+  fetchSolanaNativeBalanceViaRpc,
+  fetchSolanaNfts,
+  generateWalletForChain,
+  getWalletAddresses,
+  importWallet,
+  validatePrivateKey,
+  type WalletBalancesResponse,
+  type WalletChain,
+  type WalletConfigStatus,
+  type WalletNftsResponse,
+} from "./wallet";
+import { resolveWalletRpcReadiness } from "./wallet-rpc";
+
+interface WalletExportRequestBody {
+  confirm?: boolean;
+  exportToken?: string;
+}
+
+interface WalletExportRejectionLike {
+  status: 401 | 403;
+  reason: string;
+}
+
+export interface WalletRouteDependencies {
+  getWalletAddresses: typeof getWalletAddresses;
+  fetchEvmBalances: typeof fetchEvmBalances;
+  fetchSolanaBalances: typeof fetchSolanaBalances;
+  fetchSolanaNativeBalanceViaRpc: typeof fetchSolanaNativeBalanceViaRpc;
+  fetchEvmNfts: typeof fetchEvmNfts;
+  fetchSolanaNfts: typeof fetchSolanaNfts;
+  validatePrivateKey: typeof validatePrivateKey;
+  importWallet: typeof importWallet;
+  generateWalletForChain: typeof generateWalletForChain;
+}
+
+export const DEFAULT_WALLET_ROUTE_DEPENDENCIES: WalletRouteDependencies = {
+  getWalletAddresses,
+  fetchEvmBalances,
+  fetchSolanaBalances,
+  fetchSolanaNativeBalanceViaRpc,
+  fetchEvmNfts,
+  fetchSolanaNfts,
+  validatePrivateKey,
+  importWallet,
+  generateWalletForChain,
+};
+
+export interface WalletRouteContext
+  extends RouteRequestMeta,
+    Pick<RouteHelpers, "readJsonBody" | "json" | "error"> {
+  config: MiladyConfig;
+  saveConfig: (config: MiladyConfig) => void;
+  ensureWalletKeysInEnvAndConfig: (config: MiladyConfig) => boolean;
+  resolveWalletExportRejection: (
+    req: http.IncomingMessage,
+    body: WalletExportRequestBody,
+  ) => WalletExportRejectionLike | null;
+  scheduleRuntimeRestart?: (reason: string) => void;
+  deps?: WalletRouteDependencies;
+}
+
+export async function handleWalletRoutes(
+  ctx: WalletRouteContext,
+): Promise<boolean> {
+  const {
+    req,
+    res,
+    method,
+    pathname,
+    config,
+    saveConfig,
+    ensureWalletKeysInEnvAndConfig,
+    resolveWalletExportRejection,
+    readJsonBody,
+    json,
+    error,
+  } = ctx;
+  const deps = ctx.deps ?? DEFAULT_WALLET_ROUTE_DEPENDENCIES;
+
+  // GET /api/wallet/addresses
+  if (method === "GET" && pathname === "/api/wallet/addresses") {
+    json(res, deps.getWalletAddresses());
+    return true;
+  }
+
+  // GET /api/wallet/balances
+  if (method === "GET" && pathname === "/api/wallet/balances") {
+    const addresses = deps.getWalletAddresses();
+    const rpcReadiness = resolveWalletRpcReadiness(config);
+    const alchemyKey = process.env.ALCHEMY_API_KEY?.trim() || null;
+    const ankrKey = process.env.ANKR_API_KEY?.trim() || null;
+    const heliusKey = process.env.HELIUS_API_KEY?.trim() || null;
+
+    const result: WalletBalancesResponse = { evm: null, solana: null };
+
+    if (addresses.evmAddress && rpcReadiness.evmBalanceReady) {
+      const evmBalancesSpan = createIntegrationTelemetrySpan({
+        boundary: "wallet",
+        operation: "fetch_evm_balances",
+      });
+      try {
+        const chains = await deps.fetchEvmBalances(addresses.evmAddress, {
+          alchemyKey,
+          ankrKey,
+          cloudManagedAccess: rpcReadiness.cloudManagedAccess,
+          bscRpcUrls: rpcReadiness.bscRpcUrls,
+          ethereumRpcUrls: rpcReadiness.ethereumRpcUrls,
+          baseRpcUrls: rpcReadiness.baseRpcUrls,
+          avaxRpcUrls: rpcReadiness.avalancheRpcUrls,
+          nodeRealBscRpcUrl: process.env.NODEREAL_BSC_RPC_URL,
+          quickNodeBscRpcUrl: process.env.QUICKNODE_BSC_RPC_URL,
+          bscRpcUrl: process.env.BSC_RPC_URL,
+          ethereumRpcUrl: process.env.ETHEREUM_RPC_URL,
+          baseRpcUrl: process.env.BASE_RPC_URL,
+          avaxRpcUrl: process.env.AVALANCHE_RPC_URL,
+        });
+        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 && rpcReadiness.solanaBalanceReady) {
+      const solanaBalancesSpan = createIntegrationTelemetrySpan({
+        boundary: "wallet",
+        operation: "fetch_solana_balances",
+      });
+      try {
+        const solanaData = heliusKey
+          ? await deps.fetchSolanaBalances(addresses.solanaAddress, heliusKey)
+          : await deps.fetchSolanaNativeBalanceViaRpc(
+              addresses.solanaAddress,
+              rpcReadiness.solanaRpcUrls,
+            );
+        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;
+  }
+
+  // GET /api/wallet/nfts
+  if (method === "GET" && pathname === "/api/wallet/nfts") {
+    const addresses = deps.getWalletAddresses();
+    const rpcReadiness = resolveWalletRpcReadiness(config);
+    const alchemyKey = process.env.ALCHEMY_API_KEY?.trim() || null;
+    const ankrKey = process.env.ANKR_API_KEY?.trim() || null;
+    const heliusKey = process.env.HELIUS_API_KEY?.trim() || null;
+
+    const result: WalletNftsResponse = { evm: [], solana: null };
+
+    if (
+      addresses.evmAddress &&
+      (Boolean(alchemyKey) || rpcReadiness.managedBscRpcReady)
+    ) {
+      const evmNftsSpan = createIntegrationTelemetrySpan({
+        boundary: "wallet",
+        operation: "fetch_evm_nfts",
+      });
+      try {
+        result.evm = await deps.fetchEvmNfts(addresses.evmAddress, {
+          alchemyKey,
+          ankrKey,
+          cloudManagedAccess: rpcReadiness.cloudManagedAccess,
+          bscRpcUrls: rpcReadiness.bscRpcUrls,
+          ethereumRpcUrls: rpcReadiness.ethereumRpcUrls,
+          baseRpcUrls: rpcReadiness.baseRpcUrls,
+          avaxRpcUrls: rpcReadiness.avalancheRpcUrls,
+          nodeRealBscRpcUrl: process.env.NODEREAL_BSC_RPC_URL,
+          quickNodeBscRpcUrl: process.env.QUICKNODE_BSC_RPC_URL,
+          bscRpcUrl: process.env.BSC_RPC_URL,
+          ethereumRpcUrl: process.env.ETHEREUM_RPC_URL,
+          baseRpcUrl: process.env.BASE_RPC_URL,
+          avaxRpcUrl: process.env.AVALANCHE_RPC_URL,
+        });
+        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 {
+        const nfts = await deps.fetchSolanaNfts(
+          addresses.solanaAddress,
+          heliusKey,
+        );
+        result.solana = { nfts };
+        solanaNftsSpan.success();
+      } catch (err) {
+        solanaNftsSpan.failure({ error: err });
+        logger.warn(`[wallet] Solana NFT fetch failed: ${err}`);
+      }
+    }
+
+    json(res, result);
+    return true;
+  }
+
+  // POST /api/wallet/import
+  if (method === "POST" && pathname === "/api/wallet/import") {
+    const body = await readJsonBody<{ chain?: string; privateKey?: string }>(
+      req,
+      res,
+    );
+    if (!body) return true;
+
+    if (!body.privateKey?.trim()) {
+      error(res, "privateKey is required");
+      return true;
+    }
+
+    let chain: WalletChain;
+    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 {
+      const detection = deps.validatePrivateKey(body.privateKey.trim());
+      chain = detection.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 as Record<string, string>)[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;
+  }
+
+  // POST /api/wallet/generate
+  if (method === "POST" && pathname === "/api/wallet/generate") {
+    const body = await readJsonBody<{ chain?: string }>(req, res);
+    if (!body) return true;
+
+    const chain = body.chain as string | undefined;
+    const validChains: Array<WalletChain | "both"> = ["evm", "solana", "both"];
+
+    if (chain && !validChains.includes(chain as WalletChain | "both")) {
+      error(
+        res,
+        `Unsupported chain: ${chain}. Must be "evm", "solana", or "both".`,
+      );
+      return true;
+    }
+
+    const targetChain = (chain ?? "both") as WalletChain | "both";
+
+    if (!config.env) config.env = {};
+
+    const generated: Array<{ chain: WalletChain; address: string }> = [];
+
+    if (targetChain === "both" || targetChain === "evm") {
+      const result = deps.generateWalletForChain("evm");
+      process.env.EVM_PRIVATE_KEY = result.privateKey;
+      (config.env as Record<string, string>).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 as Record<string, string>).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;
+  }
+
+  // GET /api/wallet/config
+  if (method === "GET" && pathname === "/api/wallet/config") {
+    const addresses = deps.getWalletAddresses();
+    const rpcReadiness = resolveWalletRpcReadiness(config);
+    const alchemyKeySet = Boolean(process.env.ALCHEMY_API_KEY?.trim());
+    const ankrKeySet = Boolean(process.env.ANKR_API_KEY?.trim());
+    const nodeRealSet = Boolean(process.env.NODEREAL_BSC_RPC_URL?.trim());
+    const quickNodeSet = Boolean(process.env.QUICKNODE_BSC_RPC_URL?.trim());
+    const configStatus: WalletConfigStatus = {
+      alchemyKeySet,
+      infuraKeySet: Boolean(process.env.INFURA_API_KEY?.trim()),
+      ankrKeySet,
+      nodeRealBscRpcSet: nodeRealSet,
+      quickNodeBscRpcSet: quickNodeSet,
+      managedBscRpcReady: rpcReadiness.managedBscRpcReady,
+      cloudManagedAccess: rpcReadiness.cloudManagedAccess,
+      evmBalanceReady: rpcReadiness.evmBalanceReady,
+      ethereumBalanceReady:
+        alchemyKeySet || rpcReadiness.ethereumRpcUrls.length > 0,
+      baseBalanceReady: alchemyKeySet || rpcReadiness.baseRpcUrls.length > 0,
+      bscBalanceReady: ankrKeySet || rpcReadiness.bscRpcUrls.length > 0,
+      avalancheBalanceReady:
+        alchemyKeySet || rpcReadiness.avalancheRpcUrls.length > 0,
+      solanaBalanceReady: rpcReadiness.solanaBalanceReady,
+      heliusKeySet: Boolean(process.env.HELIUS_API_KEY?.trim()),
+      birdeyeKeySet: Boolean(process.env.BIRDEYE_API_KEY?.trim()),
+      evmChains: [
+        "Ethereum",
+        "Base",
+        "Arbitrum",
+        "Optimism",
+        "Polygon",
+        "BSC",
+        "Avalanche",
+      ],
+      evmAddress: addresses.evmAddress,
+      solanaAddress: addresses.solanaAddress,
+    };
+    json(res, configStatus);
+    return true;
+  }
+
+  // PUT /api/wallet/config
+  if (method === "PUT" && pathname === "/api/wallet/config") {
+    const body = await readJsonBody<Record<string, string>>(req, res);
+    if (!body) return true;
+
+    const allowedKeys = [
+      "ALCHEMY_API_KEY",
+      "INFURA_API_KEY",
+      "ANKR_API_KEY",
+      "ETHEREUM_RPC_URL",
+      "BASE_RPC_URL",
+      "AVALANCHE_RPC_URL",
+      "HELIUS_API_KEY",
+      "BIRDEYE_API_KEY",
+      "NODEREAL_BSC_RPC_URL",
+      "QUICKNODE_BSC_RPC_URL",
+      "BSC_RPC_URL",
+      "SOLANA_RPC_URL",
+    ];
+
+    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 as Record<string, string>)[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 as Record<string, string>).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;
+  }
+
+  // POST /api/wallet/export
+  if (method === "POST" && pathname === "/api/wallet/export") {
+    const body = await readJsonBody<WalletExportRequestBody>(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;
+}

package/src/api/wallet-rpc.ts

@@ -0,0 +1,235 @@
+import type { MiladyConfig } from "../config/config";
+
+export const DEFAULT_CLOUD_API_BASE_URL = "https://elizacloud.ai/api/v1";
+export const DEFAULT_PUBLIC_BSC_RPC_URLS = [
+  "https://bsc-dataseed1.binance.org/",
+] as const;
+export const DEFAULT_PUBLIC_ETHEREUM_RPC_URLS = [
+  "https://ethereum.publicnode.com/",
+] as const;
+export const DEFAULT_PUBLIC_BASE_RPC_URLS = [
+  "https://base.publicnode.com/",
+] as const;
+export const DEFAULT_PUBLIC_AVALANCHE_RPC_URLS = [
+  "https://avalanche.publicnode.com/ext/bc/C/rpc",
+] as const;
+export const DEFAULT_PUBLIC_SOLANA_RPC_URLS = [
+  "https://api.mainnet-beta.solana.com",
+] as const;
+
+export interface WalletRpcResolutionOptions {
+  cloudManagedAccess?: boolean | null;
+  cloudApiKey?: string | null;
+  cloudBaseUrl?: string | null;
+}
+
+export interface WalletRpcReadiness {
+  cloudManagedAccess: boolean;
+  managedBscRpcReady: boolean;
+  evmBalanceReady: boolean;
+  solanaBalanceReady: boolean;
+  bscRpcUrls: string[];
+  ethereumRpcUrls: string[];
+  baseRpcUrls: string[];
+  avalancheRpcUrls: string[];
+  solanaRpcUrls: string[];
+}
+
+type SupportedCloudEvmRpcChain = "mainnet" | "base" | "bsc" | "avalanche";
+
+export function normalizeRpcUrl(url: string | null | undefined): string | null {
+  if (typeof url !== "string") return null;
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return null;
+    }
+    return parsed.toString();
+  } catch {
+    return null;
+  }
+}
+
+function uniqueRpcUrls(
+  ...groups: Array<ReadonlyArray<string | null | undefined>>
+): string[] {
+  return [
+    ...new Set(
+      groups
+        .flat()
+        .map((url) => normalizeRpcUrl(url))
+        .filter((url): url is string => Boolean(url)),
+    ),
+  ];
+}
+
+function normalizeSecret(value: string | null | undefined): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+export function resolveCloudApiBaseUrl(
+  rawBaseUrl?: string | null,
+): string | null {
+  const candidate =
+    normalizeSecret(rawBaseUrl ?? process.env.ELIZAOS_CLOUD_BASE_URL) ??
+    DEFAULT_CLOUD_API_BASE_URL;
+  try {
+    const parsed = new URL(candidate);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return null;
+    }
+    parsed.hash = "";
+    parsed.search = "";
+    const normalizedBase = parsed.toString().replace(/\/+$/, "");
+    return normalizedBase.endsWith("/api/v1")
+      ? normalizedBase
+      : `${normalizedBase}/api/v1`;
+  } catch {
+    return null;
+  }
+}
+
+export function resolveCloudApiKey(
+  config?: Pick<MiladyConfig, "cloud"> | null,
+): string | null {
+  return normalizeSecret(
+    config?.cloud?.apiKey ?? process.env.ELIZAOS_CLOUD_API_KEY,
+  );
+}
+
+function buildCloudRpcProxyUrl(
+  pathname: string,
+  options: WalletRpcResolutionOptions = {},
+): string | null {
+  const cloudApiKey = normalizeSecret(
+    options.cloudApiKey ?? process.env.ELIZAOS_CLOUD_API_KEY,
+  );
+  const cloudManagedAccess = options.cloudManagedAccess ?? Boolean(cloudApiKey);
+  if (!cloudManagedAccess || !cloudApiKey) {
+    return null;
+  }
+
+  const cloudBaseUrl = resolveCloudApiBaseUrl(options.cloudBaseUrl);
+  if (!cloudBaseUrl) {
+    return null;
+  }
+
+  const url = new URL(
+    pathname.replace(/^\/+/, ""),
+    `${cloudBaseUrl.replace(/\/+$/, "")}/`,
+  );
+  url.searchParams.set("api_key", cloudApiKey);
+  return normalizeRpcUrl(url.toString());
+}
+
+export function buildCloudEvmRpcUrl(
+  chain: SupportedCloudEvmRpcChain,
+  options: WalletRpcResolutionOptions = {},
+): string | null {
+  return buildCloudRpcProxyUrl(`proxy/evm-rpc/${chain}`, options);
+}
+
+export function buildCloudSolanaRpcUrl(
+  options: WalletRpcResolutionOptions = {},
+): string | null {
+  return buildCloudRpcProxyUrl("proxy/solana-rpc", options);
+}
+
+export function hasElizaCloudRpcAccess(
+  config?: Pick<MiladyConfig, "cloud"> | null,
+): boolean {
+  return Boolean(resolveCloudApiKey(config));
+}
+
+export function resolveBscRpcUrls(
+  options: WalletRpcResolutionOptions = {},
+): string[] {
+  return uniqueRpcUrls(
+    [
+      process.env.NODEREAL_BSC_RPC_URL,
+      process.env.QUICKNODE_BSC_RPC_URL,
+      process.env.BSC_RPC_URL,
+      buildCloudEvmRpcUrl("bsc", options),
+    ],
+    options.cloudManagedAccess ? DEFAULT_PUBLIC_BSC_RPC_URLS : [],
+  );
+}
+
+export function resolveEthereumRpcUrls(
+  options: WalletRpcResolutionOptions = {},
+): string[] {
+  return uniqueRpcUrls(
+    [process.env.ETHEREUM_RPC_URL, buildCloudEvmRpcUrl("mainnet", options)],
+    options.cloudManagedAccess ? DEFAULT_PUBLIC_ETHEREUM_RPC_URLS : [],
+  );
+}
+
+export function resolveBaseRpcUrls(
+  options: WalletRpcResolutionOptions = {},
+): string[] {
+  return uniqueRpcUrls(
+    [process.env.BASE_RPC_URL, buildCloudEvmRpcUrl("base", options)],
+    options.cloudManagedAccess ? DEFAULT_PUBLIC_BASE_RPC_URLS : [],
+  );
+}
+
+export function resolveAvalancheRpcUrls(
+  options: WalletRpcResolutionOptions = {},
+): string[] {
+  return uniqueRpcUrls(
+    [process.env.AVALANCHE_RPC_URL, buildCloudEvmRpcUrl("avalanche", options)],
+    options.cloudManagedAccess ? DEFAULT_PUBLIC_AVALANCHE_RPC_URLS : [],
+  );
+}
+
+export function resolveSolanaRpcUrls(
+  options: WalletRpcResolutionOptions = {},
+): string[] {
+  return uniqueRpcUrls(
+    [process.env.SOLANA_RPC_URL, buildCloudSolanaRpcUrl(options)],
+    options.cloudManagedAccess ? DEFAULT_PUBLIC_SOLANA_RPC_URLS : [],
+  );
+}
+
+export function resolveWalletRpcReadiness(
+  config?: Pick<MiladyConfig, "cloud"> | null,
+): WalletRpcReadiness {
+  const cloudApiKey = resolveCloudApiKey(config);
+  const cloudBaseUrl = resolveCloudApiBaseUrl(config?.cloud?.baseUrl);
+  const cloudManagedAccess = Boolean(cloudApiKey);
+  const cloudOptions = {
+    cloudManagedAccess,
+    cloudApiKey,
+    cloudBaseUrl,
+  } satisfies WalletRpcResolutionOptions;
+  const bscRpcUrls = resolveBscRpcUrls(cloudOptions);
+  const ethereumRpcUrls = resolveEthereumRpcUrls(cloudOptions);
+  const baseRpcUrls = resolveBaseRpcUrls(cloudOptions);
+  const avalancheRpcUrls = resolveAvalancheRpcUrls(cloudOptions);
+  const solanaRpcUrls = resolveSolanaRpcUrls(cloudOptions);
+
+  return {
+    cloudManagedAccess,
+    managedBscRpcReady: bscRpcUrls.length > 0,
+    evmBalanceReady: Boolean(
+      process.env.ALCHEMY_API_KEY?.trim() ||
+        process.env.ANKR_API_KEY?.trim() ||
+        bscRpcUrls.length > 0 ||
+        ethereumRpcUrls.length > 0 ||
+        baseRpcUrls.length > 0 ||
+        avalancheRpcUrls.length > 0,
+    ),
+    solanaBalanceReady: Boolean(
+      process.env.HELIUS_API_KEY?.trim() || solanaRpcUrls.length > 0,
+    ),
+    bscRpcUrls,
+    ethereumRpcUrls,
+    baseRpcUrls,
+    avalancheRpcUrls,
+    solanaRpcUrls,
+  };
+}