@pioneer-platform/pioneer-sdk 8.11.10 → 8.11.14

package/package.json

@@ -1,14 +1,14 @@
 {
   "author": "highlander",
   "name": "@pioneer-platform/pioneer-sdk",
-  "version": "8.11.10",
+  "version": "8.11.14",
   "dependencies": {
     "@keepkey/keepkey-sdk": "^0.2.62",
     "@pioneer-platform/loggerdog": "^8.11.0",
     "@pioneer-platform/pioneer-caip": "^9.10.0",
     "@pioneer-platform/pioneer-client": "^9.10.10",
     "@pioneer-platform/pioneer-coins": "^9.11.0",
-    "@pioneer-platform/pioneer-discovery": "^8.11.4",
+    "@pioneer-platform/pioneer-discovery": "^8.11.14",
     "@pioneer-platform/pioneer-events": "^8.11.0",
     "coinselect": "^3.1.13",
     "eventemitter3": "^5.0.1",

package/src/charts/cosmos-staking.ts

@@ -8,6 +8,18 @@ export async function getCosmosStakingCharts(params: ChartParams): Promise<Chart
   const balances: ChartBalance[] = [];
   
   try {
+    // Fast-path: skip staking in test/e2e or when explicitly requested
+    try {
+      const fastFlag = typeof process !== 'undefined' && process.env && process.env.PIONEER_FAST === '1';
+      const isTestContext = typeof context === 'string' && /test|e2e/i.test(context);
+      if (fastFlag || isTestContext) {
+        console.log(tag, 'Fast mode detected (test/e2e). Skipping cosmos staking fetch.');
+        return balances;
+      }
+    } catch (_) {
+      // ignore
+    }
+
     console.log(tag, 'Adding Cosmos staking positions to charts...');
 
     // Find cosmos pubkeys that could have staking positions
@@ -27,31 +39,29 @@ export async function getCosmosStakingCharts(params: ChartParams): Promise<Chart
 
     console.log(tag, 'Found cosmos pubkeys for staking:', cosmosPubkeys.length);
 
-    for (const cosmosPubkey of cosmosPubkeys) {
-      if (!cosmosPubkey.address) {
-        continue;
-      }
+    await Promise.allSettled(
+      cosmosPubkeys.map(async (cosmosPubkey: any) => {
+        if (!cosmosPubkey.address) return;
 
-      // Check which cosmos networks this pubkey supports
-      const cosmosNetworks = cosmosPubkey.networks.filter(
-        (n: string) => n.includes('cosmos:cosmoshub') || n.includes('cosmos:osmosis'),
-      );
+        const cosmosNetworks = cosmosPubkey.networks.filter(
+          (n: string) => n.includes('cosmos:cosmoshub') || n.includes('cosmos:osmosis'),
+        );
 
-      for (const networkId of cosmosNetworks) {
-        // Only process if this network is in our blockchains list
-        if (!blockchains.includes(networkId)) {
-          continue;
-        }
-
-        await fetchStakingPositionsForNetwork(
-          networkId,
-          cosmosPubkey.address,
-          context,
-          pioneer,
-          balances
+        await Promise.allSettled(
+          cosmosNetworks
+            .filter((networkId: string) => blockchains.includes(networkId))
+            .map(async (networkId: string) => {
+              await fetchStakingPositionsForNetwork(
+                networkId,
+                cosmosPubkey.address,
+                context,
+                pioneer,
+                balances
+              );
+            })
         );
-      }
-    }
+      })
+    );
   } catch (e) {
     console.error(tag, 'Error adding cosmos staking positions:', e);
   }

package/src/charts/evm.ts

@@ -18,31 +18,72 @@ export async function getEvmCharts(params: ChartParams): Promise<ChartBalance[]>
   console.log(tag, 'Total pubkeys available:', pubkeys.length);
   console.log(tag, 'Blockchains to process:', blockchains);
 
-  // Only call portfolio endpoint if we have an EVM address (Zapper requirement)
-  if (!primaryAddress) {
-    console.log(
-      tag,
-      'No EVM address found, skipping portfolio lookup (Zapper only supports Ethereum)',
-    );
-    return balances;
+  // Build pubkeys array for batch request
+  // Map all pubkeys to { pubkey, caip } format for each supported blockchain
+  const pubkeysForBatch: { pubkey: string; caip: string }[] = [];
+
+  for (const pubkey of pubkeys) {
+    const address = pubkey.address || pubkey.master || pubkey.pubkey;
+    if (!address) continue;
+
+    // Get networks this pubkey supports
+    const supportedNetworks = pubkey.networks || [];
+
+    // For each blockchain we're processing
+    for (const blockchain of blockchains) {
+      // Check if this pubkey supports this blockchain
+      // Networks can be specific (eip155:1) or wildcard (eip155:*)
+      const supportsNetwork = supportedNetworks.some((net: string) =>
+        net === blockchain ||
+        (net.endsWith(':*') && blockchain.startsWith(net.replace(':*', ':')))
+      );
+
+      if (supportsNetwork) {
+        // Build the CAIP for this combination
+        // For EVM chains, use slip44:60 for ETH asset
+        // For non-EVM chains, we'd need different logic (not implemented yet)
+        let caip: string;
+        if (blockchain.startsWith('eip155:')) {
+          caip = `${blockchain}/slip44:60`;
+        } else {
+          // For non-EVM chains, use generic format
+          // TODO: Implement proper CAIP construction for other chains
+          caip = `${blockchain}/slip44:0`;
+        }
+
+        pubkeysForBatch.push({
+          pubkey: address,
+          caip: caip
+        });
+      }
+    }
   }
 
-  console.log(tag, 'Using EVM address for portfolio:', primaryAddress);
+  console.log(tag, `Built ${pubkeysForBatch.length} pubkey-chain combinations for batch request`);
+
+  // Only call portfolio endpoint if we have pubkeys to query
+  if (pubkeysForBatch.length === 0) {
+    console.log(tag, 'No pubkeys to query, skipping portfolio lookup');
+    return balances;
+  }
 
   // REDUNDANCY: Fetch stable coins from dedicated endpoint for ALL EVM networks
-  // This ensures USDC/USDT balances are always available even if Zapper fails
-  await fetchStableCoins(pioneer, primaryAddress, blockchains, balances, context);
+  // This ensures USDC/USDT balances are always available even if cache is empty
+  if (primaryAddress) {
+    await fetchStableCoins(pioneer, primaryAddress, blockchains, balances, context);
+  }
 
   // CUSTOM TOKENS: Fetch user-defined custom tokens from MongoDB-backed endpoint
   // This ensures user's custom tokens are always included in their portfolio
   await fetchCustomTokens({ blockchains, pioneer, pubkeys, context }, balances);
 
   try {
-    // NOTE: Zapper API returns portfolio data across ALL networks for a given address
-    // We use eip155:1 as the networkId parameter, but Zapper will return data for all EVM chains
+    // BATCH + NON-BLOCKING: Call portfolio endpoint with ALL pubkeys in one request
+    // The endpoint returns immediately from cache, never blocks waiting for blockchain APIs
+    console.log(tag, `Calling GetPortfolio with ${pubkeysForBatch.length} pubkeys (batch + non-blocking)`);
+
     let portfolio = await pioneer.GetPortfolio({
-      networkId: 'eip155:1',  // Required by endpoint, but Zapper returns all networks
-      address: primaryAddress
+      pubkeys: pubkeysForBatch
     });
 
     // Handle double-wrapped response from Swagger client
@@ -73,10 +114,10 @@ export async function getEvmCharts(params: ChartParams): Promise<ChartBalance[]>
     }
     console.log(tag, `Processed ${processedCount} balances, skipped ${skippedCount}`);
 
-    // Process tokens from portfolio (if they exist)
+    // Process tokens from portfolio.tokens array (returned by backend with blocking token fetch)
     if (portfolio.tokens && portfolio.tokens.length > 0) {
       console.log(tag, 'Processing portfolio.tokens:', portfolio.tokens.length);
-      
+
       for (const token of portfolio.tokens) {
         const processedToken = processPortfolioToken(token, primaryAddress, context, blockchains);
         if (processedToken && !checkDuplicateBalance(balances, processedToken.caip, processedToken.pubkey)) {
@@ -84,6 +125,8 @@ export async function getEvmCharts(params: ChartParams): Promise<ChartBalance[]>
         }
       }
     }
+
+    console.log(tag, `Total balances (native + tokens): ${balances.length}`);
   } catch (e) {
     console.error(tag, 'Error fetching portfolio:', e);
   }
@@ -243,6 +286,18 @@ async function fetchStableCoins(
 ): Promise<void> {
   console.log(tag, 'Fetching stable coins for redundancy...');
 
+  // Fast-path: skip redundancy in test/e2e or when explicitly requested
+  try {
+    const fastFlag = typeof process !== 'undefined' && process.env && process.env.PIONEER_FAST === '1';
+    const isTestContext = typeof context === 'string' && /test|e2e/i.test(context);
+    if (fastFlag || isTestContext) {
+      console.log(tag, 'Fast mode detected (test/e2e). Skipping stable coin redundancy.');
+      return;
+    }
+  } catch (_) {
+    // no-op if process/env not available
+  }
+
   // Networks that support stable coins endpoint
   const supportedNetworks = ['eip155:1', 'eip155:137', 'eip155:8453', 'eip155:56'];
 
@@ -256,30 +311,42 @@ async function fetchStableCoins(
 
   console.log(tag, `Checking stable coins on ${networksToCheck.length} networks`);
 
-  // Fetch stable coins for each network
-  for (const networkId of networksToCheck) {
-    try {
-      const response = await pioneer.GetStableCoins({ networkId, address: primaryAddress });
-      const stableCoins = response?.data?.tokens || [];
-
-      console.log(tag, `Found ${stableCoins.length} stable coins on ${networkId}`);
-
-      // Process each stable coin
-      for (const token of stableCoins) {
-        // Convert to ChartBalance format
-        const chartBalance = processPortfolioToken(token, primaryAddress, context, blockchains);
+  // Helper: timeout a promise
+  const withTimeout = <T>(p: Promise<T>, ms: number): Promise<T> => {
+    return new Promise<T>((resolve, reject) => {
+      const t = setTimeout(() => reject(new Error(`timeout ${ms}ms`)), ms);
+      p.then((v) => { clearTimeout(t); resolve(v); })
+       .catch((e) => { clearTimeout(t); reject(e); });
+    });
+  };
 
-        // Add if not already in balances (avoid duplicates)
-        if (chartBalance && !checkDuplicateBalance(balances, chartBalance.caip, chartBalance.pubkey)) {
-          balances.push(chartBalance);
-          console.log(tag, `Added stable coin: ${chartBalance.symbol} = ${chartBalance.balance}`);
+  // Fetch stable coins for each network in parallel with short timeouts
+  const results = await Promise.allSettled(
+    networksToCheck.map(async (networkId) => {
+      try {
+        const response = await withTimeout(
+          pioneer.GetStableCoins({ networkId, address: primaryAddress }),
+          2000
+        );
+        const stableCoins = response?.data?.tokens || [];
+        console.log(tag, `Found ${stableCoins.length} stable coins on ${networkId}`);
+
+        for (const token of stableCoins) {
+          const chartBalance = processPortfolioToken(token, primaryAddress, context, blockchains);
+          if (chartBalance && !checkDuplicateBalance(balances, chartBalance.caip, chartBalance.pubkey)) {
+            balances.push(chartBalance);
+            console.log(tag, `Added stable coin: ${chartBalance.symbol} = ${chartBalance.balance}`);
+          }
         }
+      } catch (error: any) {
+        console.error(tag, `Error fetching stable coins for ${networkId}:`, error?.message || error);
       }
-    } catch (error: any) {
-      console.error(tag, `Error fetching stable coins for ${networkId}:`, error.message);
-      // Continue with other networks even if one fails
-    }
-  }
+    })
+  );
+
+  // Optional: log aggregate failures (for diagnostics only)
+  const failures = results.filter(r => r.status === 'rejected').length;
+  if (failures > 0) console.log(tag, `Stable coin fetch had ${failures} failures (non-blocking)`);
 
   console.log(tag, `Stable coin redundancy complete. Total balances: ${balances.length}`);
 }

package/src/charts/maya.ts

@@ -45,12 +45,15 @@ export async function getMayaCharts(
 
     // Try to get MAYA token balance via a separate call
     // This is a workaround for the portfolio API not returning MAYA tokens
-    const mayaBalanceResponse = await pioneer.GetPortfolioBalances([
-      {
-        caip: 'cosmos:mayachain-mainnet-v1/denom:maya',
-        pubkey: mayaPubkey.address,
-      },
-    ]);
+    // FIX: Wrap in object with pubkeys field to match server API
+    const mayaBalanceResponse = await pioneer.GetPortfolioBalances({
+      pubkeys: [
+        {
+          caip: 'cosmos:mayachain-mainnet-v1/denom:maya',
+          pubkey: mayaPubkey.address,
+        },
+      ],
+    });
 
     console.log(
       tag,

package/src/index.ts

@@ -1678,6 +1678,47 @@ export class SDK {
         if (duplicatesRemoved > 0) {
         }
 
+        // FIX 1: Validate that all pubkeys have networks field
+        const pubkeysWithoutNetworks = this.pubkeys.filter(
+          pk => !pk.networks || !Array.isArray(pk.networks) || pk.networks.length === 0
+        );
+
+        if (pubkeysWithoutNetworks.length > 0) {
+          console.error(tag, 'ERROR: Some pubkeys missing networks field!');
+          console.error(tag, 'Affected pubkeys:', pubkeysWithoutNetworks.length);
+
+          // Log details
+          pubkeysWithoutNetworks.forEach(pk => {
+            console.error(tag, `  - ${pk.note || pk.pubkey}: networks=${pk.networks}`);
+          });
+
+          // Try to fix by matching with paths
+          for (const pubkey of pubkeysWithoutNetworks) {
+            const matchingPath = this.paths.find(p =>
+              JSON.stringify(p.addressNList) === JSON.stringify(pubkey.addressNList)
+            );
+
+            if (matchingPath && matchingPath.networks) {
+              console.warn(tag, `  ⚠️ Auto-fixing: Adding networks from path ${matchingPath.note}`);
+              pubkey.networks = matchingPath.networks;
+            }
+          }
+
+          // Check if auto-fix worked
+          const stillMissing = this.pubkeys.filter(
+            pk => !pk.networks || !Array.isArray(pk.networks) || pk.networks.length === 0
+          );
+
+          if (stillMissing.length > 0) {
+            console.error(tag, `❌ CRITICAL: ${stillMissing.length} pubkeys still missing networks after auto-fix!`);
+            stillMissing.forEach(pk => {
+              console.error(tag, `  - ${pk.note || pk.pubkey}`);
+            });
+          } else {
+            console.log(tag, `✅ Auto-fix successful: All pubkeys now have networks field`);
+          }
+        }
+
         // Emit event to notify that pubkeys have been set
         this.events.emit('SET_PUBKEYS', this.pubkeys);
 
@@ -1701,6 +1742,24 @@ export class SDK {
           throw new Error('Pioneer client not initialized. Call init() first.');
         }
 
+        // 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));
+
+        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}`);
+          });
+        }
+
         const assetQuery: { caip: string; pubkey: string }[] = [];
 
         for (const networkId of networkIds) {
@@ -1711,7 +1770,7 @@ export class SDK {
           }
 
           const isEip155 = adjustedNetworkId.includes('eip155');
-          const pubkeys = this.pubkeys.filter(
+          let pubkeys = this.pubkeys.filter(
             (pubkey) =>
               pubkey.networks &&
               Array.isArray(pubkey.networks) &&
@@ -1721,21 +1780,73 @@ export class SDK {
               }),
           );
 
+          // 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');
+
+            // 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)
+              );
+
+              if (matchingPubkey) {
+                console.warn(tag, `  ✓ Found pubkey via path matching: ${matchingPubkey.note || matchingPubkey.pubkey.slice(0, 10)}`);
+                pubkeys.push(matchingPubkey);
+              }
+            }
+
+            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}`);
+            }
+          }
+
           const caipNative = await networkIdToCaip(networkId);
           for (const pubkey of pubkeys) {
             assetQuery.push({ caip: caipNative, pubkey: pubkey.pubkey });
           }
         }
 
+        // DIAGNOSTIC: Log assetQuery before API call
+        console.log('🔍 [DIAGNOSTIC] Built assetQuery with', assetQuery.length, 'entries');
+        console.log('🔍 [DIAGNOSTIC] Sample queries:', assetQuery.slice(0, 5));
+
+        // 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`);
+        });
+
+        console.log(`⏱️  [PERF] Starting GetPortfolioBalances API call...`);
+        const apiCallStart = performance.now();
         console.time('GetPortfolioBalances Response Time');
 
         try {
-          let marketInfo = await this.pioneer.GetPortfolioBalances(assetQuery);
+          // FIX: Wrap assetQuery in object with pubkeys field to match server API
+          let marketInfo = await this.pioneer.GetPortfolioBalances({ pubkeys: assetQuery });
+          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);
             if (!assetInfo) continue;
@@ -1751,8 +1862,12 @@ export class SDK {
               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);
+          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);
@@ -1834,32 +1949,68 @@ export class SDK {
     this.getCharts = async function () {
       const tag = `${TAG} | getCharts | `;
       try {
-        console.log(tag, 'Fetching charts');
+        console.log(tag, 'Fetching charts from batch endpoint');
 
-        // Fetch balances from the `getCharts` function
-        const newBalances = await getCharts(
-          this.blockchains,
-          this.pioneer,
-          this.pubkeys,
-          this.context,
-        );
-        console.log(tag, 'newBalances: ', newBalances);
+        // Build pubkeys array for batch request
+        const pubkeysForBatch: { pubkey: string; caip: string }[] = [];
+
+        for (const pubkey of this.pubkeys) {
+          const address = pubkey.address || pubkey.master || pubkey.pubkey;
+          if (!address) continue;
+
+          // Get networks this pubkey supports
+          const supportedNetworks = pubkey.networks || [];
+
+          // For each blockchain we're processing
+          for (const blockchain of this.blockchains) {
+            // Check if this pubkey supports this blockchain
+            const supportsNetwork = supportedNetworks.some((net: string) =>
+              net === blockchain ||
+              (net.endsWith(':*') && blockchain.startsWith(net.replace(':*', ':')))
+            );
+
+            if (supportsNetwork) {
+              // Build the CAIP for this combination
+              let caip: string;
+              if (blockchain.startsWith('eip155:')) {
+                caip = `${blockchain}/slip44:60`;
+              } else {
+                caip = `${blockchain}/slip44:0`; // Fallback for non-EVM
+              }
+
+              pubkeysForBatch.push({
+                pubkey: address,
+                caip: caip
+              });
+            }
+          }
+        }
+
+        console.log(tag, `Calling batch GetCharts with ${pubkeysForBatch.length} pubkeys`);
+
+        // Single batch call to get ALL charts data
+        const chartsResponse = await this.pioneer.GetCharts({
+          pubkeys: pubkeysForBatch
+        });
+
+        const newBalances = chartsResponse?.data?.balances || [];
+        console.log(tag, `Received ${newBalances.length} balances from batch endpoint`);
 
         // Deduplicate balances using a Map with `identifier` as the key
         const uniqueBalances = new Map(
           [...this.balances, ...newBalances].map((balance: any) => [
-            balance.identifier,
+            balance.identifier || `${balance.caip}:${balance.pubkey}`,
             {
               ...balance,
               type: balance.type || 'balance',
             },
           ]),
         );
-        console.log(tag, 'uniqueBalances: ', uniqueBalances);
+        console.log(tag, 'uniqueBalances: ', uniqueBalances.size);
 
         // Convert Map back to array and set this.balances
         this.balances = Array.from(uniqueBalances.values());
-        console.log(tag, 'Updated this.balances: ', this.balances);
+        console.log(tag, 'Updated this.balances: ', this.balances.length);
 
         return this.balances;
       } catch (e) {