@pioneer-platform/pioneer-cache 1.1.24 → 1.5.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @pioneer-platform/pioneer-cache
 
+## 1.5.0
+
+### Minor Changes
+
+- chore: chore: chore: feat(pioneer): implement end-to-end Solana transaction signing
+
+## 1.4.0
+
+### Minor Changes
+
+- chore: chore: feat(pioneer): implement end-to-end Solana transaction signing
+
+## 1.3.0
+
+### Minor Changes
+
+- chore: feat(pioneer): implement end-to-end Solana transaction signing
+
+## 1.2.0
+
+### Minor Changes
+
+- feat(pioneer): implement end-to-end Solana transaction signing
+
 ## 1.1.24
 
 ### Patch Changes

package/dist/stores/balance-cache.js

@@ -97,7 +97,12 @@ class BalanceCache extends base_cache_1.BaseCache {
     async fetchFromSource(params) {
         const tag = this.TAG + 'fetchFromSource | ';
         try {
-            const { caip, pubkey } = params;
+            // PHASE 2: Normalize CAIP to lowercase at entry point for consistency
+            const normalizedParams = {
+                caip: params.caip.toLowerCase(),
+                pubkey: params.pubkey
+            };
+            const { caip, pubkey } = normalizedParams;
             // Log sanitized pubkey for debugging
             log.debug(tag, `Fetching balance for ${caip}/${sanitizePubkey(pubkey)}`);
             // Fetch balance using balance module (still uses real pubkey)

package/dist/stores/portfolio-cache.d.ts

@@ -55,11 +55,17 @@ export declare class PortfolioCache extends BaseCache<PortfolioData> {
      * Not cryptographic - just needs to be stable and collision-resistant
      */
     private simpleHash;
+    /**
+     * Fetch stable coin balances for EVM addresses
+     * INTEGRATED: Part of portfolio background refresh, no direct blockchain queries from endpoints
+     */
+    private fetchStableCoins;
     /**
      * Fetch portfolio from blockchain APIs
      *
      * This is the SLOW operation that happens in the background
      * It fetches balances for all pubkeys and enriches with pricing
+     * INTEGRATED: Now includes stable coin balances automatically
      */
     protected fetchFromSource(params: Record<string, any>): Promise<PortfolioData>;
     /**

package/dist/stores/portfolio-cache.js

@@ -85,11 +85,120 @@ class PortfolioCache extends base_cache_1.BaseCache {
         }
         return Math.abs(hash).toString(36);
     }
+    /**
+     * Fetch stable coin balances for EVM addresses
+     * INTEGRATED: Part of portfolio background refresh, no direct blockchain queries from endpoints
+     */
+    async fetchStableCoins(primaryAddress, pubkeys) {
+        const tag = this.TAG + 'fetchStableCoins | ';
+        const stableCharts = [];
+        try {
+            // Stable coins configuration (same as GetStableCoins endpoint)
+            const STABLE_COINS = {
+                'eip155:1': [
+                    { symbol: 'USDC', name: 'USD Coin', address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', decimals: 6, coingeckoId: 'usd-coin' },
+                    { symbol: 'USDT', name: 'Tether USD', address: '0xdAC17F958D2ee523a2206206994597C13D831ec7', decimals: 6, coingeckoId: 'tether' },
+                    { symbol: 'LINK', name: 'Chainlink', address: '0x514910771AF9Ca656af840dff83E8264EcF986CA', decimals: 18, coingeckoId: 'chainlink' },
+                ],
+                'eip155:137': [
+                    { symbol: 'USDC', name: 'USD Coin (Polygon)', address: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174', decimals: 6, coingeckoId: 'usd-coin' },
+                    { symbol: 'USDT', name: 'Tether USD (Polygon)', address: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F', decimals: 6, coingeckoId: 'tether' },
+                ],
+                'eip155:8453': [
+                    { symbol: 'USDC', name: 'USD Coin (Base)', address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', decimals: 6, coingeckoId: 'usd-coin' },
+                ],
+                'eip155:56': [
+                    { symbol: 'USDT', name: 'Tether USD (BSC)', address: '0x55d398326f99059fF775485246999027B3197955', decimals: 18, coingeckoId: 'tether' },
+                    { symbol: 'USDC', name: 'USD Coin (BSC)', address: '0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d', decimals: 18, coingeckoId: 'usd-coin' },
+                ],
+            };
+            // Extract EVM networks from pubkeys
+            const evmNetworks = [...new Set(pubkeys
+                    .filter(p => p.caip && p.caip.startsWith('eip155:'))
+                    .map(p => p.caip.split('/')[0]))];
+            if (evmNetworks.length === 0) {
+                log.debug(tag, 'No EVM networks found, skipping stable coin fetch');
+                return stableCharts;
+            }
+            log.info(tag, `Fetching stable coins for ${evmNetworks.length} EVM networks`);
+            // Initialize eth-network module for token balance queries
+            let ethNetwork;
+            try {
+                ethNetwork = require('@pioneer-platform/eth-network');
+                await ethNetwork.init({});
+            }
+            catch (error) {
+                log.error(tag, 'Failed to initialize eth-network:', error);
+                return stableCharts;
+            }
+            // Fetch stable coins for each network
+            for (const networkId of evmNetworks) {
+                const stableCoins = STABLE_COINS[networkId];
+                if (!stableCoins || stableCoins.length === 0) {
+                    continue;
+                }
+                log.debug(tag, `Checking ${stableCoins.length} stable coins on ${networkId}`);
+                // Fetch all token balances for this network in parallel
+                const tokenPromises = stableCoins.map(async (tokenConfig) => {
+                    try {
+                        const balance = await ethNetwork.getBalanceTokenByNetwork(networkId, primaryAddress, tokenConfig.address);
+                        const balanceNum = parseFloat(balance);
+                        // Skip zero balances
+                        if (isNaN(balanceNum) || balanceNum === 0) {
+                            return null;
+                        }
+                        // Get price from markets module
+                        let priceUsd = 0;
+                        try {
+                            const tokenCaip = `${networkId}/erc20:${tokenConfig.address.toLowerCase()}`;
+                            priceUsd = await this.marketsModule.getAssetPriceByCaip(tokenCaip);
+                            if (isNaN(priceUsd) || priceUsd < 0) {
+                                priceUsd = 0;
+                            }
+                        }
+                        catch (priceError) {
+                            log.warn(tag, `Error fetching price for ${tokenConfig.symbol}:`, priceError);
+                        }
+                        const valueUsd = balanceNum * priceUsd;
+                        const chartData = {
+                            caip: `${networkId}/erc20:${tokenConfig.address.toLowerCase()}`,
+                            pubkey: primaryAddress,
+                            networkId,
+                            symbol: tokenConfig.symbol,
+                            name: tokenConfig.name,
+                            balance: balance,
+                            priceUsd,
+                            valueUsd,
+                            icon: '',
+                            type: 'token',
+                            decimal: tokenConfig.decimals
+                        };
+                        log.info(tag, `✅ ${tokenConfig.symbol}: ${balance} ($${valueUsd.toFixed(2)})`);
+                        return chartData;
+                    }
+                    catch (error) {
+                        log.error(tag, `Error fetching ${tokenConfig.symbol}:`, error);
+                        return null;
+                    }
+                });
+                const results = await Promise.all(tokenPromises);
+                const validTokens = results.filter((t) => t !== null);
+                stableCharts.push(...validTokens);
+            }
+            log.info(tag, `Fetched ${stableCharts.length} stable coin balances`);
+            return stableCharts;
+        }
+        catch (error) {
+            log.error(tag, 'Error fetching stable coins:', error);
+            return stableCharts;
+        }
+    }
     /**
      * Fetch portfolio from blockchain APIs
      *
      * This is the SLOW operation that happens in the background
      * It fetches balances for all pubkeys and enriches with pricing
+     * INTEGRATED: Now includes stable coin balances automatically
      */
     async fetchFromSource(params) {
         const tag = this.TAG + 'fetchFromSource | ';
@@ -165,14 +274,32 @@ class PortfolioCache extends base_cache_1.BaseCache {
                 }
             });
             const results = await Promise.all(balancePromises);
-            // Filter out nulls and calculate total
+            // Filter out nulls
             const validCharts = results.filter((c) => c !== null);
-            const totalValueUsd = validCharts.reduce((sum, c) => sum + c.valueUsd, 0);
+            charts.push(...validCharts);
+            // INTEGRATED: Fetch stable coins for EVM addresses (background operation)
+            // This ensures stable coins are ALWAYS in the cache and available instantly
+            const evmPubkey = pubkeys.find((p) => p.caip && p.caip.startsWith('eip155:'));
+            if (evmPubkey) {
+                const primaryAddress = evmPubkey.pubkey;
+                log.info(tag, `Fetching stable coins for EVM address: ${primaryAddress.substring(0, 10)}...`);
+                const stableCoins = await this.fetchStableCoins(primaryAddress, pubkeys);
+                // Add stable coins to charts (deduplicate by CAIP+pubkey)
+                for (const stableCoin of stableCoins) {
+                    const isDuplicate = charts.some(c => c.caip === stableCoin.caip && c.pubkey === stableCoin.pubkey);
+                    if (!isDuplicate) {
+                        charts.push(stableCoin);
+                    }
+                }
+                log.info(tag, `Added ${stableCoins.length} stable coins to portfolio`);
+            }
+            // Calculate total value
+            const totalValueUsd = charts.reduce((sum, c) => sum + c.valueUsd, 0);
             const fetchTime = Date.now() - startTime;
-            log.info(tag, `✅ Fetched portfolio: ${validCharts.length} assets, $${totalValueUsd.toFixed(2)} in ${fetchTime}ms`);
+            log.info(tag, `✅ Fetched portfolio: ${charts.length} assets (including stable coins), $${totalValueUsd.toFixed(2)} in ${fetchTime}ms`);
             return {
                 pubkeys,
-                charts: validCharts,
+                charts,
                 totalValueUsd,
                 timestamp: Date.now()
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/pioneer-cache",
-  "version": "1.1.24",
+  "version": "1.5.0",
   "description": "Unified caching system for Pioneer platform with Redis backend",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/stores/balance-cache.ts

@@ -129,7 +129,12 @@ export class BalanceCache extends BaseCache<BalanceData> {
         const tag = this.TAG + 'fetchFromSource | ';
 
         try {
-            const { caip, pubkey } = params;
+            // PHASE 2: Normalize CAIP to lowercase at entry point for consistency
+            const normalizedParams = {
+                caip: params.caip.toLowerCase(),
+                pubkey: params.pubkey
+            };
+            const { caip, pubkey } = normalizedParams;
 
             // Log sanitized pubkey for debugging
             log.debug(tag, `Fetching balance for ${caip}/${sanitizePubkey(pubkey)}`);

package/src/stores/portfolio-cache.ts

@@ -124,11 +124,150 @@ export class PortfolioCache extends BaseCache<PortfolioData> {
         return Math.abs(hash).toString(36);
     }
 
+    /**
+     * Fetch stable coin balances for EVM addresses
+     * INTEGRATED: Part of portfolio background refresh, no direct blockchain queries from endpoints
+     */
+    private async fetchStableCoins(
+        primaryAddress: string,
+        pubkeys: Array<{ pubkey: string; caip: string }>
+    ): Promise<ChartData[]> {
+        const tag = this.TAG + 'fetchStableCoins | ';
+        const stableCharts: ChartData[] = [];
+
+        try {
+            // Stable coins configuration (same as GetStableCoins endpoint)
+            const STABLE_COINS: Record<string, Array<{
+                symbol: string;
+                name: string;
+                address: string;
+                decimals: number;
+                coingeckoId: string;
+            }>> = {
+                'eip155:1': [
+                    { symbol: 'USDC', name: 'USD Coin', address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', decimals: 6, coingeckoId: 'usd-coin' },
+                    { symbol: 'USDT', name: 'Tether USD', address: '0xdAC17F958D2ee523a2206206994597C13D831ec7', decimals: 6, coingeckoId: 'tether' },
+                    { symbol: 'LINK', name: 'Chainlink', address: '0x514910771AF9Ca656af840dff83E8264EcF986CA', decimals: 18, coingeckoId: 'chainlink' },
+                ],
+                'eip155:137': [
+                    { symbol: 'USDC', name: 'USD Coin (Polygon)', address: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174', decimals: 6, coingeckoId: 'usd-coin' },
+                    { symbol: 'USDT', name: 'Tether USD (Polygon)', address: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F', decimals: 6, coingeckoId: 'tether' },
+                ],
+                'eip155:8453': [
+                    { symbol: 'USDC', name: 'USD Coin (Base)', address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', decimals: 6, coingeckoId: 'usd-coin' },
+                ],
+                'eip155:56': [
+                    { symbol: 'USDT', name: 'Tether USD (BSC)', address: '0x55d398326f99059fF775485246999027B3197955', decimals: 18, coingeckoId: 'tether' },
+                    { symbol: 'USDC', name: 'USD Coin (BSC)', address: '0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d', decimals: 18, coingeckoId: 'usd-coin' },
+                ],
+            };
+
+            // Extract EVM networks from pubkeys
+            const evmNetworks = [...new Set(
+                pubkeys
+                    .filter(p => p.caip && p.caip.startsWith('eip155:'))
+                    .map(p => p.caip.split('/')[0])
+            )];
+
+            if (evmNetworks.length === 0) {
+                log.debug(tag, 'No EVM networks found, skipping stable coin fetch');
+                return stableCharts;
+            }
+
+            log.info(tag, `Fetching stable coins for ${evmNetworks.length} EVM networks`);
+
+            // Initialize eth-network module for token balance queries
+            let ethNetwork: any;
+            try {
+                ethNetwork = require('@pioneer-platform/eth-network');
+                await ethNetwork.init({});
+            } catch (error) {
+                log.error(tag, 'Failed to initialize eth-network:', error);
+                return stableCharts;
+            }
+
+            // Fetch stable coins for each network
+            for (const networkId of evmNetworks) {
+                const stableCoins = STABLE_COINS[networkId];
+                if (!stableCoins || stableCoins.length === 0) {
+                    continue;
+                }
+
+                log.debug(tag, `Checking ${stableCoins.length} stable coins on ${networkId}`);
+
+                // Fetch all token balances for this network in parallel
+                const tokenPromises = stableCoins.map(async (tokenConfig) => {
+                    try {
+                        const balance = await ethNetwork.getBalanceTokenByNetwork(
+                            networkId,
+                            primaryAddress,
+                            tokenConfig.address
+                        );
+
+                        const balanceNum = parseFloat(balance);
+
+                        // Skip zero balances
+                        if (isNaN(balanceNum) || balanceNum === 0) {
+                            return null;
+                        }
+
+                        // Get price from markets module
+                        let priceUsd = 0;
+                        try {
+                            const tokenCaip = `${networkId}/erc20:${tokenConfig.address.toLowerCase()}`;
+                            priceUsd = await this.marketsModule.getAssetPriceByCaip(tokenCaip);
+                            if (isNaN(priceUsd) || priceUsd < 0) {
+                                priceUsd = 0;
+                            }
+                        } catch (priceError) {
+                            log.warn(tag, `Error fetching price for ${tokenConfig.symbol}:`, priceError);
+                        }
+
+                        const valueUsd = balanceNum * priceUsd;
+
+                        const chartData: ChartData = {
+                            caip: `${networkId}/erc20:${tokenConfig.address.toLowerCase()}`,
+                            pubkey: primaryAddress,
+                            networkId,
+                            symbol: tokenConfig.symbol,
+                            name: tokenConfig.name,
+                            balance: balance,
+                            priceUsd,
+                            valueUsd,
+                            icon: '',
+                            type: 'token',
+                            decimal: tokenConfig.decimals
+                        };
+
+                        log.info(tag, `✅ ${tokenConfig.symbol}: ${balance} ($${valueUsd.toFixed(2)})`);
+                        return chartData;
+
+                    } catch (error) {
+                        log.error(tag, `Error fetching ${tokenConfig.symbol}:`, error);
+                        return null;
+                    }
+                });
+
+                const results = await Promise.all(tokenPromises);
+                const validTokens = results.filter((t): t is ChartData => t !== null);
+                stableCharts.push(...validTokens);
+            }
+
+            log.info(tag, `Fetched ${stableCharts.length} stable coin balances`);
+            return stableCharts;
+
+        } catch (error) {
+            log.error(tag, 'Error fetching stable coins:', error);
+            return stableCharts;
+        }
+    }
+
     /**
      * Fetch portfolio from blockchain APIs
-     * 
+     *
      * This is the SLOW operation that happens in the background
      * It fetches balances for all pubkeys and enriches with pricing
+     * INTEGRATED: Now includes stable coin balances automatically
      */
     protected async fetchFromSource(params: Record<string, any>): Promise<PortfolioData> {
         const tag = this.TAG + 'fetchFromSource | ';
@@ -216,17 +355,42 @@ export class PortfolioCache extends BaseCache<PortfolioData> {
             });
 
             const results = await Promise.all(balancePromises);
-            
-            // Filter out nulls and calculate total
+
+            // Filter out nulls
             const validCharts = results.filter((c): c is ChartData => c !== null);
-            const totalValueUsd = validCharts.reduce((sum, c) => sum + c.valueUsd, 0);
+            charts.push(...validCharts);
+
+            // INTEGRATED: Fetch stable coins for EVM addresses (background operation)
+            // This ensures stable coins are ALWAYS in the cache and available instantly
+            const evmPubkey = pubkeys.find(
+                (p: any) => p.caip && p.caip.startsWith('eip155:')
+            );
+            if (evmPubkey) {
+                const primaryAddress = evmPubkey.pubkey;
+                log.info(tag, `Fetching stable coins for EVM address: ${primaryAddress.substring(0, 10)}...`);
+                const stableCoins = await this.fetchStableCoins(primaryAddress, pubkeys);
+
+                // Add stable coins to charts (deduplicate by CAIP+pubkey)
+                for (const stableCoin of stableCoins) {
+                    const isDuplicate = charts.some(c =>
+                        c.caip === stableCoin.caip && c.pubkey === stableCoin.pubkey
+                    );
+                    if (!isDuplicate) {
+                        charts.push(stableCoin);
+                    }
+                }
+                log.info(tag, `Added ${stableCoins.length} stable coins to portfolio`);
+            }
+
+            // Calculate total value
+            const totalValueUsd = charts.reduce((sum, c) => sum + c.valueUsd, 0);
 
             const fetchTime = Date.now() - startTime;
-            log.info(tag, `✅ Fetched portfolio: ${validCharts.length} assets, $${totalValueUsd.toFixed(2)} in ${fetchTime}ms`);
+            log.info(tag, `✅ Fetched portfolio: ${charts.length} assets (including stable coins), $${totalValueUsd.toFixed(2)} in ${fetchTime}ms`);
 
             return {
                 pubkeys,
-                charts: validCharts,
+                charts,
                 totalValueUsd,
                 timestamp: Date.now()
             };

package/src/stores/balance-cache.ts.bak

@@ -1,345 +0,0 @@
-/*
-    BalanceCache - Balance-specific cache implementation
-
-    Extends BaseCache with balance-specific logic.
-    All common logic is inherited from BaseCache.
-*/
-
-import { BaseCache } from '../core/base-cache';
-import type { CacheConfig } from '../types';
-import crypto from 'crypto';
-
-const log = require('@pioneer-platform/loggerdog')();
-
-/**
- * Hash pubkey/xpub for privacy-protecting cache keys
- * Uses SHA-256 for fast, deterministic, one-way hashing
- */
-function hashPubkey(pubkey: string, salt: string = ''): string {
-    // Detect if this is an xpub (don't lowercase) or regular address (lowercase)
-    const isXpub = pubkey.match(/^[xyz]pub[1-9A-HJ-NP-Za-km-z]{100,}/);
-    const normalized = isXpub ? pubkey.trim() : pubkey.trim().toLowerCase();
-
-    const hash = crypto.createHash('sha256');
-    hash.update(normalized);
-    if (salt) hash.update(salt);
-
-    // Return first 128 bits (32 hex chars) for shorter Redis keys
-    return hash.digest('hex').substring(0, 32);
-}
-
-/**
- * Sanitize pubkey for safe logging
- */
-function sanitizePubkey(pubkey: string): string {
-    if (!pubkey || pubkey.length < 12) return '[invalid]';
-
-    // Check if xpub (show first 8, last 8)
-    if (pubkey.match(/^[xyz]pub/)) {
-        return `${pubkey.substring(0, 8)}...${pubkey.substring(pubkey.length - 8)}`;
-    }
-
-    // Regular address (show first 6, last 4)
-    return `${pubkey.substring(0, 6)}...${pubkey.substring(pubkey.length - 4)}`;
-}
-
-/**
- * Balance data structure
- */
-export interface BalanceData {
-    caip: string;
-    pubkey: string;
-    balance: string;
-    priceUsd?: string;
-    valueUsd?: string;
-    symbol?: string;
-    name?: string;
-    networkId?: string;
-    type?: string;        // ✅ PHASE 1: Asset type (native, token, unknown)
-    isNative?: boolean;   // ✅ PHASE 1: Whether asset is native to chain (backward compat)
-    fetchedAt?: number;   // Unix timestamp when balance was fetched
-    fetchedAtISO?: string; // ISO 8601 timestamp
-    fetchedAt?: number;   // Unix timestamp when balance was fetched from blockchain
-    fetchedAtISO?: string; // ISO 8601 string for display (e.g., "2025-01-11T12:34:56.789Z")
-    dataSource?: string;  // Data source description (e.g., "Bitcoin Blockbook", "Ethereum RPC")
-}
-
-/**
- * BalanceCache - Caches blockchain balance data
- */
-export class BalanceCache extends BaseCache<BalanceData> {
-    private balanceModule: any;
-
-    constructor(redis: any, balanceModule: any, config?: Partial<CacheConfig>) {
-        const defaultConfig: CacheConfig = {
-            name: 'balance',
-            keyPrefix: 'balance_v2:',
-            ttl: 0,                                // Ignored when enableTTL: false
-            staleThreshold: 5 * 60 * 1000,         // 5 minutes - triggers background refresh
-            enableTTL: false,                      // NEVER EXPIRE - data persists forever
-            queueName: 'cache-refresh',
-            enableQueue: true,
-            maxRetries: 3,
-            retryDelay: 10000,
-            blockOnMiss: true,                     // Wait for fresh data on first request - users need real balances!
-            enableLegacyFallback: true,
-            defaultValue: {
-                caip: '',
-                pubkey: '',
-                balance: '0',
-            },
-            maxConcurrentJobs: 10,
-            apiTimeout: 15000,
-            logCacheHits: false,
-            logCacheMisses: true,
-            logRefreshJobs: true
-        };
-
-        super(redis, { ...defaultConfig, ...config });
-        this.balanceModule = balanceModule;
-    }
-
-    /**
-     * Build Redis key for balance data
-     * Format: balance_v2:caip:hashedPubkey
-     *
-     * PRIVACY: Uses SHA-256 hash of pubkey/xpub instead of plaintext
-     * - One-way: cannot recover pubkey from hash
-     * - Deterministic: same pubkey always produces same key
-     * - Fast: ~0.02ms per hash
-     */
-    protected buildKey(params: Record<string, any>): string {
-        const { caip, pubkey } = params;
-        if (!caip || !pubkey) {
-            throw new Error('BalanceCache.buildKey: caip and pubkey required');
-        }
-
-        const normalizedCaip = caip.toLowerCase();
-
-        // Hash pubkey for privacy protection
-        const hashedPubkey = hashPubkey(pubkey, caip);
-
-        return `${this.config.keyPrefix}${normalizedCaip}:${hashedPubkey}`;
-    }
-
-    /**
-     * Fetch balance from blockchain via balance module
-     */
-    protected async fetchFromSource(params: Record<string, any>): Promise<BalanceData> {
-        const tag = this.TAG + 'fetchFromSource | ';
-
-        try {
-            const { caip, pubkey } = params;
-
-            // Log sanitized pubkey for debugging
-            log.debug(tag, `Fetching balance for ${caip}/${sanitizePubkey(pubkey)}`);
-
-            // Fetch balance using balance module (still uses real pubkey)
-            const asset = { caip };
-            const owner = { pubkey };
-            const balanceInfo = await this.balanceModule.getBalance(asset, owner);
-
-            if (!balanceInfo || !balanceInfo.balance) {
-                log.warn(tag, `No balance returned for ${caip}/${sanitizePubkey(pubkey)}`);
-                const now = Date.now();
-                return {
-                    caip,
-                    pubkey,
-                    balance: '0',
-                    fetchedAt: now,
-                    fetchedAtISO: new Date(now).toISOString()
-                };
-            }
-
-            // Get asset metadata
-            const assetData = require('@pioneer-platform/pioneer-discovery').assetData;
-            const { caipToNetworkId } = require('@pioneer-platform/pioneer-caip');
-
-            const assetInfo = assetData[caip.toUpperCase()] || assetData[caip.toLowerCase()] || {};
-            const networkId = caipToNetworkId(caip);
-
-            // Use actual node URL if available, otherwise construct generic description
-            let dataSource = 'Unknown';
-            if (balanceInfo.nodeUrl) {
-                // Actual node URL returned from network module
-                dataSource = balanceInfo.nodeUrl;
-            } else {
-                // Fallback to generic description if nodeUrl not available
-                const chainName = assetInfo.name || 'Unknown Chain';
-                if (caip.startsWith('bip122:')) {
-                    dataSource = `${chainName} (Blockbook API)`;
-                } else if (caip.startsWith('eip155:')) {
-                    const isToken = caip.includes('/erc20:');
-                    dataSource = isToken ? `${chainName} (RPC - ERC20)` : `${chainName} (RPC)`;
-                } else if (caip.startsWith('cosmos:')) {
-                    dataSource = `${chainName} (LCD API)`;
-                } else if (caip.startsWith('ripple:')) {
-                    dataSource = `${chainName} (JSON-RPC)`;
-                } else {
-                    dataSource = `${chainName} (API)`;
-                }
-            }
-
-            // Capture fetch timestamp for freshness tracking
-            const now = Date.now();
-
-            return {
-                caip,
-                pubkey,
-                balance: balanceInfo.balance,
-                symbol: assetInfo.symbol,
-                name: assetInfo.name,
-                networkId,
-                fetchedAt: now,
-                fetchedAtISO: new Date(now).toISOString(),
-                dataSource
-            };
-
-        } catch (error) {
-            log.error(tag, 'Error fetching balance:', error);
-            throw error;
-        }
-    }
-
-    /**
-     * Try to get balance from legacy cache format
-     */
-    protected async getLegacyCached(params: Record<string, any>): Promise<BalanceData | null> {
-        const tag = this.TAG + 'getLegacyCached | ';
-
-        try {
-            const { caip, pubkey } = params;
-            const { caipToNetworkId } = require('@pioneer-platform/pioneer-caip');
-            const networkId = caipToNetworkId(caip);
-
-            // Try legacy format: cache:balance:pubkey:asset
-            const legacyKey = `cache:balance:${pubkey}:${networkId}`;
-            const legacyData = await this.redis.get(legacyKey);
-
-            if (legacyData) {
-                const parsed = JSON.parse(legacyData);
-                if (parsed.balance !== undefined) {
-                    return {
-                        caip,
-                        pubkey,
-                        balance: typeof parsed.balance === 'string' ? parsed.balance : String(parsed.balance)
-                    };
-                }
-            }
-
-            return null;
-
-        } catch (error) {
-            log.error(tag, 'Error getting legacy cached balance:', error);
-            return null;
-        }
-    }
-
-    /**
-     * Get balance for a specific asset and pubkey
-     * Convenience method that wraps base get()
-     */
-    async getBalance(caip: string, pubkey: string, waitForFresh?: boolean): Promise<BalanceData> {
-        const result = await this.get({ caip, pubkey }, waitForFresh);
-        return result.value || this.config.defaultValue;
-    }
-
-    /**
-     * Get balances for multiple assets (batch operation)
-     * OPTIMIZED: Uses Redis MGET for single round-trip instead of N individual GETs
-     */
-    async getBatchBalances(items: Array<{ caip: string; pubkey: string }>, waitForFresh?: boolean): Promise<BalanceData[]> {
-        const tag = this.TAG + 'getBatchBalances | ';
-        const startTime = Date.now();
-
-        try {
-            log.info(tag, `Batch request for ${items.length} balances using Redis MGET`);
-
-            // Build all Redis keys
-            const keys = items.map(item => this.buildKey({ caip: item.caip, pubkey: item.pubkey }));
-
-            // PERF: Use MGET to fetch all keys in ONE Redis round-trip
-            const cachedValues = await this.redis.mget(...keys);
-
-            // Process results
-            const results: BalanceData[] = [];
-            const missedItems: Array<{ caip: string; pubkey: string; index: number }> = [];
-
-            for (let i = 0; i < items.length; i++) {
-                const item = items[i];
-                const cached = cachedValues[i];
-
-                if (cached) {
-                    try {
-                        const parsed = JSON.parse(cached);
-                        if (parsed.value && parsed.value.caip && parsed.value.pubkey) {
-                            results[i] = parsed.value;
-                            continue;
-                        }
-                    } catch (e) {
-                        log.warn(tag, `Failed to parse cached value for ${keys[i]}`);
-                    }
-                }
-
-                // Cache miss - record for fetching
-                missedItems.push({ ...item, index: i });
-                results[i] = this.config.defaultValue; // Placeholder
-            }
-
-            const responseTime = Date.now() - startTime;
-            const hitRate = ((items.length - missedItems.length) / items.length * 100).toFixed(1);
-            log.info(tag, `MGET completed: ${items.length} keys in ${responseTime}ms (${hitRate}% hit rate)`);
-
-            // If we have cache misses and blocking is enabled, fetch them
-            if (missedItems.length > 0) {
-                const shouldBlock = waitForFresh !== undefined ? waitForFresh : this.config.blockOnMiss;
-                
-                if (shouldBlock) {
-                    log.info(tag, `Fetching ${missedItems.length} cache misses...`);
-                    const fetchStart = Date.now();
-                    
-                    // Fetch all misses in parallel
-                    const fetchPromises = missedItems.map(async (item) => {
-                        try {
-                            // Use fetchFresh to ensure Redis is updated and requests are deduplicated
-                            const freshData = await this.fetchFresh({ caip: item.caip, pubkey: item.pubkey });
-                            results[item.index] = freshData;
-                        } catch (error) {
-                            log.error(tag, `Failed to fetch ${item.caip}/${item.pubkey}:`, error);
-                            const now = Date.now();
-                            results[item.index] = {
-                                caip: item.caip,
-                                pubkey: item.pubkey,
-                                balance: '0',
-                                fetchedAt: now,
-                                fetchedAtISO: new Date(now).toISOString()
-                            };
-                        }
-                    });
-                    
-                    await Promise.all(fetchPromises);
-                    log.info(tag, `Fetched ${missedItems.length} misses in ${Date.now() - fetchStart}ms`);
-                } else {
-                    // Non-blocking: trigger background refresh for misses
-                    missedItems.forEach(item => {
-                        this.triggerAsyncRefresh({ caip: item.caip, pubkey: item.pubkey }, 'high');
-                    });
-                }
-            }
-
-            return results;
-
-        } catch (error) {
-            log.error(tag, 'Error in batch balance request:', error);
-            // Return defaults for all items
-            const now = Date.now();
-            return items.map(item => ({
-                caip: item.caip,
-                pubkey: item.pubkey,
-                balance: '0',
-                fetchedAt: now,
-                fetchedAtISO: new Date(now).toISOString()
-            }));
-        }
-    }
-}