@pioneer-platform/pioneer-sdk 4.20.4 → 4.20.6

package/package.json

@@ -1,12 +1,12 @@
 {
   "author": "highlander",
   "name": "@pioneer-platform/pioneer-sdk",
-  "version": "4.20.4",
+  "version": "4.20.6",
   "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.1",
+    "@pioneer-platform/pioneer-client": "^9.10.2",
     "@pioneer-platform/pioneer-coins": "^9.11.0",
     "@pioneer-platform/pioneer-discovery": "^0.8.0",
     "@pioneer-platform/pioneer-events": "^8.11.0",
@@ -48,6 +48,8 @@
   },
   "react-native": "./src/index.ts",
   "repository": "https://github.com/thorswap/SwapKit.git",
+  "type": "module",
+  "types": "./dist/index.d.ts",
   "scripts": {
     "build": "bash scripts/build.sh",
     "build:watch": "nodemon --watch src --exec 'bun run build'",
@@ -55,7 +57,5 @@
     "lint": "eslint ./ --ext .ts,.tsx --fix; tsc --noEmit",
     "test": "echo 'vitest --run'",
     "test:coverage": "echo 'vitest run --coverage'"
-  },
-  "type": "module",
-  "types": "./dist/index.d.ts"
-}
+  }
+}

package/src/index.ts

@@ -45,18 +45,6 @@ export interface PioneerSDKConfig {
   forceLocalhost?: boolean;
 }
 
-// Helper function to format time differences
-function formatTime(durationMs) {
-  let seconds = Math.floor((durationMs / 1000) % 60);
-  let minutes = Math.floor((durationMs / (1000 * 60)) % 60);
-  let hours = Math.floor((durationMs / (1000 * 60 * 60)) % 24);
-
-  let formatted = '';
-  if (hours > 0) formatted += `${hours}h `;
-  if (minutes > 0 || hours > 0) formatted += `${minutes}m `;
-  formatted += `${seconds}s`;
-  return formatted.trim();
-}
 
 export class SDK {
   public status: string;
@@ -582,181 +570,7 @@ export class SDK {
     };
     // Build dashboard from cached balances (no Pioneer API calls)
     this.buildDashboardFromBalances = function () {
-      const tag = `${TAG} | buildDashboardFromBalances | `;
-      console.log(tag, '[DASHBOARD] Building dashboard from cached balances...');
-
-      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: [],
-      };
-
-      let totalPortfolioValue = 0;
-      const networksTemp: {
-        networkId: string;
-        totalValueUsd: number;
-        gasAssetCaip: string | null;
-        gasAssetSymbol: string | null;
-        icon: string | null;
-        color: string | null;
-        totalNativeBalance: string;
-      }[] = [];
-
-      console.log(tag, 'this.balances: ', this.balances);
-
-      // Calculate totals for each blockchain
-      for (const blockchain of this.blockchains) {
-        const filteredBalances = this.balances.filter((b) => {
-          const networkId = caipToNetworkId(b.caip);
-          return (
-            networkId === blockchain ||
-            (blockchain === 'eip155:*' && networkId.startsWith('eip155:'))
-          );
-        });
-
-        // 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) {
-          console.log(tag, 'Bitcoin network detected - checking for duplicate balances');
-          // 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);
-          });
-
-          // 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) {
-              console.log(
-                tag,
-                'BITCOIN API BUG DETECTED: All 3 address types have same balance, keeping only xpub',
-              );
-              // 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);
-            }
-          });
-        }
-
-        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;
-
-          if (blockchain.includes('bip122:000000000019d6689c085ae165831e93')) {
-            console.log(
-              tag,
-              `[BITCOIN DEBUG ${idx}] pubkey:`,
-              balance.pubkey?.substring(0, 10) + '...',
-              '| balance:',
-              balance.balance,
-              '| valueUsd:',
-              balance.valueUsd,
-              '→ parsed:',
-              valueUsd,
-              '| running sum:',
-              sum + valueUsd,
-            );
-          }
-
-          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();
-
-        // Get colors from assetMap since balances don't have them
-        const assetInfo = nativeAssetCaip ? this.assetsMap.get(nativeAssetCaip) : null;
-
-        networksTemp.push({
-          networkId: blockchain,
-          totalValueUsd: networkTotal,
-          gasAssetCaip: nativeAssetCaip || null,
-          gasAssetSymbol: gasAsset?.ticker || gasAsset?.symbol || assetInfo?.symbol || null,
-          icon: gasAsset?.icon || assetInfo?.icon || null,
-          color: gasAsset?.color || assetInfo?.color || null,
-          totalNativeBalance,
-        });
-
-        totalPortfolioValue += networkTotal;
-      }
-
-      // 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(
-        `[FAST DASHBOARD] ✅ Built dashboard: ${
-          dashboardData.networks.length
-        } networks, $${totalPortfolioValue.toFixed(2)} total`,
-      );
-      return dashboardData;
+      return buildDashboardFromBalances(this.balances, this.blockchains, this.assetsMap);
     };
 
     this.syncMarket = async function () {

package/src/utils/sync-portfolio.ts

@@ -0,0 +1,100 @@
+// Portfolio synchronization logic
+import { getPaths } from '@pioneer-platform/pioneer-coins';
+
+const TAG = ' | sync-portfolio | ';
+
+export async function syncPortfolio(context: {
+  blockchains: string[];
+  paths: any[];
+  pubkeys: any[];
+  balances: any[];
+  pioneer: any;
+  getPubkeys: () => Promise<any[]>;
+  getBalances: () => Promise<any[]>;
+  events: any;
+}) {
+  const tag = `${TAG} | syncPortfolio | `;
+  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;
+    };
+
+    //at least 1 path per chain
+    await context.getPubkeys();
+    for (let i = 0; i < context.blockchains.length; i++) {
+      let networkId = context.blockchains[i];
+      if (networkId.indexOf('eip155:') >= 0) networkId = 'eip155:*';
+
+      let paths = context.paths.filter((path) => matchesNetwork(path, networkId));
+      if (paths.length === 0) {
+        //get paths for chain
+        const pathsForChain = getPaths([networkId]);
+        console.log(tag, 'pathsForChain: ', pathsForChain);
+        for (let j = 0; j < pathsForChain.length; j++) {
+          const path = pathsForChain[j];
+          if (!context.paths.find((p) => p.note === path.note)) {
+            context.paths.push(path);
+          }
+        }
+      }
+    }
+
+    //get balances for paths
+    await context.getPubkeys();
+    console.log(tag, 'context.pubkeys: ', context.pubkeys);
+    await context.getBalances();
+
+    // Get market data with cache support
+    let allCaips = context.balances
+      .filter((b) => b && b.caip && typeof b.caip === 'string' && b.caip.trim().length > 0)
+      .map((b) => b.caip);
+
+    // Remove duplicates
+    allCaips = [...new Set(allCaips)];
+
+    // CRITICAL: Double-check all elements are valid strings after Set deduplication
+    allCaips = allCaips.filter(
+      (caip) =>
+        caip &&
+        typeof caip === 'string' &&
+        caip.trim().length > 0 &&
+        caip.includes(':'), // CAIP format always has a colon
+    );
+
+    if (allCaips && allCaips.length > 0) {
+      try {
+        let allPrices = await context.pioneer.GetMarketInfo(allCaips);
+
+        // Create a map of CAIP to price for easier lookup
+        const priceMap = {};
+        if (allPrices && allPrices.data) {
+          for (let i = 0; i < allCaips.length && i < allPrices.data.length; i++) {
+            priceMap[allCaips[i]] = allPrices.data[i];
+          }
+        }
+
+        // Update each balance with the corresponding price and value
+        for (let balance of context.balances) {
+          if (balance && balance.caip && priceMap[balance.caip] !== undefined) {
+            balance.price = priceMap[balance.caip];
+            balance.priceUsd = priceMap[balance.caip];
+            balance.valueUsd = balance.price * (balance.balance || 0);
+          }
+        }
+      } catch (apiError) {
+        console.error(tag, 'API error fetching market info:', apiError);
+        console.warn(tag, 'Continuing without market prices');
+      }
+    }
+
+    context.events.emit('BALANCES_UPDATED', context.balances);
+    return true;
+  } catch (e) {
+    console.error(tag, 'e: ', e);
+    throw e;
+  }
+}