@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.2

package/packages/agent/src/api/wallet.js

@@ -1,22 +1,129 @@
 /**
  * Wallet key generation, address derivation, and balance/NFT fetching.
- * Uses Node crypto primitives (no viem/@solana/web3.js dependency).
+ * Uses Node crypto primitives + ethers (keccak-256 / checksum).
  * Balance data from Alchemy/Ankr (EVM), NodeReal/QuickNode (BSC RPC),
  * and Helius (Solana) REST APIs.
  *
- * DEX price oracle logic lives in ./wallet-dex-prices.ts
+ * DEX price oracle logic lives in ./wallet-dex-prices.ts.
  * EVM balance + NFT fetching lives in ./wallet-evm-balance.ts
  */
 import crypto from "node:crypto";
+import fs from "node:fs";
 import { logger } from "@elizaos/core";
 import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { ethers } from "ethers";
+import { resolveStewardCredentialsPath } from "../config/paths.js";
+import { computeValueUsd } from "./wallet-dex-prices.js";
 // ── Re-exports from extracted modules ─────────────────────────────────
-export { computeValueUsd, DEX_PRICE_TIMEOUT_MS, DEXPAPRIKA_CHAIN_MAP, DEXSCREENER_CHAIN_MAP, fetchDexPaprikaPrices, fetchDexPrices, fetchDexScreenerPrices, WRAPPED_NATIVE, } from "./wallet-dex-prices";
-export { DEFAULT_EVM_CHAINS, fetchEvmBalances, resolveEvmProviderKeys, } from "./wallet-evm-balance";
+export { computeValueUsd, DEX_PRICE_TIMEOUT_MS, DEXPAPRIKA_CHAIN_MAP, DEXSCREENER_CHAIN_MAP, fetchDexPaprikaPrices, fetchDexPrices, fetchDexScreenerPrices, WRAPPED_NATIVE, } from "./wallet-dex-prices.js";
+export { DEFAULT_EVM_CHAINS, fetchEvmBalances, resolveEvmProviderKeys, } from "./wallet-evm-balance.js";
 // ── Constants ─────────────────────────────────────────────────────────
 const FETCH_TIMEOUT_MS = 15_000;
 export const MANAGED_EVM_ADDRESS_ENV_KEY = "ELIZA_MANAGED_EVM_ADDRESS";
 export const MANAGED_SOLANA_ADDRESS_ENV_KEY = "ELIZA_MANAGED_SOLANA_ADDRESS";
+export const CLOUD_EVM_ADDRESS_ENV_KEY = "ELIZA_CLOUD_EVM_ADDRESS";
+export const CLOUD_SOLANA_ADDRESS_ENV_KEY = "ELIZA_CLOUD_SOLANA_ADDRESS";
+export const WALLET_SOURCE_EVM_ENV_KEY = "WALLET_SOURCE_EVM";
+export const WALLET_SOURCE_SOLANA_ENV_KEY = "WALLET_SOURCE_SOLANA";
+const SOLANA_WRAPPED_NATIVE_MINT = "So11111111111111111111111111111111111111112";
+const SOLANA_SPL_TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+/** Module-level cache for steward wallet addresses (avoids process.env mutation). */
+let stewardAddressCache = null;
+function normalizeWalletSource(value) {
+    if (value === "local" || value === "cloud") {
+        return value;
+    }
+    return null;
+}
+function readValidatedEvmAddress(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return null;
+    if (!/^0x[0-9a-fA-F]{40}$/.test(trimmed)) {
+        return null;
+    }
+    return trimmed;
+}
+function readValidatedSolanaAddress(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const decoded = base58Decode(trimmed);
+        return decoded.length === 32 ? trimmed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function deriveLocalEvmAddress() {
+    const evmKey = process.env.EVM_PRIVATE_KEY;
+    if (!evmKey || PLACEHOLDER_RE.test(evmKey))
+        return null;
+    try {
+        return deriveEvmAddress(evmKey);
+    }
+    catch (e) {
+        logger.warn(`Bad EVM key: ${e}`);
+        return null;
+    }
+}
+function deriveLocalSolanaAddress() {
+    const solKey = process.env.SOLANA_PRIVATE_KEY;
+    if (!solKey || PLACEHOLDER_RE.test(solKey))
+        return null;
+    try {
+        return deriveSolanaAddress(solKey);
+    }
+    catch (e) {
+        logger.warn(`Bad SOL key: ${e}`);
+        return null;
+    }
+}
+function readStewardEvmAddress() {
+    const stewardEvm = stewardAddressCache?.evm?.trim() ??
+        process.env[STEWARD_EVM_ADDRESS_ENV_KEY]?.trim();
+    return readValidatedEvmAddress(stewardEvm);
+}
+function readStewardSolanaAddress() {
+    const stewardSolana = stewardAddressCache?.solana?.trim() ??
+        process.env[STEWARD_SOLANA_ADDRESS_ENV_KEY]?.trim();
+    return readValidatedSolanaAddress(stewardSolana);
+}
+function readManagedEvmAddress() {
+    const managed = readValidatedEvmAddress(process.env[MANAGED_EVM_ADDRESS_ENV_KEY]);
+    if (!managed && process.env[MANAGED_EVM_ADDRESS_ENV_KEY]?.trim()) {
+        logger.warn("Bad managed EVM address in env");
+    }
+    return managed;
+}
+function readManagedSolanaAddress() {
+    const managed = readValidatedSolanaAddress(process.env[MANAGED_SOLANA_ADDRESS_ENV_KEY]);
+    if (!managed && process.env[MANAGED_SOLANA_ADDRESS_ENV_KEY]?.trim()) {
+        logger.warn("Bad managed Solana address in env");
+    }
+    return managed;
+}
+function resolveEvmAddressForConfiguredSource(source) {
+    if (source === "local") {
+        return deriveLocalEvmAddress();
+    }
+    if (source === "cloud") {
+        return (readValidatedEvmAddress(process.env[CLOUD_EVM_ADDRESS_ENV_KEY]) ??
+            readManagedEvmAddress());
+    }
+    return null;
+}
+function resolveSolanaAddressForConfiguredSource(source) {
+    if (source === "local") {
+        return deriveLocalSolanaAddress();
+    }
+    if (source === "cloud") {
+        return (readValidatedSolanaAddress(process.env[CLOUD_SOLANA_ADDRESS_ENV_KEY]) ??
+            readManagedSolanaAddress());
+    }
+    return null;
+}
 // ── EVM key derivation (secp256k1 via @noble/curves + keccak-256) ─────
 function generateEvmPrivateKey() {
     return `0x${crypto.randomBytes(32).toString("hex")}`;
@@ -30,106 +137,9 @@ export function deriveEvmAddress(privateKeyHex) {
     const pubKey = secp256k1.getPublicKey(Buffer.from(cleaned, "hex"), false); // uncompressed (65 bytes)
     const pubNoPrefix = pubKey.subarray(1); // drop the 04 prefix
     // Ethereum address = last 20 bytes of keccak-256(pubkey).
-    const hash = keccak256(pubNoPrefix);
-    return toChecksumAddress(`0x${hash.subarray(12).toString("hex")}`);
-}
-// ── Keccak-256 (minimal sponge implementation) ───────────────────────
-const RC = [
-    0x0000000000000001n,
-    0x0000000000008082n,
-    0x800000000000808an,
-    0x8000000080008000n,
-    0x000000000000808bn,
-    0x0000000080000001n,
-    0x8000000080008081n,
-    0x8000000000008009n,
-    0x000000000000008an,
-    0x0000000000000088n,
-    0x0000000080008009n,
-    0x000000008000000an,
-    0x000000008000808bn,
-    0x800000000000008bn,
-    0x8000000000008089n,
-    0x8000000000008003n,
-    0x8000000000008002n,
-    0x8000000000000080n,
-    0x000000000000800an,
-    0x800000008000000an,
-    0x8000000080008081n,
-    0x8000000000008080n,
-    0x0000000080000001n,
-    0x8000000080008008n,
-];
-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; // 1088 bits
-    const state = Array.from({ length: 5 }, () => Array.from({ length: 5 }, () => 0n));
-    // Keccak padding (0x01, NOT SHA-3's 0x06)
-    const q = rate - (data.length % rate);
-    const padded = Buffer.alloc(data.length + q);
-    padded.set(data);
-    padded[data.length] = 0x01;
-    padded[padded.length - 1] |= 0x80;
-    // Absorb
-    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);
-    }
-    // Squeeze (32 bytes)
-    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)) & 0xffn);
-    }
-    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++) {
-        // theta
-        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;
-        }
-        // rho + pi
-        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]);
-        // chi
-        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;
-        // iota
-        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;
+    const hash = ethers.keccak256(pubNoPrefix);
+    const raw = hash.slice(26); // drop '0x' + first 24 hex chars (12 bytes)
+    return ethers.getAddress(`0x${raw}`);
 }
 // ── Solana key derivation (Ed25519 via Node crypto) ───────────────────
 function generateSolanaKeypair() {
@@ -205,7 +215,7 @@ function base58Decode(str) {
     return zeros > 0 ? Buffer.concat([Buffer.alloc(zeros), bytes]) : bytes;
 }
 /** Sentinel values that appear as env placeholders – skip without error. */
-const PLACEHOLDER_RE = /^\[?\s*(REDACTED|PLACEHOLDER|TODO|CHANGEME|EMPTY)\s*]?$/i;
+const PLACEHOLDER_RE = /^\[?\s*(REDACTED|PLACEHOLDER|T(?:O)D(?:O)|CHANGEME|EMPTY)\s*]?$/i;
 function decodeSolanaPrivateKey(key) {
     if (PLACEHOLDER_RE.test(key)) {
         throw new Error("placeholder value");
@@ -258,7 +268,7 @@ export function validateEvmPrivateKey(key) {
             valid: false,
             chain: "evm",
             address: null,
-            error: `Derivation failed: ${err instanceof Error ? err.message : err}`,
+            error: `Derivation failed: ${String(err)}`,
         };
     }
 }
@@ -285,7 +295,7 @@ export function validateSolanaPrivateKey(key) {
             valid: false,
             chain: "solana",
             address: null,
-            error: `Invalid key: ${err instanceof Error ? err.message : err}`,
+            error: `Invalid key: ${String(err)}`,
         };
     }
 }
@@ -326,6 +336,16 @@ export function generateWalletForChain(chain) {
         privateKey: sol.privateKey,
     };
 }
+// Extracted to wallet-env-sync.ts to break circular dependency with config/config.ts.
+// Local import for internal use (setSolanaWalletEnv below), plus re-export for
+// backward compatibility so existing consumers of wallet.js keep working.
+import { syncSolanaPublicKeyEnv } from "./wallet-env-sync.js";
+export { syncSolanaPublicKeyEnv } from "./wallet-env-sync.js";
+export function setSolanaWalletEnv(privateKey) {
+    const trimmed = privateKey.trim();
+    process.env.SOLANA_PRIVATE_KEY = trimmed;
+    return syncSolanaPublicKeyEnv(trimmed);
+}
 /** Validate key, store in process.env. Caller persists to config if needed. */
 export function importWallet(chain, privateKey) {
     const trimmed = privateKey.trim();
@@ -342,63 +362,266 @@ export function importWallet(chain, privateKey) {
     const v = validateSolanaPrivateKey(trimmed);
     if (!v.valid)
         return { success: false, chain, address: null, error: v.error };
-    process.env.SOLANA_PRIVATE_KEY = trimmed;
+    setSolanaWalletEnv(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. */
-export function getWalletAddresses() {
-    let evmAddress = null;
-    let solanaAddress = null;
-    const evmKey = process.env.EVM_PRIVATE_KEY;
-    if (evmKey && !PLACEHOLDER_RE.test(evmKey)) {
-        try {
-            evmAddress = deriveEvmAddress(evmKey);
-        }
-        catch (e) {
-            logger.warn(`Bad EVM key: ${e}`);
+// ── Steward wallet cache env keys ─────────────────────────────────────
+export const STEWARD_EVM_ADDRESS_ENV_KEY = "STEWARD_EVM_ADDRESS";
+export const STEWARD_SOLANA_ADDRESS_ENV_KEY = "STEWARD_SOLANA_ADDRESS";
+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),
+        };
     }
-    const solKey = process.env.SOLANA_PRIVATE_KEY;
-    if (solKey && !PLACEHOLDER_RE.test(solKey)) {
-        try {
-            solanaAddress = deriveSolanaAddress(solKey);
+    catch {
+        return null;
+    }
+}
+/**
+ * Initialise the steward wallet address cache.
+ *
+ * Call once during server startup.  Fetches addresses from the steward API
+ * and writes them to `process.env.STEWARD_EVM_ADDRESS` /
+ * `process.env.STEWARD_SOLANA_ADDRESS` so the synchronous
+ * `getWalletAddresses()` can use them without hitting the network.
+ */
+export 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}`;
         }
-        catch (e) {
-            logger.warn(`Bad SOL key: ${e}`);
+        else if (apiKey) {
+            headers["X-Steward-Key"] = apiKey;
         }
-    }
-    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;
+        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 body = (await res.json());
+        const agent = body.data ?? body;
+        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;
             }
-            else {
-                logger.warn("Bad managed EVM address in env");
+            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}`);
+        }
     }
-    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 (err) {
+        logger.debug(`[wallet] Steward wallet cache init unavailable: ${err}`);
+    }
+}
+/**
+ * Derive addresses from env keys.  Works without a running runtime.
+ *
+ * Resolution order (steward-first):
+ *   1. Steward cached addresses  (`STEWARD_EVM_ADDRESS` / `STEWARD_SOLANA_ADDRESS`)
+ *   2. Local private key derivation  (`EVM_PRIVATE_KEY` / `SOLANA_PRIVATE_KEY`)
+ *   3. Managed address env vars  (`ELIZA_MANAGED_EVM_ADDRESS` / `ELIZA_MANAGED_SOLANA_ADDRESS`)
+ */
+export function getWalletAddresses() {
+    const configuredEvmSource = normalizeWalletSource(process.env[WALLET_SOURCE_EVM_ENV_KEY]);
+    const configuredSolanaSource = normalizeWalletSource(process.env[WALLET_SOURCE_SOLANA_ENV_KEY]);
+    let evmAddress = resolveEvmAddressForConfiguredSource(configuredEvmSource);
+    let solanaAddress = resolveSolanaAddressForConfiguredSource(configuredSolanaSource);
+    // Legacy fallback order when no explicit source selection exists yet.
+    if (!evmAddress && !configuredEvmSource) {
+        evmAddress =
+            readStewardEvmAddress() ??
+                deriveLocalEvmAddress() ??
+                readManagedEvmAddress();
+    }
+    if (!solanaAddress && !configuredSolanaSource) {
+        solanaAddress =
+            readStewardSolanaAddress() ??
+                deriveLocalSolanaAddress() ??
+                readManagedSolanaAddress();
+    }
+    return { evmAddress, solanaAddress };
+}
+/**
+ * Extended wallet addresses including steward-managed wallets.
+ * Calls steward API (async) to discover additional addresses.
+ * Key-derived addresses are always preferred; steward addresses fill gaps.
+ */
+export async function getWalletAddressesWithSteward() {
+    const base = getWalletAddresses();
+    // Only augment when steward is configured
+    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 body = (await res.json());
+        const agent = body.data ?? body;
+        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 shortenMint(mint) {
+    if (mint.length <= 10)
+        return mint;
+    return `${mint.slice(0, 4)}...${mint.slice(-4)}`;
+}
+async function fetchSolanaDexMeta(addresses) {
+    const uniqueAddresses = [
+        ...new Set(addresses.map((address) => address.trim())),
+    ].filter(Boolean);
+    const results = new Map();
+    if (uniqueAddresses.length === 0)
+        return results;
+    for (let index = 0; index < uniqueAddresses.length; index += 30) {
+        const batch = uniqueAddresses.slice(index, index + 30);
+        try {
+            const res = await fetch(`https://api.dexscreener.com/tokens/v1/solana/${batch.join(",")}`, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+            if (!res.ok)
+                continue;
+            const pairs = (await res.json());
+            if (!Array.isArray(pairs))
+                continue;
+            const bestPairByMint = new Map();
+            for (const pair of pairs) {
+                const mint = pair.baseToken?.address?.trim();
+                if (!mint)
+                    continue;
+                const existing = bestPairByMint.get(mint);
+                if (!existing ||
+                    (pair.liquidity?.usd ?? 0) > (existing.liquidity?.usd ?? 0)) {
+                    bestPairByMint.set(mint, pair);
                 }
             }
-            catch {
-                logger.warn("Bad managed Solana address in env");
+            for (const [mint, pair] of bestPairByMint) {
+                results.set(mint, {
+                    priceUsd: pair.priceUsd ?? null,
+                    imageUrl: pair.info?.imageUrl?.trim() || undefined,
+                    name: pair.baseToken?.name?.trim() || undefined,
+                    symbol: pair.baseToken?.symbol?.trim() || undefined,
+                });
             }
         }
+        catch (err) {
+            logger.warn(`[wallet] Solana DexScreener fetch failed: ${String(err)}`);
+        }
     }
-    return { evmAddress, solanaAddress };
+    return results;
+}
+function buildSolanaTokenBalance(token, dexMeta) {
+    const meta = dexMeta.get(token.mint);
+    const computedValueUsd = meta?.priceUsd && meta.priceUsd.length > 0
+        ? computeValueUsd(token.balance, meta.priceUsd)
+        : "0";
+    return {
+        mint: token.mint,
+        symbol: token.symbol?.trim() ||
+            meta?.symbol?.trim() ||
+            shortenMint(token.mint).toUpperCase(),
+        name: token.name?.trim() || meta?.name?.trim() || token.mint,
+        balance: token.balance,
+        decimals: token.decimals,
+        valueUsd: token.valueUsd && Number.parseFloat(token.valueUsd) > 0
+            ? token.valueUsd
+            : computedValueUsd,
+        logoUrl: token.logoUrl?.trim() || meta?.imageUrl || "",
+    };
 }
 function rpcJsonRequest(body) {
     return {
@@ -437,75 +660,119 @@ export async function fetchSolanaBalances(address, heliusKey) {
         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 balanceData = await jsonOrThrow(await fetch(url, rpc(JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "getBalance",
+        params: [address],
+    }))));
+    if (balanceData.error?.message)
+        throw new Error(balanceData.error.message);
+    solBalance = ((balanceData.result?.value ?? 0) / 1e9).toFixed(9);
+    const tokenData = 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 (tokenData.error?.message)
+        throw new Error(tokenData.error.message);
+    const fungibleAssets = (tokenData.result?.items ?? []).filter((item) => item.interface === "FungibleToken" || item.interface === "FungibleAsset");
+    const dexMeta = await fetchSolanaDexMeta([
+        SOLANA_WRAPPED_NATIVE_MINT,
+        ...fungibleAssets.map((item) => item.id),
+    ]);
     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}`);
+    for (const item of tokenData.result?.items ?? []) {
+        if (item.interface !== "FungibleToken" &&
+            item.interface !== "FungibleAsset")
+            continue;
+        const decimals = item.token_info?.decimals ?? 0;
+        const rawBalance = item.token_info?.balance ?? 0;
+        const balance = decimals > 0
+            ? (rawBalance / 10 ** decimals).toString()
+            : rawBalance.toString();
+        tokens.push(buildSolanaTokenBalance({
+            mint: item.id,
+            symbol: item.token_info?.symbol ?? item.content?.metadata?.symbol,
+            name: item.content?.metadata?.name ?? null,
+            balance,
+            decimals,
+            valueUsd: item.token_info?.price_info?.total_price?.toFixed(2) ?? null,
+            logoUrl: item.content?.links?.image ?? null,
+        }, dexMeta));
     }
-    return { solBalance, solValueUsd: "0", tokens };
+    const solPriceUsd = dexMeta.get(SOLANA_WRAPPED_NATIVE_MINT)?.priceUsd ?? "0";
+    return {
+        solBalance,
+        solValueUsd: computeValueUsd(solBalance, solPriceUsd),
+        tokens,
+    };
 }
 export 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({
+            const balanceData = 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: [] };
+            if (balanceData.error?.message)
+                throw new Error(balanceData.error.message);
+            const tokenAccounts = await jsonOrThrow(await fetch(rpcUrl, rpcJsonRequest(JSON.stringify({
+                jsonrpc: "2.0",
+                id: 2,
+                method: "getTokenAccountsByOwner",
+                params: [
+                    address,
+                    { programId: SOLANA_SPL_TOKEN_PROGRAM_ID },
+                    { encoding: "jsonParsed" },
+                ],
+            }))));
+            if (tokenAccounts.error?.message) {
+                throw new Error(tokenAccounts.error.message);
+            }
+            const rawTokens = (tokenAccounts.result?.value ?? [])
+                .map((item) => {
+                const info = item.account?.data?.parsed?.info;
+                const mint = info?.mint?.trim();
+                const tokenAmount = info?.tokenAmount;
+                const balance = tokenAmount?.uiAmountString?.trim() ||
+                    tokenAmount?.amount?.trim() ||
+                    "0";
+                const decimals = tokenAmount?.decimals ?? 0;
+                if (!mint || Number.parseFloat(balance) <= 0)
+                    return null;
+                return {
+                    mint,
+                    balance,
+                    decimals,
+                };
+            })
+                .filter((token) => token !== null);
+            const dexMeta = await fetchSolanaDexMeta([
+                SOLANA_WRAPPED_NATIVE_MINT,
+                ...rawTokens.map((token) => token.mint),
+            ]);
+            const tokens = rawTokens.map((token) => buildSolanaTokenBalance(token, dexMeta));
+            const solBalance = ((balanceData.result?.value ?? 0) / 1e9).toFixed(9);
+            const solPriceUsd = dexMeta.get(SOLANA_WRAPPED_NATIVE_MINT)?.priceUsd ?? "0";
+            return {
+                solBalance,
+                solValueUsd: computeValueUsd(solBalance, solPriceUsd),
+                tokens,
+            };
         }
         catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
+            const msg = String(err);
             errors.push(`${describeRpcEndpoint(rpcUrl)}: ${msg}`);
         }
     }