@pioneer-platform/pioneer-sdk 8.15.31 → 8.15.33

package/src/utils/build-dashboard.ts

@@ -23,7 +23,7 @@ export function buildDashboardFromBalances(balances: any[], blockchains: string[
     networkPercentages: [],
   };
 
-  let totalPortfolioValue = 0;
+  let totalPortfolioValueCents = 0; // Use cents for integer math
   const networksTemp: {
     networkId: string;
     totalValueUsd: number;
@@ -46,73 +46,81 @@ export function buildDashboardFromBalances(balances: any[], blockchains: string[
     });
 
     // Deduplicate balances based on caip + pubkey combination
+    // NOTE: Each pubkey (xpub/ypub/zpub) represents a DIFFERENT address space with potentially
+    // different balances - they are NOT duplicates! Keep all of them.
     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);
-      });
-
-      // 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);
-          });
-        }
+    // Standard deduplication for all networks (including Bitcoin)
+    // Only deduplicate if BOTH caip AND pubkey are identical (true duplicates)
+    filteredBalances.forEach((balance) => {
+      const key = `${balance.caip}_${balance.pubkey || 'default'}`;
+
+      // Only keep the first occurrence or the one with higher value for TRUE duplicates
+      if (
+        !balanceMap.has(key) ||
+        parseFloat(balance.valueUsd || '0') > parseFloat(balanceMap.get(key).valueUsd || '0')
+      ) {
+        balanceMap.set(key, balance);
+      } else {
+        // DEBUG: Log when we skip a balance due to deduplication
+        const existing = balanceMap.get(key);
+        const existingValue = parseFloat(existing.valueUsd || '0');
+        const newValue = parseFloat(balance.valueUsd || '0');
+
+        // Always log duplicates being skipped (removed the 0.01 threshold)
+        console.log(`⚠️  [BUILD-DASHBOARD] ${blockchain} dedup skipped (same caip+pubkey):`, {
+          caip: balance.caip,
+          pubkey: (balance.pubkey || 'default').substring(0, 20),
+          existing: existingValue,
+          new: newValue,
+          diff: Math.abs(existingValue - newValue)
+        });
       }
-    } 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 =
+    // Accumulate in cents (integer math) to avoid floating point errors
+    const networkTotalCents = networkBalances.reduce((sumCents, balance, idx) => {
+      // Normalize valueUsd to number type
+      let valueUsd =
         typeof balance.valueUsd === 'string'
           ? parseFloat(balance.valueUsd)
           : balance.valueUsd || 0;
 
+      // Check for NaN values which can cause calculation errors
+      if (isNaN(valueUsd)) {
+        console.warn(`⚠️  [BUILD-DASHBOARD] NaN value detected for ${balance.caip}:`, balance.valueUsd);
+        return sumCents;
+      }
+
+      // Normalize the balance object to always use number type for valueUsd
+      balance.valueUsd = valueUsd;
+
+      // Convert to cents with higher precision to reduce rounding errors
+      // Use Math.round with extended precision, then scale back
+      const valueCents = Math.round(valueUsd * 100 * 1000) / 1000;
+
       // Debug first few balances for each network
       if (idx < 2) {
         console.log(`💰 [BUILD-DASHBOARD] ${blockchain} balance #${idx}:`, {
           caip: balance.caip,
           balance: balance.balance,
           valueUsd: balance.valueUsd,
+          valueUsdType: typeof balance.valueUsd,
           parsedValueUsd: valueUsd,
-          runningSum: sum + valueUsd
+          valueCents: valueCents,
+          runningSumCents: sumCents + valueCents
         });
       }
 
-      return sum + valueUsd;
+      return sumCents + valueCents;
     }, 0);
 
+    // Convert back to dollars
+    const networkTotal = networkTotalCents / 100;
+
     console.log(`💰 [BUILD-DASHBOARD] ${blockchain} totals:`, {
       balancesCount: networkBalances.length,
       networkTotal,
@@ -149,9 +157,13 @@ export function buildDashboardFromBalances(balances: any[], blockchains: string[
       totalNativeBalance,
     });
 
-    totalPortfolioValue += networkTotal;
+    // Add to total using cents (integer math) to avoid floating point errors
+    totalPortfolioValueCents += networkTotalCents;
   }
 
+  // Convert total from cents to dollars
+  const totalPortfolioValue = totalPortfolioValueCents / 100;
+
   // Sort networks by USD value and assign to dashboard
   dashboardData.networks = networksTemp.sort((a, b) => b.totalValueUsd - a.totalValueUsd);
   dashboardData.totalValueUsd = totalPortfolioValue;
@@ -172,5 +184,33 @@ export function buildDashboardFromBalances(balances: any[], blockchains: string[
       dashboardData.networks.length
     } networks, $${totalPortfolioValue.toFixed(2)} total`,
   );
+
+  // ===== BALANCE RECONCILIATION CHECK =====
+  // Verify that dashboard total matches the sum of all input balances
+  const inputBalancesTotal = balances.reduce((sum, b) => {
+    const value = typeof b.valueUsd === 'string' ? parseFloat(b.valueUsd) : (b.valueUsd || 0);
+    return sum + (isNaN(value) ? 0 : value);
+  }, 0);
+
+  const difference = Math.abs(inputBalancesTotal - totalPortfolioValue);
+
+  if (difference > 0.01) {
+    console.error(`🚨 [BUILD-DASHBOARD] BALANCE MISMATCH DETECTED!`);
+    console.error(`   Input balances total:  $${inputBalancesTotal.toFixed(2)} USD`);
+    console.error(`   Dashboard total:       $${totalPortfolioValue.toFixed(2)} USD`);
+    console.error(`   Difference:            $${difference.toFixed(2)} USD`);
+    console.error(`   This indicates lost balances during dashboard aggregation!`);
+
+    // Log per-network breakdown to help debug
+    console.error(`   Network breakdown:`);
+    dashboardData.networks.forEach(network => {
+      console.error(`      ${network.networkId}: $${network.totalValueUsd.toFixed(2)}`);
+    });
+  } else if (difference > 0.001) {
+    console.warn(`⚠️  [BUILD-DASHBOARD] Minor balance rounding difference: $${difference.toFixed(4)} USD`);
+  } else {
+    console.log(`✅ [BUILD-DASHBOARD] Balance reconciliation passed (diff: $${difference.toFixed(4)})`);
+  }
+
   return dashboardData;
 }

package/src/utils/portfolio-helpers.ts

@@ -3,6 +3,100 @@
 import { logger as log } from './logger.js';
 const TAG = ' | portfolio-helpers | ';
 
+// CAIP-based explorer URL mapping
+const EXPLORER_BASE_URLS: Record<string, { address: string; tx: string }> = {
+  // Ethereum mainnet
+  'eip155:1': {
+    address: 'https://etherscan.io/address/',
+    tx: 'https://etherscan.io/tx/'
+  },
+  // Polygon
+  'eip155:137': {
+    address: 'https://polygonscan.com/address/',
+    tx: 'https://polygonscan.com/tx/'
+  },
+  // Base
+  'eip155:8453': {
+    address: 'https://basescan.org/address/',
+    tx: 'https://basescan.org/tx/'
+  },
+  // BSC
+  'eip155:56': {
+    address: 'https://bscscan.com/address/',
+    tx: 'https://bscscan.com/tx/'
+  },
+  // Monad
+  'eip155:41454': {
+    address: 'https://explorer.monad.xyz/address/',
+    tx: 'https://explorer.monad.xyz/tx/'
+  },
+  // Hyperliquid
+  'eip155:2868': {
+    address: 'https://app.hyperliquid.xyz/explorer/address/',
+    tx: 'https://app.hyperliquid.xyz/explorer/tx/'
+  },
+  // Bitcoin
+  'bip122:000000000019d6689c085ae165831e93': {
+    address: 'https://blockstream.info/address/',
+    tx: 'https://blockstream.info/tx/'
+  },
+  // Litecoin
+  'bip122:12a765e31ffd4059bada1e25190f6e98': {
+    address: 'https://blockchair.com/litecoin/address/',
+    tx: 'https://blockchair.com/litecoin/transaction/'
+  },
+  // Dogecoin
+  'bip122:00000000001a91e3dace36e2be3bf030': {
+    address: 'https://dogechain.info/address/',
+    tx: 'https://dogechain.info/tx/'
+  },
+  // Bitcoin Cash
+  'bip122:000000000000000000651ef99cb9fcbe': {
+    address: 'https://blockchair.com/bitcoin-cash/address/',
+    tx: 'https://blockchair.com/bitcoin-cash/transaction/'
+  },
+  // Dash
+  'bip122:000007d91d1254d60e2dd1ae58038307': {
+    address: 'https://chainz.cryptoid.info/dash/address.dws?',
+    tx: 'https://chainz.cryptoid.info/dash/tx.dws?'
+  },
+  // DigiByte
+  'bip122:4da631f2ac1bed857bd968c67c913978': {
+    address: 'https://digiexplorer.info/address/',
+    tx: 'https://digiexplorer.info/tx/'
+  },
+  // Zcash
+  'bip122:00040fe8ec8471911baa1db1266ea15d': {
+    address: 'https://explorer.zcha.in/accounts/',
+    tx: 'https://explorer.zcha.in/transactions/'
+  },
+  // Cosmos Hub
+  'cosmos:cosmoshub-4': {
+    address: 'https://www.mintscan.io/cosmos/address/',
+    tx: 'https://www.mintscan.io/cosmos/tx/'
+  },
+  // Osmosis
+  'cosmos:osmosis-1': {
+    address: 'https://www.mintscan.io/osmosis/address/',
+    tx: 'https://www.mintscan.io/osmosis/tx/'
+  },
+  // THORChain
+  'cosmos:thorchain-mainnet-v1': {
+    address: 'https://thorchain.net/address/',
+    tx: 'https://thorchain.net/tx/'
+  },
+  // Maya Protocol
+  'cosmos:mayachain-mainnet-v1': {
+    address: 'https://www.mayascan.org/address/',
+    tx: 'https://www.mayascan.org/tx/'
+  },
+  // Ripple
+  'ripple:4109c6f2045fc7eff4cde8f9905d19c2': {
+    address: 'https://xrpscan.com/account/',
+    tx: 'https://xrpscan.com/tx/'
+  }
+};
+
 export function isCacheDataValid(portfolioData: any): boolean {
   // Check if networks data is reasonable (should be < 50 networks, not thousands)
   if (!portfolioData.networks || !Array.isArray(portfolioData.networks)) {
@@ -220,14 +314,54 @@ export function enrichBalancesWithAssetInfo(
       continue;
     }
 
+    // ===== CRITICAL: Normalize valueUsd to NUMBER type =====
+    // Ensures consistent type throughout the SDK to prevent calculation errors
+    if (typeof balance.valueUsd === 'string') {
+      balance.valueUsd = parseFloat(balance.valueUsd) || 0;
+    } else if (typeof balance.valueUsd !== 'number') {
+      balance.valueUsd = 0;
+    }
+
+    // Also normalize balance amount to number
+    if (typeof balance.balance === 'string') {
+      balance.balance = balance.balance; // Keep as string for precision (e.g., "0.00000001")
+    }
+
+    // Normalize priceUsd to number as well
+    if (typeof balance.priceUsd === 'string') {
+      balance.priceUsd = parseFloat(balance.priceUsd) || 0;
+    } else if (typeof balance.priceUsd !== 'number') {
+      balance.priceUsd = 0;
+    }
+
+    // Get networkId for explorer lookup
+    const networkId = caipToNetworkId(balance.caip);
+    const explorerUrls = EXPLORER_BASE_URLS[networkId];
+
+    // Generate explorer links if we have a pubkey/address and explorer URLs for this network
+    const explorerAddressLink = (explorerUrls && balance.pubkey)
+      ? explorerUrls.address + balance.pubkey
+      : undefined;
+
+    const explorerTxLink = explorerUrls?.tx; // Base URL for txs, actual txid added later
+
     Object.assign(balance, assetInfo, {
       type: balance.type || assetInfo.type,
       isNative: balance.isNative ?? assetInfo.isNative,
-      networkId: caipToNetworkId(balance.caip),
+      networkId,
       icon: assetInfo.icon || 'https://pioneers.dev/coins/etherum.png',
       identifier: `${balance.caip}:${balance.pubkey}`,
       updated: Date.now(),
       color: assetInfo.color,
+      // CRITICAL: Always use decimals from assetInfo if available
+      decimals: assetInfo.decimals || balance.decimals || 8,
+      // Add explorer links
+      explorerAddressLink,
+      explorerTxLink,
+      explorer: explorerUrls?.address, // Base explorer URL
+      // Ensure these are numbers (redundant but explicit)
+      valueUsd: balance.valueUsd,
+      priceUsd: balance.priceUsd,
     });
 
     enrichedBalances.push(balance);