@pioneer-platform/pioneer-sdk 8.15.13 → 8.15.15

package/src/index.ts

@@ -21,43 +21,47 @@ import { detectKkApiAvailability } from './utils/kkapi-detection.js';
 import { formatTime } from './utils/format-time.js';
 import { buildDashboardFromBalances } from './utils/build-dashboard.js';
 import { syncMarket } from './utils/sync-market.js';
+import {
+  getPubkeyKey,
+  deduplicatePubkeys,
+  validatePubkey,
+  findPubkeysForNetwork,
+  findPubkeyForNetwork,
+  validatePubkeysForNetwork,
+  filterPubkeysForAsset
+} from './utils/pubkey-management.js';
+import {
+  isCacheDataValid,
+  buildDashboardFromPortfolioData,
+  fetchMarketPrice,
+  extractPriceFromBalances,
+  aggregateBalances,
+  updateBalancesWithPrice
+} from './utils/portfolio-helpers.js';
+import {
+  createInitialSyncState,
+  createCacheSyncState,
+  createFreshSyncState,
+  type SyncState,
+  resolveAssetInfo
+} from './utils/sync-state.js';
+import { getMaxSendableAmount } from './utils/fee-reserves.js';
+import {
+  matchesNetwork,
+  normalizeNetworkId,
+  validatePubkeysNetworks
+} from './utils/network-helpers.js';
+import {
+  buildAssetQuery,
+  logQueryDiagnostics,
+  enrichBalancesWithAssetInfo
+} from './utils/portfolio-helpers.js';
+import { ensurePathsForBlockchains } from './utils/path-discovery.js';
+import { syncPubkeysForBlockchains } from './utils/pubkey-sync.js';
+// import { ASSET_COLORS } from './constants/asset-colors.js'; // TODO: Create this file or remove usage
 
 const TAG = ' | Pioneer-sdk | ';
 
-// Color mappings for major assets (until pioneer-discovery includes colors)
-const ASSET_COLORS: Record<string, string> = {
-  // Bitcoin
-  'bip122:000000000019d6689c085ae165831e93/slip44:0': '#FF9800',
-  // Ethereum
-  'eip155:1/slip44:60': '#627EEA',
-  // Polygon
-  'eip155:137/slip44:60': '#8247E5',
-  // Base
-  'eip155:8453/slip44:60': '#0052FF',
-  // BNB
-  'eip155:56/slip44:60': '#F3BA2F',
-  // Litecoin
-  'bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2': '#BFBBBB',
-  // Dogecoin
-  'bip122:00000000001a91e3dace36e2be3bf030/slip44:3': '#C2A633',
-  // Bitcoin Cash
-  'bip122:000000000000000000651ef99cb9fcbe/slip44:145': '#8DC351',
-  // Dash
-  'bip122:000007d91d1254d60e2dd1ae58038307/slip44:5': '#008CE7',
-  // DigiByte
-  'bip122:4da631f2ac1bed857bd968c67c913978/slip44:20': '#006AD2',
-  // Cosmos
-  'cosmos:cosmoshub-4/slip44:118': '#2E3148',
-  // Osmosis
-  'cosmos:osmosis-1/slip44:118': '#9B1FD7',
-  // XRP
-  'ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144': '#23292F',
-  // Maya/CACAO
-  'cosmos:mayachain-mainnet-v1/slip44:931': '#00D4AA',
-  // Thorchain/RUNE
-  'cosmos:thorchain-mainnet-v1/slip44:931': '#00CCFF',
-};
-
 export interface PioneerSDKConfig {
   appName: string;
   appIcon: string;
@@ -84,18 +88,6 @@ export interface PioneerSDKConfig {
   skipKeeperEndpoint?: boolean;     // Skip vault endpoint detection
 }
 
-export interface SyncState {
-  isSynced: boolean;              // Has fresh data from full sync?
-  isInitialSync: boolean;          // First sync (no cache)?
-  cacheAge: number;                // Seconds since last cache update
-  syncProgress: number;            // 0-100 percentage of completion
-  syncedChains: number;            // Number of chains synced
-  totalChains: number;             // Total chains to sync
-  lastSyncTime: number | null;    // Timestamp of last successful sync
-  syncSource: 'cache' | 'fresh' | 'none';  // Where data came from
-}
-
-
 export class SDK {
   public status: string;
   public username: string;
@@ -159,18 +151,8 @@ export class SDK {
   public appName: string;
   public appIcon: any;
   public init: (walletsVerbose: any, setup: any) => Promise<any>;
-  // public initOffline: () => Promise<any>;
-  // public backgroundSync: () => Promise<void>;
   public getUnifiedPortfolio: () => Promise<any>;
   public offlineClient: OfflineClient | null;
-  // public verifyWallet: () => Promise<void>;
-  public convertVaultPubkeysToPioneerFormat: (vaultPubkeys: any[]) => any[];
-  // public deriveNetworksFromPath: (path: string) => string[];
-  // public getAddress: (options: {
-  //   networkId?: string;
-  //   showDevice?: boolean;
-  //   path?: any;
-  // }) => Promise<string>;
   public app: {
     getAddress: (options: {
       networkId?: string;
@@ -272,16 +254,7 @@ export class SDK {
     this.contextType = '';
 
     // Initialize sync state
-    this.syncState = {
-      isSynced: false,
-      isInitialSync: true,
-      cacheAge: 0,
-      syncProgress: 0,
-      syncedChains: 0,
-      totalChains: this.blockchains.length,
-      lastSyncTime: null,
-      syncSource: 'none'
-    };
+    this.syncState = createInitialSyncState(this.blockchains.length);
 
     // Initialize offline client if offline-first mode is enabled
     this.offlineClient = config.offlineFirst
@@ -314,40 +287,17 @@ export class SDK {
       });
     };
 
-    // Helper method to generate unique key for a pubkey
-    this.getPubkeyKey = (pubkey: any): string => {
-      return `${pubkey.pubkey}_${pubkey.pathMaster}`;
-    };
-
-    // Helper method to deduplicate pubkeys array
-    this.deduplicatePubkeys = (pubkeys: any[]): any[] => {
-      const seen = new Set<string>();
-      const deduped = pubkeys.filter((pubkey) => {
-        const key = this.getPubkeyKey(pubkey);
-        if (seen.has(key)) {
-          return false;
-        }
-        seen.add(key);
-        return true;
-      });
-      return deduped;
-    };
+    // Pubkey helper methods using utilities
+    this.getPubkeyKey = getPubkeyKey;
+    this.deduplicatePubkeys = deduplicatePubkeys;
 
     // Helper method to validate and add a single pubkey
     this.addPubkey = (pubkey: any): boolean => {
-      // Validate pubkey has required fields
-      if (!pubkey.pubkey || !pubkey.pathMaster) {
-        return false;
-      }
-
-      const key = this.getPubkeyKey(pubkey);
+      if (!validatePubkey(pubkey)) return false;
 
-      // Check if already exists
-      if (this.pubkeySet.has(key)) {
-        return false;
-      }
+      const key = getPubkeyKey(pubkey);
+      if (this.pubkeySet.has(key)) return false;
 
-      // Add to both array and set
       this.pubkeys.push(pubkey);
       this.pubkeySet.add(key);
       return true;
@@ -378,20 +328,6 @@ export class SDK {
       this.pubkeys = [];
       this.pubkeySet.clear();
     }
-
-    // View-only mode helper methods
-    this.isViewOnlyMode = (): boolean => {
-      return this.viewOnlyMode;
-    };
-
-    this.canSignTransactions = (): boolean => {
-      return !this.viewOnlyMode && !!this.keepKeySdk;
-    };
-
-    this.isVaultAvailable = (): boolean => {
-      return !!this.keepkeyEndpoint && this.keepkeyEndpoint.isAvailable;
-    };
-
     // Fast portfolio loading from kkapi:// cache
     this.getUnifiedPortfolio = async function () {
       const tag = `${TAG} | getUnifiedPortfolio | `;
@@ -439,10 +375,8 @@ export class SDK {
 
           // Update pubkeys from cache
           if (portfolioData.pubkeys && portfolioData.pubkeys.length > 0) {
-            // Convert vault pubkey format to pioneer-sdk format
-            const convertedPubkeys = this.convertVaultPubkeysToPioneerFormat(portfolioData.pubkeys);
             // Use setPubkeys to ensure deduplication
-            this.setPubkeys(convertedPubkeys);
+            this.setPubkeys(portfolioData.pubkeys);
             this.events.emit('SET_PUBKEYS', this.pubkeys);
           }
 
@@ -459,75 +393,12 @@ export class SDK {
           }
 
           // Validate cache data before using it
-          const isCacheDataValid = (portfolioData: any): boolean => {
-            // Check if networks data is reasonable (should be < 50 networks, not thousands)
-            if (!portfolioData.networks || !Array.isArray(portfolioData.networks)) {
-              console.warn('[CACHE VALIDATION] Networks is not an array');
-              return false;
-            }
-
-            if (portfolioData.networks.length > 50) {
-              console.error(
-                `[CACHE VALIDATION] CORRUPTED: ${portfolioData.networks.length} networks (should be < 50)`,
-              );
-              return false;
-            }
-
-            // Check if at least some networks have required fields
-            const validNetworks = portfolioData.networks.filter(
-              (n: any) => n.networkId && n.totalValueUsd !== undefined && n.gasAssetSymbol,
-            );
-
-            if (validNetworks.length === 0 && portfolioData.networks.length > 0) {
-              console.error('[CACHE VALIDATION] CORRUPTED: No networks have required fields');
-              return false;
-            }
-
-            console.log(
-              `[CACHE VALIDATION] Found ${portfolioData.networks.length} networks, ${validNetworks.length} valid`,
-            );
-            return true;
-          };
-
-          // Only use cache data if it's valid
           if (isCacheDataValid(portfolioData)) {
-            const dashboardData = {
-              totalValueUsd: portfolioData.totalValueUsd,
-              pairedDevices: portfolioData.pairedDevices,
-              devices: portfolioData.devices || [],
-              networks: portfolioData.networks || [],
-              assets: portfolioData.assets || [],
-              statistics: portfolioData.statistics || {},
-              cached: portfolioData.cached,
-              lastUpdated: portfolioData.lastUpdated,
-              cacheAge: portfolioData.lastUpdated
-                ? Math.floor((Date.now() - portfolioData.lastUpdated) / 1000)
-                : 0,
-              networkPercentages:
-                portfolioData.networks?.map((network: any) => ({
-                  networkId: network.network_id || network.networkId,
-                  percentage: network.percentage || 0,
-                })) || [],
-            };
-
-            this.dashboard = dashboardData;
+            this.dashboard = buildDashboardFromPortfolioData(portfolioData);
             this.events.emit('SET_DASHBOARD', this.dashboard);
 
             // Update sync state - cache hit
-            const cacheAge = portfolioData.lastUpdated
-              ? Math.floor((Date.now() - portfolioData.lastUpdated) / 1000)
-              : 0;
-
-            this.syncState = {
-              isSynced: true,
-              isInitialSync: false,
-              cacheAge,
-              syncProgress: 100,
-              syncedChains: this.blockchains.length,
-              totalChains: this.blockchains.length,
-              lastSyncTime: portfolioData.lastUpdated || Date.now(),
-              syncSource: 'cache'
-            };
+            this.syncState = createCacheSyncState(portfolioData.lastUpdated, this.blockchains.length);
             this.events.emit('SYNC_STATE_CHANGED', this.syncState);
           } else {
             console.warn(
@@ -784,249 +655,106 @@ export class SDK {
     this.buildDashboardFromBalances = function () {
       return buildDashboardFromBalances(this.balances, this.blockchains, this.assetsMap);
     };
-    // ✅ PHASE 3: Infer asset type from CAIP structure (fallback helper)
-    this.inferTypeFromCaip = function (caip: string): string {
-      if (caip.includes('/slip44:')) return 'native';
-      if (caip.includes('/erc20:') || caip.includes('/bep20:') || caip.includes('/spl:')) return 'token';
-      if (caip.includes('/denom:')) return 'native'; // Cosmos denoms
-      return 'unknown';
-    };
     this.syncMarket = async function () {
       return syncMarket(this.balances, this.pioneer);
     };
     this.sync = async function () {
       const tag = `${TAG} | sync | `;
+      const log = require('@pioneer-platform/loggerdog')();
+
       try {
-        // Helper to check network match with EVM wildcard support (works for both paths and pubkeys)
-        const matchesNetwork = (item: any, networkId: string) => {
-          if (!item.networks || !Array.isArray(item.networks)) return false;
-          if (item.networks.includes(networkId)) return true;
-          if (networkId.startsWith('eip155:') && item.networks.includes('eip155:*')) return true;
-          return false;
+        // Update sync state: starting
+        this.syncState = {
+          ...createInitialSyncState(this.blockchains.length),
+          syncProgress: 10
         };
+        this.events.emit('SYNC_STATE_CHANGED', this.syncState);
 
-        //at least 1 path per chain
+        // Step 1: Initial pubkey fetch
+        log.info(tag, 'Fetching initial pubkeys...');
         await this.getPubkeys();
-        for (let i = 0; i < this.blockchains.length; i++) {
-          let networkId = this.blockchains[i];
-          if (networkId.indexOf('eip155:') >= 0) networkId = 'eip155:*';
-
-          let paths = this.paths.filter((path) => matchesNetwork(path, networkId));
-          if (paths.length === 0) {
-            //get paths for chain
-            let paths = getPaths([networkId]);
-            if (!paths || paths.length === 0) throw Error('Unable to find paths for: ' + networkId);
-            //add to paths
-            this.paths = this.paths.concat(paths);
-          }
-        }
 
-        for (let i = 0; i < this.blockchains.length; i++) {
-          let networkId = this.blockchains[i];
-          if (networkId.indexOf('eip155:') >= 0) networkId = 'eip155:*';
-          const pathsForChain = this.paths.filter((path) => matchesNetwork(path, networkId));
-          if (!pathsForChain || pathsForChain.length === 0)
-            throw Error('No paths found for blockchain: ' + networkId);
-
-          for (let j = 0; j < pathsForChain.length; j++) {
-            const path = pathsForChain[j];
-            let pathBip32 = addressNListToBIP32(path.addressNListMaster);
-            let pubkey = this.pubkeys.find((pubkey) => pubkey.pathMaster === pathBip32);
-            if (!pubkey) {
-              const pubkey = await getPubkey(
-                this.blockchains[i],
-                path,
-                this.keepKeySdk,
-                this.context,
-              );
-              if (!pubkey) throw Error('Unable to get pubkey for network+ ' + networkId);
-              // Use addPubkey method for proper duplicate checking
-              this.addPubkey(pubkey);
-            }
-          }
-        }
+        this.syncState.syncProgress = 20;
+        this.events.emit('SYNC_STATE_CHANGED', this.syncState);
+
+        // Step 2: Ensure paths for all blockchains
+        log.info(tag, 'Discovering paths for blockchains...');
+        this.paths = await ensurePathsForBlockchains(
+          this.blockchains,
+          this.paths,
+          tag
+        );
+
+        this.syncState.syncProgress = 30;
+        this.events.emit('SYNC_STATE_CHANGED', this.syncState);
+
+        // Step 3: Sync pubkeys for all paths
+        log.info(tag, 'Synchronizing pubkeys...');
+        await syncPubkeysForBlockchains(
+          this.blockchains,
+          this.paths,
+          this.pubkeys,
+          this.keepKeySdk,
+          this.context,
+          getPubkey,
+          (pubkey) => this.addPubkey(pubkey),
+          tag
+        );
+
+        this.syncState.syncProgress = 50;
+        this.syncState.syncedChains = this.blockchains.length;
+        this.events.emit('SYNC_STATE_CHANGED', this.syncState);
+
+        // Step 4: Fetch balances
+        log.info(tag, 'Fetching balances...');
         await this.getBalances();
 
-        // Load charts (portfolio + ERC20 tokens + staking positions)
-        // This is CRITICAL for discovering user's token balances (USDT, USDC, etc.)
-        console.log(tag, 'Loading charts (tokens + portfolio)...');
+        this.syncState.syncProgress = 70;
+        this.events.emit('SYNC_STATE_CHANGED', this.syncState);
+
+        // Step 5: Load charts (critical for token discovery)
+        log.info(tag, 'Loading charts (tokens + portfolio)...');
         await this.getCharts();
-        console.log(tag, `Charts loaded. Total balances: ${this.balances.length}`);
+        log.info(tag, `Charts loaded. Total balances: ${this.balances.length}`);
 
-        // Sync market prices for all balances
-        await this.syncMarket();
+        this.syncState.syncProgress = 85;
+        this.events.emit('SYNC_STATE_CHANGED', this.syncState);
 
-        //we should be fully synced so lets make the dashboard
-        const dashboardData: {
-          networks: {
-            networkId: string;
-            totalValueUsd: number;
-            gasAssetCaip: string | null;
-            gasAssetSymbol: string | null;
-            icon: string | null;
-            color: string | null;
-            totalNativeBalance: string;
-          }[];
-          totalValueUsd: number;
-          networkPercentages: { networkId: string; percentage: number }[];
-        } = {
-          networks: [],
-          totalValueUsd: 0,
-          networkPercentages: [],
-        };
+        // Step 6: Sync market prices
+        log.info(tag, 'Syncing market prices...');
+        await this.syncMarket();
 
-        let totalPortfolioValue = 0;
-        const networksTemp: {
-          networkId: string;
-          totalValueUsd: number;
-          gasAssetCaip: string | null;
-          gasAssetSymbol: string | null;
-          icon: string | null;
-          color: string | null;
-          totalNativeBalance: string;
-        }[] = [];
-
-        // Deduplicate blockchains before calculation to prevent double-counting
-        const uniqueBlockchains = [...new Set(this.blockchains)];
-
-        // Calculate totals for each blockchain
-        for (const blockchain of uniqueBlockchains) {
-          const filteredBalances = this.balances.filter((b) => {
-            const networkId = caipToNetworkId(b.caip);
-            return (
-              networkId === blockchain ||
-              (blockchain === 'eip155:*' && networkId.startsWith('eip155:'))
-            );
-          });
+        this.syncState.syncProgress = 95;
+        this.events.emit('SYNC_STATE_CHANGED', this.syncState);
 
-          // Deduplicate balances based on caip + pubkey combination
-          const balanceMap = new Map();
-
-          // Special handling for Bitcoin to work around API bug
-          const isBitcoin = blockchain.includes('bip122:000000000019d6689c085ae165831e93');
-          if (isBitcoin) {
-            // Group Bitcoin balances by value to detect duplicates
-            const bitcoinByValue = new Map();
-            filteredBalances.forEach((balance) => {
-              const valueKey = `${balance.balance}_${balance.valueUsd}`;
-              if (!bitcoinByValue.has(valueKey)) {
-                bitcoinByValue.set(valueKey, []);
-              }
-              bitcoinByValue.get(valueKey).push(balance);
-            });
+        // Step 7: Build dashboard
+        log.info(tag, 'Building dashboard...');
+        this.dashboard = buildDashboardFromBalances(
+          this.balances,
+          [...new Set(this.blockchains)], // Deduplicate blockchains
+          this.assetsMap
+        );
 
-            // Check if all three address types have the same non-zero balance (API bug)
-            for (const [valueKey, balances] of bitcoinByValue.entries()) {
-              if (balances.length === 3 && parseFloat(balances[0].valueUsd || '0') > 0) {
-                // Keep only the xpub (or first one if no xpub)
-                const xpubBalance =
-                  balances.find((b) => b.pubkey?.startsWith('xpub')) || balances[0];
-                const key = `${xpubBalance.caip}_${xpubBalance.pubkey || 'default'}`;
-                balanceMap.set(key, xpubBalance);
-              } else {
-                // Add all balances normally
-                balances.forEach((balance) => {
-                  const key = `${balance.caip}_${balance.pubkey || 'default'}`;
-                  balanceMap.set(key, balance);
-                });
-              }
-            }
-          } else {
-            // Standard deduplication for non-Bitcoin networks
-            filteredBalances.forEach((balance) => {
-              const key = `${balance.caip}_${balance.pubkey || 'default'}`;
-              // Only keep the first occurrence or the one with higher value
-              if (
-                !balanceMap.has(key) ||
-                parseFloat(balance.valueUsd || '0') >
-                  parseFloat(balanceMap.get(key).valueUsd || '0')
-              ) {
-                balanceMap.set(key, balance);
-              }
-            });
-          }
+        // Step 8: Update sync state - complete
+        this.syncState = createFreshSyncState(this.blockchains.length);
+        this.events.emit('SYNC_STATE_CHANGED', this.syncState);
+        this.events.emit('SYNC_COMPLETE', this.syncState);
 
-          const networkBalances = Array.from(balanceMap.values());
-
-          // Ensure we're working with numbers for calculations
-          const networkTotal = networkBalances.reduce((sum, balance, idx) => {
-            const valueUsd =
-              typeof balance.valueUsd === 'string'
-                ? parseFloat(balance.valueUsd)
-                : balance.valueUsd || 0;
-
-            return sum + valueUsd;
-          }, 0);
-
-          // Get native asset for this blockchain
-          const nativeAssetCaip = networkIdToCaip(blockchain);
-          const gasAsset = networkBalances.find((b) => b.caip === nativeAssetCaip);
-
-          // Calculate total native balance (sum of all balances for the native asset)
-          const totalNativeBalance = networkBalances
-            .filter((b) => b.caip === nativeAssetCaip)
-            .reduce((sum, balance) => {
-              const balanceNum =
-                typeof balance.balance === 'string'
-                  ? parseFloat(balance.balance)
-                  : balance.balance || 0;
-              return sum + balanceNum;
-            }, 0)
-            .toString();
-
-          networksTemp.push({
-            networkId: blockchain,
-            totalValueUsd: networkTotal,
-            gasAssetCaip: nativeAssetCaip || null,
-            gasAssetSymbol: gasAsset?.symbol || null,
-            icon: gasAsset?.icon || null,
-            color: gasAsset?.color || null,
-            totalNativeBalance,
-          });
+        log.info(tag, '✅ Sync complete!');
+        return true;
 
-          totalPortfolioValue += networkTotal;
-        }
+      } catch (e) {
+        log.error(tag, 'Sync failed:', e);
 
-        // Sort networks by USD value and assign to dashboard
-        dashboardData.networks = networksTemp.sort((a, b) => b.totalValueUsd - a.totalValueUsd);
-        dashboardData.totalValueUsd = totalPortfolioValue;
-
-        // Calculate network percentages for pie chart
-        dashboardData.networkPercentages = dashboardData.networks
-          .map((network) => ({
-            networkId: network.networkId,
-            percentage:
-              totalPortfolioValue > 0
-                ? Number(((network.totalValueUsd / totalPortfolioValue) * 100).toFixed(2))
-                : 0,
-          }))
-          .filter((entry) => entry.percentage > 0); // Remove zero percentages
-
-        /* console.log('Bitcoin balances:', btcBalances.map(b => ({
-          pubkey: b.pubkey,
-          balance: b.balance,
-          valueUsd: b.valueUsd
-        }))); */
-
-        this.dashboard = dashboardData;
-
-        // Update sync state - fresh sync complete
+        // Update sync state with error
         this.syncState = {
-          isSynced: true,
-          isInitialSync: false,
-          cacheAge: 0,
-          syncProgress: 100,
-          syncedChains: this.blockchains.length,
-          totalChains: this.blockchains.length,
-          lastSyncTime: Date.now(),
-          syncSource: 'fresh'
+          ...this.syncState,
+          isSynced: false,
+          syncProgress: 0
         };
         this.events.emit('SYNC_STATE_CHANGED', this.syncState);
-        this.events.emit('SYNC_COMPLETE', this.syncState);
+        this.events.emit('SYNC_ERROR', e);
 
-        return true;
-      } catch (e) {
-        console.error(tag, 'Error in sync:', e);
         throw e;
       }
     };
@@ -1213,16 +941,6 @@ export class SDK {
 
         //get quote
         // Quote fetching logic
-        // Helper function to check if pubkey matches network (handles EVM wildcard)
-        const matchesNetwork = (pubkey: any, networkId: string) => {
-          if (!pubkey.networks || !Array.isArray(pubkey.networks)) return false;
-          // Exact match
-          if (pubkey.networks.includes(networkId)) return true;
-          // For EVM chains, check if pubkey has eip155:* wildcard
-          if (networkId.startsWith('eip155:') && pubkey.networks.includes('eip155:*')) return true;
-          return false;
-        };
-
         const pubkeys = this.pubkeys.filter((e: any) =>
           matchesNetwork(e, this.assetContext.networkId),
         );
@@ -1280,23 +998,12 @@ export class SDK {
           ).toFixed(2);
           console.log(tag, `Updated assetContext balance to aggregated total: ${totalBalance}`);
 
-          // Fee reserves by network (conservative estimates)
-          // These match the pattern used in transfer functions
-          const feeReserves: any = {
-            'bip122:000000000019d6689c085ae165831e93/slip44:0': 0.00005, // BTC
-            'eip155:1/slip44:60': 0.001, // ETH
-            'cosmos:thorchain-mainnet-v1/slip44:931': 0.02, // RUNE
-            'bip122:00000000001a91e3dace36e2be3bf030/slip44:3': 1, // DOGE
-            'bip122:000007d91d1254d60e2dd1ae58038307/slip44:5': 0.001, // DASH
-            'bip122:000000000000000000651ef99cb9fcbe/slip44:145': 0.0005, // BCH
-          };
-
-          const reserve = feeReserves[swapPayload.caipIn] || 0.0001;
-          inputAmount = Math.max(0, totalBalance - reserve);
+          // Calculate max sendable amount using centralized fee reserve utility
+          inputAmount = getMaxSendableAmount(totalBalance, swapPayload.caipIn);
 
           console.log(
             tag,
-            `Using max amount for swap: ${inputAmount} (total balance: ${totalBalance}, reserve: ${reserve})`,
+            `Using max amount for swap: ${inputAmount} (total balance: ${totalBalance})`,
           );
         } else {
           // Convert amount to number for type safety
@@ -1780,31 +1487,8 @@ export class SDK {
           }
         }
 
-        //add gas assets to map
-
-        // Add missing MAYA token manually until it's added to assetData
-        const mayaTokenCaip = 'cosmos:mayachain-mainnet-v1/denom:maya';
-        if (!this.assetsMap.has(mayaTokenCaip)) {
-          const mayaToken = {
-            caip: mayaTokenCaip,
-            networkId: 'cosmos:mayachain-mainnet-v1',
-            chainId: 'mayachain-mainnet-v1',
-            symbol: 'MAYA',
-            name: 'Maya Token',
-            precision: 4,
-            decimals: 4,
-            color: '#00D4AA',
-            icon: 'https://pioneers.dev/coins/maya.png',
-            explorer: 'https://explorer.mayachain.info',
-            explorerAddressLink: 'https://explorer.mayachain.info/address/{{address}}',
-            explorerTxLink: 'https://explorer.mayachain.info/tx/{{txid}}',
-            type: 'token',
-            isToken: true,
-            denom: 'maya',
-          };
-          this.assetsMap.set(mayaTokenCaip, mayaToken);
-          console.log(tag, 'Added MAYA token to assetsMap');
-        }
+        // All gas assets and tokens are now loaded from assetData
+        // MAYA token is included in generatedAssetData.json
 
         return this.assetsMap;
       } catch (e) {
@@ -1892,195 +1576,85 @@ export class SDK {
     this.getBalancesForNetworks = async function (networkIds: string[], forceRefresh?: boolean) {
       const tag = `${TAG} | getBalancesForNetworks | `;
       try {
-        // Add defensive check for pioneer initialization
         if (!this.pioneer) {
-          console.error(
-            tag,
-            'ERROR: Pioneer client not initialized! this.pioneer is:',
-            this.pioneer,
-          );
           throw new Error('Pioneer client not initialized. Call init() first.');
         }
 
-        // Log force refresh request
-        if (forceRefresh) {
-          console.log(tag, '🔄 Force refresh requested - bypassing balance cache');
-        }
-
-        // DIAGNOSTIC: Log input
-        console.log('🔍 [DIAGNOSTIC] Input networks:', networkIds);
-        console.log('🔍 [DIAGNOSTIC] Total pubkeys:', this.pubkeys.length);
-
-        // DIAGNOSTIC: Check which pubkeys have networks field
-        const pubkeysWithNetworks = this.pubkeys.filter(p => p.networks && Array.isArray(p.networks));
-        const pubkeysWithoutNetworks = this.pubkeys.filter(p => !p.networks || !Array.isArray(p.networks));
+        if (forceRefresh) console.log(tag, '🔄 Force refresh requested');
 
-        console.log('🔍 [DIAGNOSTIC] Pubkeys WITH networks:', pubkeysWithNetworks.length);
-        console.log('🔍 [DIAGNOSTIC] Pubkeys WITHOUT networks:', pubkeysWithoutNetworks.length);
-
-        if (pubkeysWithoutNetworks.length > 0) {
-          console.warn('⚠️ [WARNING] Some pubkeys missing networks field:');
-          pubkeysWithoutNetworks.forEach(pk => {
-            console.warn(`   - ${pk.note || pk.pubkey.slice(0, 10)}: networks=${pk.networks}`);
-          });
-        }
+        // Validate pubkeys and log diagnostics
+        console.log('🔍 [DIAGNOSTIC] Networks:', networkIds.length, 'Pubkeys:', this.pubkeys.length);
+        const { valid, invalid } = validatePubkeysNetworks(this.pubkeys, '🔍 [DIAGNOSTIC]');
+        console.log('🔍 [DIAGNOSTIC] Pubkeys:', { valid: valid.length, invalid: invalid.length });
 
+        // Build asset query for all networks
         const assetQuery: { caip: string; pubkey: string }[] = [];
-
         for (const networkId of networkIds) {
-          let adjustedNetworkId = networkId;
-
-          if (adjustedNetworkId.includes('eip155:')) {
-            adjustedNetworkId = 'eip155:*';
-          }
+          const pubkeys = findPubkeysForNetwork(this.pubkeys, networkId, this.paths, tag);
+          const caip = await networkIdToCaip(networkId);
+          assetQuery.push(...buildAssetQuery(pubkeys, caip));
+        }
 
-          const isEip155 = adjustedNetworkId.includes('eip155');
-          let pubkeys = this.pubkeys.filter(
-            (pubkey) =>
-              pubkey.networks &&
-              Array.isArray(pubkey.networks) &&
-              pubkey.networks.some((network) => {
-                if (isEip155) return network.startsWith('eip155:');
-                return network === adjustedNetworkId;
-              }),
-          );
+        logQueryDiagnostics(assetQuery, '🔍 [DIAGNOSTIC]');
 
-          // FIX 2: Fallback query for missing networks
-          if (pubkeys.length === 0) {
-            console.warn(tag, `⚠️ No pubkeys found for ${networkId} with networks field`);
-            console.warn(tag, 'Attempting fallback: finding pubkeys by path matching');
+        // Fetch balances from API
+        console.log(`⏱️  [PERF] Starting GetPortfolioBalances...`);
+        const apiStart = performance.now();
+        console.time('GetPortfolioBalances Response');
 
-            // Find paths for this network
-            const pathsForNetwork = this.paths.filter(p =>
-              p.networks?.includes(networkId) ||
-              (networkId.startsWith('eip155:') && p.networks?.includes('eip155:*'))
-            );
-
-            // Find pubkeys matching those paths
-            for (const path of pathsForNetwork) {
-              const matchingPubkey = this.pubkeys.find(pk =>
-                JSON.stringify(pk.addressNList) === JSON.stringify(path.addressNList)
-              );
+        const marketInfo = await this.pioneer.GetPortfolioBalances(
+          { pubkeys: assetQuery },
+          forceRefresh ? { forceRefresh: true } : undefined
+        );
 
-              if (matchingPubkey) {
-                console.warn(tag, `  ✓ Found pubkey via path matching: ${matchingPubkey.note || matchingPubkey.pubkey.slice(0, 10)}`);
-                pubkeys.push(matchingPubkey);
-              }
-            }
+        console.timeEnd('GetPortfolioBalances Response');
+        console.log(`⏱️  [PERF] API completed in ${(performance.now() - apiStart).toFixed(0)}ms`);
 
-            if (pubkeys.length > 0) {
-              console.warn(tag, `  ✅ Fallback successful: Found ${pubkeys.length} pubkeys for ${networkId}`);
-            } else {
-              console.error(tag, `  ❌ Fallback failed: No pubkeys found for ${networkId}`);
-            }
-          }
+        // Enrich balances with asset metadata
+        const enrichStart = performance.now();
+        console.log(`⏱️  [PERF] Enriching ${marketInfo.data?.length || 0} balances...`);
 
-          const caipNative = await networkIdToCaip(networkId);
-          for (const pubkey of pubkeys) {
-            assetQuery.push({ caip: caipNative, pubkey: pubkey.pubkey });
-          }
-        }
+        const balances = enrichBalancesWithAssetInfo(
+          marketInfo.data,
+          this.assetsMap,
+          caipToNetworkId
+        );
 
-        // DIAGNOSTIC: Log assetQuery before API call
-        console.log('🔍 [DIAGNOSTIC] Built assetQuery with', assetQuery.length, 'entries');
-        console.log('🔍 [DIAGNOSTIC] Sample queries:', assetQuery.slice(0, 5));
+        console.log(`⏱️  [PERF] Enrichment completed in ${(performance.now() - enrichStart).toFixed(0)}ms`);
 
-        // Group by CAIP to see which chains are included
-        const caipCounts = new Map<string, number>();
-        for (const query of assetQuery) {
-          caipCounts.set(query.caip, (caipCounts.get(query.caip) || 0) + 1);
-        }
-        console.log('🔍 [DIAGNOSTIC] Queries by chain:');
-        caipCounts.forEach((count, caip) => {
-          console.log(`   - ${caip}: ${count} queries`);
-        });
+        // Update state and emit events
+        this.balances = balances;
+        this.events.emit('SET_BALANCES', this.balances);
 
-        console.log(`⏱️  [PERF] Starting GetPortfolioBalances API call...`);
-        const apiCallStart = performance.now();
-        console.time('GetPortfolioBalances Response Time');
+        // Build and emit dashboard
+        const dashStart = performance.now();
+        this.dashboard = this.buildDashboardFromBalances();
+        this.events.emit('SET_DASHBOARD', this.dashboard);
+        console.log(`⏱️  [PERF] Dashboard built in ${(performance.now() - dashStart).toFixed(0)}ms`);
+        console.log(`📊 Dashboard: ${this.dashboard?.networks?.length || 0} networks, $${this.dashboard?.totalValueUsd?.toFixed(2) || '0.00'}`);
 
-        try {
-          // Wrap assetQuery in object with pubkeys field (API expects { pubkeys: [...] })
-          // Pass forceRefresh as query parameter if provided
-          let marketInfo = await this.pioneer.GetPortfolioBalances(
-            { pubkeys: assetQuery },
-            forceRefresh ? { forceRefresh: true } : undefined
-          );
-          const apiCallTime = performance.now() - apiCallStart;
-          console.timeEnd('GetPortfolioBalances Response Time');
-          console.log(`⏱️  [PERF] API call completed in ${apiCallTime.toFixed(0)}ms`);
-
-          const enrichStart = performance.now();
-          let balances = marketInfo.data;
-          console.log(`⏱️  [PERF] Received ${balances?.length || 0} balances from server`);
-
-          // Enrich balances with asset info
-          console.log(`⏱️  [PERF] Starting balance enrichment...`);
-          for (let balance of balances) {
-            const assetInfo = this.assetsMap.get(balance.caip.toLowerCase()) || this.assetsMap.get(balance.caip);
-
-            // ✅ PHASE 3: Add fallback for missing asset metadata
-            if (!assetInfo) {
-              console.warn(`⚠️  [ENRICHMENT] Asset metadata missing for ${balance.caip}, using fallback enrichment`);
-
-              // Fallback: Use API-provided values or infer from CAIP
-              const inferredType = this.inferTypeFromCaip(balance.caip);
-              Object.assign(balance, {
-                type: balance.type || inferredType,
-                isNative: balance.isNative ?? (inferredType === 'native'),
-                networkId: caipToNetworkId(balance.caip),
-                icon: 'https://pioneers.dev/coins/unknown.png',
-                identifier: `${balance.caip}:${balance.pubkey}`,
-                updated: Date.now(),
-              });
-              continue;
-            }
+        console.log(`⏱️  [PERF] Total: ${(performance.now() - apiStart).toFixed(0)}ms`);
+        return this.balances;
 
-            // Get color from mapping (fallback to assetInfo.color if it exists)
-            const color = ASSET_COLORS[balance.caip] || assetInfo.color;
-
-            Object.assign(balance, assetInfo, {
-              type: balance.type || assetInfo.type,           // ✅ PHASE 3: Prefer API type, fallback to assetInfo
-              isNative: balance.isNative ?? assetInfo.isNative, // ✅ PHASE 3: Prefer API isNative
-              networkId: caipToNetworkId(balance.caip),
-              icon: assetInfo.icon || 'https://pioneers.dev/coins/etherum.png',
-              identifier: `${balance.caip}:${balance.pubkey}`,
-              updated: Date.now(), // Add timestamp for worker validation
-              color, // Add color from mapping
-            });
-          }
-          const enrichTime = performance.now() - enrichStart;
-          console.log(`⏱️  [PERF] Enrichment completed in ${enrichTime.toFixed(0)}ms`);
-          
-          this.balances = balances;
-          this.events.emit('SET_BALANCES', this.balances);
-
-          // Build dashboard from balances
-          console.log(`⏱️  [PERF] Building dashboard from ${balances.length} balances...`);
-          const dashboardStart = performance.now();
-          const dashboardData = this.buildDashboardFromBalances();
-          this.dashboard = dashboardData;
-          this.events.emit('SET_DASHBOARD', this.dashboard);
-          console.log(`⏱️  [PERF] Dashboard built in ${(performance.now() - dashboardStart).toFixed(0)}ms`);
-          console.log(`📊 Dashboard created: ${this.dashboard?.networks?.length || 0} networks, $${this.dashboard?.totalValueUsd?.toFixed(2) || '0.00'} total`);
-
-          console.log(`⏱️  [PERF] Total getBalancesForNetworks: ${(performance.now() - apiCallStart).toFixed(0)}ms`);
-          return this.balances;
-        } catch (apiError: any) {
-          console.error(tag, 'GetPortfolioBalances API call failed:', apiError);
-          throw new Error(
-            `GetPortfolioBalances API call failed: ${apiError?.message || 'Unknown error'}`,
-          );
-        }
-      } catch (e) {
-        console.error(tag, 'Error: ', e);
+      } catch (e: any) {
+        console.error(tag, 'Error:', e?.message || e);
         throw e;
       }
     };
-    this.getBalances = async function (forceRefresh?: boolean) {
+    this.getBalances = async function (forceRefresh?: boolean, caip?: string) {
       const tag = `${TAG} | getBalances | `;
       try {
-        // Simply call the shared function with all blockchains
+        // If CAIP is provided, refresh only that specific asset
+        if (caip) {
+          console.log(tag, `🎯 Refreshing single asset: ${caip}`);
+          const networkId = caip.split('/')[0];
+          console.log(tag, `📍 Target network: ${networkId}`);
+
+          const results = await this.getBalancesForNetworks([networkId], forceRefresh);
+          return results.filter((b) => b.caip === caip || b.networkId === networkId);
+        }
+
+        // Default: refresh all blockchains
         return await this.getBalancesForNetworks(this.blockchains, forceRefresh);
       } catch (e) {
         console.error(tag, 'Error in getBalances: ', e);
@@ -2090,16 +1664,8 @@ export class SDK {
     this.getBalance = async function (networkId: string) {
       const tag = `${TAG} | getBalance | `;
       try {
-        // If we need to handle special logic like eip155: inside getBalance,
-        // we can do it here or just rely on getBalancesForNetworks to handle it.
-        // For example:
-        // if (networkId.includes('eip155:')) {
-        //   networkId = 'eip155:*';
-        // }
-
         // Call the shared function with a single-network array
         const results = await this.getBalancesForNetworks([networkId]);
-
         // If needed, you can filter only those that match the specific network
         // (especially if you used wildcard eip155:*)
         const filtered = results.filter(
@@ -2111,11 +1677,6 @@ export class SDK {
         throw e;
       }
     };
-
-    /**
-     * Get normalized fee rates for a specific network
-     * This method handles all fee complexity and returns a clean, consistent format
-     */
     this.getFees = async function (networkId: string): Promise<NormalizedFeeRates> {
       const tag = `${TAG} | getFees | `;
       try {
@@ -2239,171 +1800,47 @@ export class SDK {
         if (!asset.caip) throw Error('Invalid Asset! missing caip!');
         if (!asset.networkId) asset.networkId = caipToNetworkId(asset.caip);
 
-        // CRITICAL VALIDATION: Check if we have an address/xpub for this network
-        if (!this.pubkeys || this.pubkeys.length === 0) {
-          const errorMsg = `Cannot set asset context for ${asset.caip} - no pubkeys loaded. Please initialize wallet first.`;
-          console.error(tag, errorMsg);
-          throw new Error(errorMsg);
-        }
-
-        // For EVM chains, check for wildcard eip155:* in addition to exact match
-        const pubkeysForNetwork = this.pubkeys.filter((e: any) => {
-          if (!e.networks || !Array.isArray(e.networks)) return false;
-
-          // Exact match
-          if (e.networks.includes(asset.networkId)) return true;
-
-          // For EVM chains, check if pubkey has eip155:* wildcard
-          if (asset.networkId.startsWith('eip155:') && e.networks.includes('eip155:*')) {
-            return true;
-          }
-
-          return false;
-        });
-
-        if (pubkeysForNetwork.length === 0) {
-          const errorMsg = `Cannot set asset context for ${asset.caip} - no address/xpub found for network ${asset.networkId}`;
-          console.error(tag, errorMsg);
-          console.error(tag, 'Available networks in pubkeys:', [
-            ...new Set(this.pubkeys.flatMap((p: any) => p.networks || [])),
-          ]);
-          throw new Error(errorMsg);
-        }
-
-        // For UTXO chains, verify we have xpub
-        const isUtxoChain = asset.networkId.startsWith('bip122:');
-        if (isUtxoChain) {
-          const xpubFound = pubkeysForNetwork.some((p: any) => p.type === 'xpub' && p.pubkey);
-          if (!xpubFound) {
-            const errorMsg = `Cannot set asset context for UTXO chain ${asset.caip} - xpub required but not found`;
-            console.error(tag, errorMsg);
-            throw new Error(errorMsg);
-          }
-        }
-
-        // Verify we have a valid address or pubkey
-        const hasValidAddress = pubkeysForNetwork.some(
-          (p: any) => p.address || p.master || p.pubkey,
-        );
-        if (!hasValidAddress) {
-          const errorMsg = `Cannot set asset context for ${asset.caip} - no valid address found in pubkeys`;
-          console.error(tag, errorMsg);
-          throw new Error(errorMsg);
-        }
-
+        // Validate pubkeys for network (throws descriptive errors)
+        validatePubkeysForNetwork(this.pubkeys, asset.networkId, asset.caip);
+        const pubkeysForNetwork = findPubkeysForNetwork(this.pubkeys, asset.networkId);
         console.log(
           tag,
           `✅ Validated: Found ${pubkeysForNetwork.length} addresses for ${asset.networkId}`,
         );
 
-        // ALWAYS fetch fresh market price for the asset
-        let freshPriceUsd = 0;
-        try {
-          // Validate CAIP before calling API
-          if (!asset.caip || typeof asset.caip !== 'string' || !asset.caip.includes(':')) {
-            console.warn(tag, 'Invalid or missing CAIP, skipping market price fetch:', asset.caip);
-          } else {
-            console.log(tag, 'Fetching fresh market price for:', asset.caip);
-            const marketData = await this.pioneer.GetMarketInfo([asset.caip]);
-            console.log(tag, 'Market data response:', marketData);
-
-            if (marketData && marketData.data && marketData.data.length > 0) {
-              freshPriceUsd = marketData.data[0];
-              console.log(tag, '✅ Fresh market price:', freshPriceUsd);
-            } else {
-              console.warn(tag, 'No market data returned for:', asset.caip);
-            }
-          }
-        } catch (marketError) {
-          console.error(tag, 'Error fetching market price:', marketError);
-          // Continue without fresh price, will try to use cached data
-        }
+        // Fetch fresh market price
+        const freshPriceUsd = await fetchMarketPrice(this.pioneer, asset.caip);
 
-        // Try to find the asset in the local assetsMap
-        let assetInfo = this.assetsMap.get(asset.caip.toLowerCase());
-        console.log(tag, 'assetInfo: ', assetInfo);
-
-        //check discovery
-        let assetInfoDiscovery = assetData[asset.caip];
-        console.log(tag, 'assetInfoDiscovery: ', assetInfoDiscovery);
-        if (assetInfoDiscovery) assetInfo = assetInfoDiscovery;
-
-        // If the asset is not found, create a placeholder object
-        if (!assetInfo) {
-          console.log(tag, 'Building placeholder asset!');
-          // Create a placeholder asset if it's not found in Pioneer or locally
-          assetInfo = {
-            caip: asset.caip.toLowerCase(),
-            networkId: asset.networkId,
-            symbol: asset.symbol || 'UNKNOWN',
-            name: asset.name || 'Unknown Asset',
-            icon: asset.icon || 'https://pioneers.dev/coins/ethereum.png',
-          };
-        }
+        // Resolve asset info from multiple sources
+        let assetInfo = resolveAssetInfo(this.assetsMap, assetData, asset);
 
-        // Look for price and balance information in balances
-        // CRITICAL: For UTXO chains, we need to aggregate ALL balances across all xpubs
+        // Get matching balances
         const matchingBalances = this.balances.filter((b) => b.caip === asset.caip);
 
+        // Extract price from balances if available
         if (matchingBalances.length > 0) {
-          // Use price from first balance entry (all should have same price)
-          // Check for both priceUsd and price properties (different sources may use different names)
-          let priceValue = matchingBalances[0].priceUsd || matchingBalances[0].price;
-
-          // If no price but we have valueUsd and balance, calculate the price
-          if ((!priceValue || priceValue === 0) && matchingBalances[0].valueUsd && matchingBalances[0].balance) {
-            const balance = parseFloat(matchingBalances[0].balance);
-            const valueUsd = parseFloat(matchingBalances[0].valueUsd);
-            if (balance > 0 && valueUsd > 0) {
-              priceValue = valueUsd / balance;
-              console.log(tag, 'calculated priceUsd from valueUsd/balance:', priceValue);
-            }
-          }
-
-          if (priceValue && priceValue > 0) {
+          const priceValue = extractPriceFromBalances(matchingBalances);
+          if (priceValue > 0) {
             console.log(tag, 'detected priceUsd from balance:', priceValue);
             assetInfo.priceUsd = priceValue;
           }
         }
 
-        // Override with fresh price if we got one from the API
-        if (freshPriceUsd && freshPriceUsd > 0) {
+        // Override with fresh price and aggregate balances
+        if (freshPriceUsd > 0) {
           assetInfo.priceUsd = freshPriceUsd;
           console.log(tag, '✅ Using fresh market price:', freshPriceUsd);
 
-          // Aggregate all balances for this asset (critical for UTXO chains with multiple xpubs)
-          let totalBalance = 0;
-          let totalValueUsd = 0;
-
-          console.log(tag, `Found ${matchingBalances.length} balance entries for ${asset.caip}`);
-          for (const balanceEntry of matchingBalances) {
-            const balance = parseFloat(balanceEntry.balance) || 0;
-            const valueUsd = parseFloat(balanceEntry.valueUsd) || 0;
-            totalBalance += balance;
-            totalValueUsd += valueUsd;
-            console.log(tag, `  Balance entry: ${balance} (${valueUsd} USD)`);
-          }
-
+          const { totalBalance, totalValueUsd } = aggregateBalances(matchingBalances, asset.caip);
           assetInfo.balance = totalBalance.toString();
           assetInfo.valueUsd = totalValueUsd.toFixed(2);
-          console.log(tag, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
         }
 
         // Filter balances and pubkeys for this asset
         const assetBalances = this.balances.filter((b) => b.caip === asset.caip);
-        const assetPubkeys = this.pubkeys.filter(
-          (p) =>
-            (p.networks &&
-              Array.isArray(p.networks) &&
-              p.networks.includes(caipToNetworkId(asset.caip))) ||
-            (caipToNetworkId(asset.caip).includes('eip155') &&
-              p.networks &&
-              Array.isArray(p.networks) &&
-              p.networks.some((n) => n.startsWith('eip155'))),
-        );
+        const assetPubkeys = filterPubkeysForAsset(this.pubkeys, asset.caip, caipToNetworkId);
 
         // Combine the user-provided asset with any additional info we have
-        // IMPORTANT: Don't let a 0 priceUsd from input override a valid price from balance
         const finalAssetContext = {
           ...assetInfo,
           ...asset,
@@ -2411,21 +1848,14 @@ export class SDK {
           balances: assetBalances,
         };
 
-        // If input has priceUsd of 0 but we found a valid price from balance, use the balance price
+        // If input has priceUsd of 0 but we found a valid price, use the found price
         if ((!asset.priceUsd || asset.priceUsd === 0) && assetInfo.priceUsd && assetInfo.priceUsd > 0) {
           finalAssetContext.priceUsd = assetInfo.priceUsd;
         }
 
         // Update all matching balances with the fresh price
-        if (freshPriceUsd && freshPriceUsd > 0) {
-          for (const balance of assetBalances) {
-            balance.price = freshPriceUsd;
-            balance.priceUsd = freshPriceUsd;
-            // Recalculate valueUsd with fresh price
-            const balanceAmount = parseFloat(balance.balance || 0);
-            balance.valueUsd = (balanceAmount * freshPriceUsd).toString();
-          }
-          console.log(tag, 'Updated all balances with fresh price data');
+        if (freshPriceUsd > 0) {
+          updateBalancesWithPrice(assetBalances, freshPriceUsd);
         }
 
         this.assetContext = finalAssetContext;
@@ -2439,38 +1869,6 @@ export class SDK {
         ) {
           // Get the native asset for this network
           const networkId = asset.networkId || assetInfo.networkId;
-
-          // Determine the native gas symbol based on the network
-          let nativeSymbol = 'GAS'; // default fallback
-          let nativeCaip = '';
-
-          //TODO removeme
-          if (networkId.includes('mayachain')) {
-            nativeSymbol = 'CACAO';
-            nativeCaip = 'cosmos:mayachain-mainnet-v1/slip44:931';
-          } else if (networkId.includes('thorchain')) {
-            nativeSymbol = 'RUNE';
-            nativeCaip = 'cosmos:thorchain-mainnet-v1/slip44:931';
-          } else if (networkId.includes('cosmoshub')) {
-            nativeSymbol = 'ATOM';
-            nativeCaip = 'cosmos:cosmoshub-4/slip44:118';
-          } else if (networkId.includes('osmosis')) {
-            nativeSymbol = 'OSMO';
-            nativeCaip = 'cosmos:osmosis-1/slip44:118';
-          } else if (networkId.includes('eip155:1')) {
-            nativeSymbol = 'ETH';
-            nativeCaip = 'eip155:1/slip44:60';
-          } else if (networkId.includes('eip155:137')) {
-            nativeSymbol = 'MATIC';
-            nativeCaip = 'eip155:137/slip44:60';
-          } else if (networkId.includes('eip155:56')) {
-            nativeSymbol = 'BNB';
-            nativeCaip = 'eip155:56/slip44:60';
-          } else if (networkId.includes('eip155:43114')) {
-            nativeSymbol = 'AVAX';
-            nativeCaip = 'eip155:43114/slip44:60';
-          }
-
           // Set the native symbol
           this.assetContext.nativeSymbol = nativeSymbol;
 
@@ -2569,125 +1967,54 @@ export class SDK {
     this.setOutboundAssetContext = async function (asset?: any): Promise<any> {
       const tag = `${TAG} | setOutputAssetContext | `;
       try {
-        console.log(tag, '0. asset: ', asset);
+        console.log(tag, 'asset:', asset);
         // Accept null
         if (!asset) {
           this.outboundAssetContext = null;
           return;
         }
 
-        console.log(tag, '1 asset: ', asset);
-
         if (!asset.caip) throw Error('Invalid Asset! missing caip!');
         if (!asset.networkId) asset.networkId = caipToNetworkId(asset.caip);
 
-        console.log(tag, 'networkId: ', asset.networkId);
-        console.log(tag, 'this.pubkeys: ', this.pubkeys);
-        //get a pubkey for network (handle EVM wildcard)
-        const pubkey = this.pubkeys.find((p) => {
-          if (!p.networks || !Array.isArray(p.networks)) return false;
-          // Exact match
-          if (p.networks.includes(asset.networkId)) return true;
-          // For EVM chains, check if pubkey has eip155:* wildcard
-          if (asset.networkId.startsWith('eip155:') && p.networks.includes('eip155:*')) return true;
-          return false;
-        });
-        if (!pubkey) throw Error('Invalid network! missing pubkey for network! ' + asset.networkId);
+        console.log(tag, 'networkId:', asset.networkId);
 
-        // ALWAYS fetch fresh market price for the asset
-        let freshPriceUsd = 0;
-        try {
-          // Validate CAIP before calling API
-          if (!asset.caip || typeof asset.caip !== 'string' || !asset.caip.includes(':')) {
-            console.warn(tag, 'Invalid or missing CAIP, skipping market price fetch:', asset.caip);
-          } else {
-            console.log(tag, 'Fetching fresh market price for:', asset.caip);
-            const marketData = await this.pioneer.GetMarketInfo([asset.caip]);
-            console.log(tag, 'Market data response:', marketData);
+        // Get pubkey for network (uses utility helper)
+        const pubkey = findPubkeyForNetwork(this.pubkeys, asset.networkId);
+        if (!pubkey) throw Error('Invalid network! missing pubkey for network! ' + asset.networkId);
 
-            if (marketData && marketData.data && marketData.data.length > 0) {
-              freshPriceUsd = marketData.data[0];
-              console.log(tag, '✅ Fresh market price:', freshPriceUsd);
-            } else {
-              console.warn(tag, 'No market data returned for:', asset.caip);
-            }
-          }
-        } catch (marketError) {
-          console.error(tag, 'Error fetching market price:', marketError);
-          // Continue without fresh price, will try to use cached data
-        }
+        // Fetch fresh market price
+        const freshPriceUsd = await fetchMarketPrice(this.pioneer, asset.caip);
 
-        // Try to find the asset in the local assetsMap
-        let assetInfo = this.assetsMap.get(asset.caip.toLowerCase());
-        console.log(tag, 'assetInfo: ', assetInfo);
-
-        // If the asset is not found, create a placeholder object
-        if (!assetInfo) {
-          // Create a placeholder asset if it's not found in Pioneer or locally
-          assetInfo = {
-            caip: asset.caip.toLowerCase(),
-            networkId: asset.networkId,
-            symbol: asset.symbol || 'UNKNOWN',
-            name: asset.name || 'Unknown Asset',
-            icon: asset.icon || 'https://pioneers.dev/coins/ethereum.png',
-          };
-        }
+        // Resolve asset info from multiple sources
+        let assetInfo = resolveAssetInfo(this.assetsMap, assetData, asset);
 
-        // Look for price and balance information in balances
-        // CRITICAL: For UTXO chains, we need to aggregate ALL balances across all xpubs
+        // Get matching balances
         const matchingBalances = this.balances.filter((b) => b.caip === asset.caip);
 
+        // Extract price from balances if available
         if (matchingBalances.length > 0) {
-          // Use price from first balance entry (all should have same price)
-          // Check for both priceUsd and price properties (different sources may use different names)
-          let priceValue = matchingBalances[0].priceUsd || matchingBalances[0].price;
-
-          // If no price but we have valueUsd and balance, calculate the price
-          if ((!priceValue || priceValue === 0) && matchingBalances[0].valueUsd && matchingBalances[0].balance) {
-            const balance = parseFloat(matchingBalances[0].balance);
-            const valueUsd = parseFloat(matchingBalances[0].valueUsd);
-            if (balance > 0 && valueUsd > 0) {
-              priceValue = valueUsd / balance;
-              console.log(tag, 'calculated priceUsd from valueUsd/balance:', priceValue);
-            }
-          }
-
-          if (priceValue && priceValue > 0) {
+          const priceValue = extractPriceFromBalances(matchingBalances);
+          if (priceValue > 0) {
             console.log(tag, 'detected priceUsd from balance:', priceValue);
             assetInfo.priceUsd = priceValue;
           }
         }
 
-        // Override with fresh price if we got one from the API
-        if (freshPriceUsd && freshPriceUsd > 0) {
+        // Override with fresh price and aggregate balances
+        if (freshPriceUsd > 0) {
           assetInfo.priceUsd = freshPriceUsd;
           console.log(tag, '✅ Using fresh market price:', freshPriceUsd);
 
-          // Aggregate all balances for this asset (critical for UTXO chains with multiple xpubs)
-          let totalBalance = 0;
-          let totalValueUsd = 0;
-
-          console.log(tag, `Found ${matchingBalances.length} balance entries for ${asset.caip}`);
-          for (const balanceEntry of matchingBalances) {
-            const balance = parseFloat(balanceEntry.balance) || 0;
-            const valueUsd = parseFloat(balanceEntry.valueUsd) || 0;
-            totalBalance += balance;
-            totalValueUsd += valueUsd;
-            console.log(tag, `  Balance entry: ${balance} (${valueUsd} USD)`);
-          }
-
+          const { totalBalance, totalValueUsd } = aggregateBalances(matchingBalances, asset.caip);
           assetInfo.balance = totalBalance.toString();
           assetInfo.valueUsd = totalValueUsd.toFixed(2);
-          console.log(tag, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
         }
 
-        console.log(tag, 'CHECKPOINT 1');
-
         // Combine the user-provided asset with any additional info we have
         this.outboundAssetContext = { ...assetInfo, ...asset, ...pubkey };
 
-        console.log(tag, 'CHECKPOINT 3');
-        console.log(tag, 'outboundAssetContext: assetInfo: ', assetInfo);
+        console.log(tag, 'outboundAssetContext set:', this.outboundAssetContext.caip);
 
         // Set outbound blockchain context based on asset
         if (asset.caip) {
@@ -2717,18 +2044,8 @@ export class SDK {
     ownerAddress: string;
     spenderAddress: string;
   }) => {
-    const tag = TAG + ' | CheckERC20Allowance | ';
-    try {
-      console.log(tag, 'Checking ERC20 allowance:', params);
-
-      const result = await this.pioneer.GetTokenAllowance(params);
-
-      console.log(tag, 'Allowance result:', result);
-      return result.data;
-    } catch (e) {
-      console.error(tag, 'Error checking ERC20 allowance:', e);
-      throw e;
-    }
+    const result = await this.pioneer.GetTokenAllowance(params);
+    return result.data;
   };
 
   /**
@@ -2742,18 +2059,8 @@ export class SDK {
     ownerAddress: string;
     amount: string;
   }) => {
-    const tag = TAG + ' | BuildERC20ApprovalTx | ';
-    try {
-      console.log(tag, 'Building ERC20 approval transaction:', params);
-
-      const result = await this.pioneer.BuildApprovalTransaction(params);
-
-      console.log(tag, 'Approval tx built:', result);
-      return result.data;
-    } catch (e) {
-      console.error(tag, 'Error building approval transaction:', e);
-      throw e;
-    }
+    const result = await this.pioneer.BuildApprovalTransaction(params);
+    return result.data;
   };
 }