@pioneer-platform/pioneer-sdk 8.15.31 → 8.15.32

package/dist/index.cjs

@@ -2639,7 +2639,21 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
         }
       } catch (error) {
         console.error(`${tag}: Failed to get fee rates from Pioneer API:`, error.message || error);
-        throw new Error(`Unable to get fee rate for network ${networkId}: ${error.message || "API unavailable"}`);
+        const defaultFees = {
+          "bip122:000000000019d6689c085ae165831e93": { slow: 3, average: 5, fast: 10, fastest: 15 },
+          "bip122:12a765e31ffd4059bada1e25190f6e98": { slow: 2, average: 3, fast: 5, fastest: 10 },
+          "bip122:00000000001a91e3dace36e2be3bf030": { slow: 1, average: 1, fast: 2, fastest: 3 },
+          "bip122:000000000000000000651ef99cb9fcbe": { slow: 1, average: 1, fast: 2, fastest: 3 },
+          "bip122:000007d91d1254d60e2dd1ae58038307": { slow: 1, average: 1, fast: 2, fastest: 3 },
+          "bip122:4da631f2ac1bed857bd968c67c913978": { slow: 75, average: 80, fast: 100, fastest: 120 },
+          "bip122:00040fe8ec8471911baa1db1266ea15d": { slow: 1, average: 1, fast: 2, fastest: 3 }
+        };
+        if (defaultFees[networkId]) {
+          console.warn(`${tag}: Using default fee rates for ${networkId}`);
+          feeRateFromNode = defaultFees[networkId];
+        } else {
+          throw new Error(`Unable to get fee rate for network ${networkId}: ${error.message || "API unavailable"}`);
+        }
       }
     }
     let effectiveFeeRate;
@@ -3355,6 +3369,7 @@ function getNetworkName(networkId) {
     "bip122:00000000001a91e3dace36e2be3bf030": "Dogecoin",
     "bip122:000000000000000000651ef99cb9fcbe": "Bitcoin Cash",
     "bip122:000007d91d1254d60e2dd1ae58038307": "Dash",
+    "bip122:00040fe8ec8471911baa1db1266ea15d": "Zcash",
     "bip122:4da631f2ac1bed857bd968c67c913978": "DigiByte",
     "eip155:1": "Ethereum",
     "eip155:56": "BNB Smart Chain",
@@ -3926,7 +3941,7 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
     totalValueUsd: 0,
     networkPercentages: []
   };
-  let totalPortfolioValue = 0;
+  let totalPortfolioValueCents = 0;
   const networksTemp = [];
   for (const blockchain of blockchains) {
     const filteredBalances = balances.filter((b) => {
@@ -3934,50 +3949,46 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
       return networkId === blockchain || blockchain === "eip155:*" && networkId.startsWith("eip155:");
     });
     const balanceMap = new Map;
-    const isBitcoin = blockchain.includes("bip122:000000000019d6689c085ae165831e93");
-    if (isBitcoin) {
-      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);
-      });
-      for (const [valueKey, balances2] of bitcoinByValue.entries()) {
-        if (balances2.length === 3 && parseFloat(balances2[0].valueUsd || "0") > 0) {
-          const xpubBalance = balances2.find((b) => b.pubkey?.startsWith("xpub")) || balances2[0];
-          const key = `${xpubBalance.caip}_${xpubBalance.pubkey || "default"}`;
-          balanceMap.set(key, xpubBalance);
-        } else {
-          balances2.forEach((balance) => {
-            const key = `${balance.caip}_${balance.pubkey || "default"}`;
-            balanceMap.set(key, balance);
-          });
-        }
+    filteredBalances.forEach((balance) => {
+      const key = `${balance.caip}_${balance.pubkey || "default"}`;
+      if (!balanceMap.has(key) || parseFloat(balance.valueUsd || "0") > parseFloat(balanceMap.get(key).valueUsd || "0")) {
+        balanceMap.set(key, balance);
+      } else {
+        const existing = balanceMap.get(key);
+        const existingValue = parseFloat(existing.valueUsd || "0");
+        const newValue = parseFloat(balance.valueUsd || "0");
+        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 {
-      filteredBalances.forEach((balance) => {
-        const key = `${balance.caip}_${balance.pubkey || "default"}`;
-        if (!balanceMap.has(key) || parseFloat(balance.valueUsd || "0") > parseFloat(balanceMap.get(key).valueUsd || "0")) {
-          balanceMap.set(key, balance);
-        }
-      });
-    }
+    });
     const networkBalances = Array.from(balanceMap.values());
-    const networkTotal = networkBalances.reduce((sum, balance, idx) => {
-      const valueUsd = typeof balance.valueUsd === "string" ? parseFloat(balance.valueUsd) : balance.valueUsd || 0;
+    const networkTotalCents = networkBalances.reduce((sumCents, balance, idx) => {
+      let valueUsd = typeof balance.valueUsd === "string" ? parseFloat(balance.valueUsd) : balance.valueUsd || 0;
+      if (isNaN(valueUsd)) {
+        console.warn(`⚠️  [BUILD-DASHBOARD] NaN value detected for ${balance.caip}:`, balance.valueUsd);
+        return sumCents;
+      }
+      balance.valueUsd = valueUsd;
+      const valueCents = Math.round(valueUsd * 100 * 1000) / 1000;
       if (idx < 2) {
         console.log(`\uD83D\uDCB0 [BUILD-DASHBOARD] ${blockchain} balance #${idx}:`, {
           caip: balance.caip,
           balance: balance.balance,
           valueUsd: balance.valueUsd,
+          valueUsdType: typeof balance.valueUsd,
           parsedValueUsd: valueUsd,
-          runningSum: sum + valueUsd
+          valueCents,
+          runningSumCents: sumCents + valueCents
         });
       }
-      return sum + valueUsd;
+      return sumCents + valueCents;
     }, 0);
+    const networkTotal = networkTotalCents / 100;
     console.log(`\uD83D\uDCB0 [BUILD-DASHBOARD] ${blockchain} totals:`, {
       balancesCount: networkBalances.length,
       networkTotal,
@@ -4000,8 +4011,9 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
       color: gasAsset?.color || assetInfo?.color || null,
       totalNativeBalance
     });
-    totalPortfolioValue += networkTotal;
+    totalPortfolioValueCents += networkTotalCents;
   }
+  const totalPortfolioValue = totalPortfolioValueCents / 100;
   dashboardData.networks = networksTemp.sort((a, b) => b.totalValueUsd - a.totalValueUsd);
   dashboardData.totalValueUsd = totalPortfolioValue;
   dashboardData.networkPercentages = dashboardData.networks.map((network) => ({
@@ -4009,6 +4021,26 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
     percentage: totalPortfolioValue > 0 ? Number((network.totalValueUsd / totalPortfolioValue * 100).toFixed(2)) : 0
   })).filter((entry) => entry.percentage > 0);
   console.log(`[FAST DASHBOARD] ✅ Built dashboard: ${dashboardData.networks.length} networks, $${totalPortfolioValue.toFixed(2)} total`);
+  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(`\uD83D\uDEA8 [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!`);
+    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;
 }
 
@@ -4281,6 +4313,19 @@ function enrichBalancesWithAssetInfo(balances, assetsMap, caipToNetworkId7) {
       console.warn(tag, `Missing AssetInfo for CAIP: "${balance.caip}" - skipping this balance`);
       continue;
     }
+    if (typeof balance.valueUsd === "string") {
+      balance.valueUsd = parseFloat(balance.valueUsd) || 0;
+    } else if (typeof balance.valueUsd !== "number") {
+      balance.valueUsd = 0;
+    }
+    if (typeof balance.balance === "string") {
+      balance.balance = balance.balance;
+    }
+    if (typeof balance.priceUsd === "string") {
+      balance.priceUsd = parseFloat(balance.priceUsd) || 0;
+    } else if (typeof balance.priceUsd !== "number") {
+      balance.priceUsd = 0;
+    }
     Object.assign(balance, assetInfo, {
       type: balance.type || assetInfo.type,
       isNative: balance.isNative ?? assetInfo.isNative,
@@ -4288,7 +4333,9 @@ function enrichBalancesWithAssetInfo(balances, assetsMap, caipToNetworkId7) {
       icon: assetInfo.icon || "https://pioneers.dev/coins/etherum.png",
       identifier: `${balance.caip}:${balance.pubkey}`,
       updated: Date.now(),
-      color: assetInfo.color
+      color: assetInfo.color,
+      valueUsd: balance.valueUsd,
+      priceUsd: balance.priceUsd
     });
     enrichedBalances.push(balance);
   }
@@ -4823,6 +4870,20 @@ class SDK {
               this.balances[index] = balance;
             }
             this.events.emit("BALANCE_UPDATE", balance);
+            console.log(tag7, "\uD83D\uDD04 Rebuilding dashboard after balance update...");
+            const previousTotal = this.dashboard?.totalValueUsd || 0;
+            this.dashboard = this.buildDashboardFromBalances();
+            const newTotal = this.dashboard?.totalValueUsd || 0;
+            if (Math.abs(newTotal - previousTotal) > 0.01) {
+              console.log(tag7, `\uD83D\uDCB0 Portfolio value changed: $${previousTotal.toFixed(2)} → $${newTotal.toFixed(2)}`);
+            }
+            this.events.emit("DASHBOARD_UPDATE", {
+              dashboard: this.dashboard,
+              trigger: "balance_update",
+              affectedAsset: balance.caip,
+              previousTotal,
+              newTotal
+            });
           } catch (e) {
             console.error(tag7, "Error processing balance update:", e);
           }

package/dist/index.es.js

@@ -2823,7 +2823,21 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
         }
       } catch (error) {
         console.error(`${tag}: Failed to get fee rates from Pioneer API:`, error.message || error);
-        throw new Error(`Unable to get fee rate for network ${networkId}: ${error.message || "API unavailable"}`);
+        const defaultFees = {
+          "bip122:000000000019d6689c085ae165831e93": { slow: 3, average: 5, fast: 10, fastest: 15 },
+          "bip122:12a765e31ffd4059bada1e25190f6e98": { slow: 2, average: 3, fast: 5, fastest: 10 },
+          "bip122:00000000001a91e3dace36e2be3bf030": { slow: 1, average: 1, fast: 2, fastest: 3 },
+          "bip122:000000000000000000651ef99cb9fcbe": { slow: 1, average: 1, fast: 2, fastest: 3 },
+          "bip122:000007d91d1254d60e2dd1ae58038307": { slow: 1, average: 1, fast: 2, fastest: 3 },
+          "bip122:4da631f2ac1bed857bd968c67c913978": { slow: 75, average: 80, fast: 100, fastest: 120 },
+          "bip122:00040fe8ec8471911baa1db1266ea15d": { slow: 1, average: 1, fast: 2, fastest: 3 }
+        };
+        if (defaultFees[networkId]) {
+          console.warn(`${tag}: Using default fee rates for ${networkId}`);
+          feeRateFromNode = defaultFees[networkId];
+        } else {
+          throw new Error(`Unable to get fee rate for network ${networkId}: ${error.message || "API unavailable"}`);
+        }
       }
     }
     let effectiveFeeRate;
@@ -3539,6 +3553,7 @@ function getNetworkName(networkId) {
     "bip122:00000000001a91e3dace36e2be3bf030": "Dogecoin",
     "bip122:000000000000000000651ef99cb9fcbe": "Bitcoin Cash",
     "bip122:000007d91d1254d60e2dd1ae58038307": "Dash",
+    "bip122:00040fe8ec8471911baa1db1266ea15d": "Zcash",
     "bip122:4da631f2ac1bed857bd968c67c913978": "DigiByte",
     "eip155:1": "Ethereum",
     "eip155:56": "BNB Smart Chain",
@@ -4110,7 +4125,7 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
     totalValueUsd: 0,
     networkPercentages: []
   };
-  let totalPortfolioValue = 0;
+  let totalPortfolioValueCents = 0;
   const networksTemp = [];
   for (const blockchain of blockchains) {
     const filteredBalances = balances.filter((b2) => {
@@ -4118,50 +4133,46 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
       return networkId === blockchain || blockchain === "eip155:*" && networkId.startsWith("eip155:");
     });
     const balanceMap = new Map;
-    const isBitcoin = blockchain.includes("bip122:000000000019d6689c085ae165831e93");
-    if (isBitcoin) {
-      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);
-      });
-      for (const [valueKey, balances2] of bitcoinByValue.entries()) {
-        if (balances2.length === 3 && parseFloat(balances2[0].valueUsd || "0") > 0) {
-          const xpubBalance = balances2.find((b2) => b2.pubkey?.startsWith("xpub")) || balances2[0];
-          const key = `${xpubBalance.caip}_${xpubBalance.pubkey || "default"}`;
-          balanceMap.set(key, xpubBalance);
-        } else {
-          balances2.forEach((balance) => {
-            const key = `${balance.caip}_${balance.pubkey || "default"}`;
-            balanceMap.set(key, balance);
-          });
-        }
+    filteredBalances.forEach((balance) => {
+      const key = `${balance.caip}_${balance.pubkey || "default"}`;
+      if (!balanceMap.has(key) || parseFloat(balance.valueUsd || "0") > parseFloat(balanceMap.get(key).valueUsd || "0")) {
+        balanceMap.set(key, balance);
+      } else {
+        const existing = balanceMap.get(key);
+        const existingValue = parseFloat(existing.valueUsd || "0");
+        const newValue = parseFloat(balance.valueUsd || "0");
+        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 {
-      filteredBalances.forEach((balance) => {
-        const key = `${balance.caip}_${balance.pubkey || "default"}`;
-        if (!balanceMap.has(key) || parseFloat(balance.valueUsd || "0") > parseFloat(balanceMap.get(key).valueUsd || "0")) {
-          balanceMap.set(key, balance);
-        }
-      });
-    }
+    });
     const networkBalances = Array.from(balanceMap.values());
-    const networkTotal = networkBalances.reduce((sum, balance, idx) => {
-      const valueUsd = typeof balance.valueUsd === "string" ? parseFloat(balance.valueUsd) : balance.valueUsd || 0;
+    const networkTotalCents = networkBalances.reduce((sumCents, balance, idx) => {
+      let valueUsd = typeof balance.valueUsd === "string" ? parseFloat(balance.valueUsd) : balance.valueUsd || 0;
+      if (isNaN(valueUsd)) {
+        console.warn(`⚠️  [BUILD-DASHBOARD] NaN value detected for ${balance.caip}:`, balance.valueUsd);
+        return sumCents;
+      }
+      balance.valueUsd = valueUsd;
+      const valueCents = Math.round(valueUsd * 100 * 1000) / 1000;
       if (idx < 2) {
         console.log(`\uD83D\uDCB0 [BUILD-DASHBOARD] ${blockchain} balance #${idx}:`, {
           caip: balance.caip,
           balance: balance.balance,
           valueUsd: balance.valueUsd,
+          valueUsdType: typeof balance.valueUsd,
           parsedValueUsd: valueUsd,
-          runningSum: sum + valueUsd
+          valueCents,
+          runningSumCents: sumCents + valueCents
         });
       }
-      return sum + valueUsd;
+      return sumCents + valueCents;
     }, 0);
+    const networkTotal = networkTotalCents / 100;
     console.log(`\uD83D\uDCB0 [BUILD-DASHBOARD] ${blockchain} totals:`, {
       balancesCount: networkBalances.length,
       networkTotal,
@@ -4184,8 +4195,9 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
       color: gasAsset?.color || assetInfo?.color || null,
       totalNativeBalance
     });
-    totalPortfolioValue += networkTotal;
+    totalPortfolioValueCents += networkTotalCents;
   }
+  const totalPortfolioValue = totalPortfolioValueCents / 100;
   dashboardData.networks = networksTemp.sort((a2, b2) => b2.totalValueUsd - a2.totalValueUsd);
   dashboardData.totalValueUsd = totalPortfolioValue;
   dashboardData.networkPercentages = dashboardData.networks.map((network) => ({
@@ -4193,6 +4205,26 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
     percentage: totalPortfolioValue > 0 ? Number((network.totalValueUsd / totalPortfolioValue * 100).toFixed(2)) : 0
   })).filter((entry) => entry.percentage > 0);
   console.log(`[FAST DASHBOARD] ✅ Built dashboard: ${dashboardData.networks.length} networks, $${totalPortfolioValue.toFixed(2)} total`);
+  const inputBalancesTotal = balances.reduce((sum, b2) => {
+    const value = typeof b2.valueUsd === "string" ? parseFloat(b2.valueUsd) : b2.valueUsd || 0;
+    return sum + (isNaN(value) ? 0 : value);
+  }, 0);
+  const difference = Math.abs(inputBalancesTotal - totalPortfolioValue);
+  if (difference > 0.01) {
+    console.error(`\uD83D\uDEA8 [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!`);
+    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;
 }
 
@@ -4465,6 +4497,19 @@ function enrichBalancesWithAssetInfo(balances, assetsMap, caipToNetworkId7) {
       console.warn(tag, `Missing AssetInfo for CAIP: "${balance.caip}" - skipping this balance`);
       continue;
     }
+    if (typeof balance.valueUsd === "string") {
+      balance.valueUsd = parseFloat(balance.valueUsd) || 0;
+    } else if (typeof balance.valueUsd !== "number") {
+      balance.valueUsd = 0;
+    }
+    if (typeof balance.balance === "string") {
+      balance.balance = balance.balance;
+    }
+    if (typeof balance.priceUsd === "string") {
+      balance.priceUsd = parseFloat(balance.priceUsd) || 0;
+    } else if (typeof balance.priceUsd !== "number") {
+      balance.priceUsd = 0;
+    }
     Object.assign(balance, assetInfo, {
       type: balance.type || assetInfo.type,
       isNative: balance.isNative ?? assetInfo.isNative,
@@ -4472,7 +4517,9 @@ function enrichBalancesWithAssetInfo(balances, assetsMap, caipToNetworkId7) {
       icon: assetInfo.icon || "https://pioneers.dev/coins/etherum.png",
       identifier: `${balance.caip}:${balance.pubkey}`,
       updated: Date.now(),
-      color: assetInfo.color
+      color: assetInfo.color,
+      valueUsd: balance.valueUsd,
+      priceUsd: balance.priceUsd
     });
     enrichedBalances.push(balance);
   }
@@ -5007,6 +5054,20 @@ class SDK {
               this.balances[index] = balance;
             }
             this.events.emit("BALANCE_UPDATE", balance);
+            console.log(tag7, "\uD83D\uDD04 Rebuilding dashboard after balance update...");
+            const previousTotal = this.dashboard?.totalValueUsd || 0;
+            this.dashboard = this.buildDashboardFromBalances();
+            const newTotal = this.dashboard?.totalValueUsd || 0;
+            if (Math.abs(newTotal - previousTotal) > 0.01) {
+              console.log(tag7, `\uD83D\uDCB0 Portfolio value changed: $${previousTotal.toFixed(2)} → $${newTotal.toFixed(2)}`);
+            }
+            this.events.emit("DASHBOARD_UPDATE", {
+              dashboard: this.dashboard,
+              trigger: "balance_update",
+              affectedAsset: balance.caip,
+              previousTotal,
+              newTotal
+            });
           } catch (e) {
             console.error(tag7, "Error processing balance update:", e);
           }

package/dist/index.js

@@ -2823,7 +2823,21 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
         }
       } catch (error) {
         console.error(`${tag}: Failed to get fee rates from Pioneer API:`, error.message || error);
-        throw new Error(`Unable to get fee rate for network ${networkId}: ${error.message || "API unavailable"}`);
+        const defaultFees = {
+          "bip122:000000000019d6689c085ae165831e93": { slow: 3, average: 5, fast: 10, fastest: 15 },
+          "bip122:12a765e31ffd4059bada1e25190f6e98": { slow: 2, average: 3, fast: 5, fastest: 10 },
+          "bip122:00000000001a91e3dace36e2be3bf030": { slow: 1, average: 1, fast: 2, fastest: 3 },
+          "bip122:000000000000000000651ef99cb9fcbe": { slow: 1, average: 1, fast: 2, fastest: 3 },
+          "bip122:000007d91d1254d60e2dd1ae58038307": { slow: 1, average: 1, fast: 2, fastest: 3 },
+          "bip122:4da631f2ac1bed857bd968c67c913978": { slow: 75, average: 80, fast: 100, fastest: 120 },
+          "bip122:00040fe8ec8471911baa1db1266ea15d": { slow: 1, average: 1, fast: 2, fastest: 3 }
+        };
+        if (defaultFees[networkId]) {
+          console.warn(`${tag}: Using default fee rates for ${networkId}`);
+          feeRateFromNode = defaultFees[networkId];
+        } else {
+          throw new Error(`Unable to get fee rate for network ${networkId}: ${error.message || "API unavailable"}`);
+        }
       }
     }
     let effectiveFeeRate;
@@ -3539,6 +3553,7 @@ function getNetworkName(networkId) {
     "bip122:00000000001a91e3dace36e2be3bf030": "Dogecoin",
     "bip122:000000000000000000651ef99cb9fcbe": "Bitcoin Cash",
     "bip122:000007d91d1254d60e2dd1ae58038307": "Dash",
+    "bip122:00040fe8ec8471911baa1db1266ea15d": "Zcash",
     "bip122:4da631f2ac1bed857bd968c67c913978": "DigiByte",
     "eip155:1": "Ethereum",
     "eip155:56": "BNB Smart Chain",
@@ -4110,7 +4125,7 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
     totalValueUsd: 0,
     networkPercentages: []
   };
-  let totalPortfolioValue = 0;
+  let totalPortfolioValueCents = 0;
   const networksTemp = [];
   for (const blockchain of blockchains) {
     const filteredBalances = balances.filter((b2) => {
@@ -4118,50 +4133,46 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
       return networkId === blockchain || blockchain === "eip155:*" && networkId.startsWith("eip155:");
     });
     const balanceMap = new Map;
-    const isBitcoin = blockchain.includes("bip122:000000000019d6689c085ae165831e93");
-    if (isBitcoin) {
-      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);
-      });
-      for (const [valueKey, balances2] of bitcoinByValue.entries()) {
-        if (balances2.length === 3 && parseFloat(balances2[0].valueUsd || "0") > 0) {
-          const xpubBalance = balances2.find((b2) => b2.pubkey?.startsWith("xpub")) || balances2[0];
-          const key = `${xpubBalance.caip}_${xpubBalance.pubkey || "default"}`;
-          balanceMap.set(key, xpubBalance);
-        } else {
-          balances2.forEach((balance) => {
-            const key = `${balance.caip}_${balance.pubkey || "default"}`;
-            balanceMap.set(key, balance);
-          });
-        }
+    filteredBalances.forEach((balance) => {
+      const key = `${balance.caip}_${balance.pubkey || "default"}`;
+      if (!balanceMap.has(key) || parseFloat(balance.valueUsd || "0") > parseFloat(balanceMap.get(key).valueUsd || "0")) {
+        balanceMap.set(key, balance);
+      } else {
+        const existing = balanceMap.get(key);
+        const existingValue = parseFloat(existing.valueUsd || "0");
+        const newValue = parseFloat(balance.valueUsd || "0");
+        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 {
-      filteredBalances.forEach((balance) => {
-        const key = `${balance.caip}_${balance.pubkey || "default"}`;
-        if (!balanceMap.has(key) || parseFloat(balance.valueUsd || "0") > parseFloat(balanceMap.get(key).valueUsd || "0")) {
-          balanceMap.set(key, balance);
-        }
-      });
-    }
+    });
     const networkBalances = Array.from(balanceMap.values());
-    const networkTotal = networkBalances.reduce((sum, balance, idx) => {
-      const valueUsd = typeof balance.valueUsd === "string" ? parseFloat(balance.valueUsd) : balance.valueUsd || 0;
+    const networkTotalCents = networkBalances.reduce((sumCents, balance, idx) => {
+      let valueUsd = typeof balance.valueUsd === "string" ? parseFloat(balance.valueUsd) : balance.valueUsd || 0;
+      if (isNaN(valueUsd)) {
+        console.warn(`⚠️  [BUILD-DASHBOARD] NaN value detected for ${balance.caip}:`, balance.valueUsd);
+        return sumCents;
+      }
+      balance.valueUsd = valueUsd;
+      const valueCents = Math.round(valueUsd * 100 * 1000) / 1000;
       if (idx < 2) {
         console.log(`\uD83D\uDCB0 [BUILD-DASHBOARD] ${blockchain} balance #${idx}:`, {
           caip: balance.caip,
           balance: balance.balance,
           valueUsd: balance.valueUsd,
+          valueUsdType: typeof balance.valueUsd,
           parsedValueUsd: valueUsd,
-          runningSum: sum + valueUsd
+          valueCents,
+          runningSumCents: sumCents + valueCents
         });
       }
-      return sum + valueUsd;
+      return sumCents + valueCents;
     }, 0);
+    const networkTotal = networkTotalCents / 100;
     console.log(`\uD83D\uDCB0 [BUILD-DASHBOARD] ${blockchain} totals:`, {
       balancesCount: networkBalances.length,
       networkTotal,
@@ -4184,8 +4195,9 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
       color: gasAsset?.color || assetInfo?.color || null,
       totalNativeBalance
     });
-    totalPortfolioValue += networkTotal;
+    totalPortfolioValueCents += networkTotalCents;
   }
+  const totalPortfolioValue = totalPortfolioValueCents / 100;
   dashboardData.networks = networksTemp.sort((a2, b2) => b2.totalValueUsd - a2.totalValueUsd);
   dashboardData.totalValueUsd = totalPortfolioValue;
   dashboardData.networkPercentages = dashboardData.networks.map((network) => ({
@@ -4193,6 +4205,26 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
     percentage: totalPortfolioValue > 0 ? Number((network.totalValueUsd / totalPortfolioValue * 100).toFixed(2)) : 0
   })).filter((entry) => entry.percentage > 0);
   console.log(`[FAST DASHBOARD] ✅ Built dashboard: ${dashboardData.networks.length} networks, $${totalPortfolioValue.toFixed(2)} total`);
+  const inputBalancesTotal = balances.reduce((sum, b2) => {
+    const value = typeof b2.valueUsd === "string" ? parseFloat(b2.valueUsd) : b2.valueUsd || 0;
+    return sum + (isNaN(value) ? 0 : value);
+  }, 0);
+  const difference = Math.abs(inputBalancesTotal - totalPortfolioValue);
+  if (difference > 0.01) {
+    console.error(`\uD83D\uDEA8 [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!`);
+    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;
 }
 
@@ -4465,6 +4497,19 @@ function enrichBalancesWithAssetInfo(balances, assetsMap, caipToNetworkId7) {
       console.warn(tag, `Missing AssetInfo for CAIP: "${balance.caip}" - skipping this balance`);
       continue;
     }
+    if (typeof balance.valueUsd === "string") {
+      balance.valueUsd = parseFloat(balance.valueUsd) || 0;
+    } else if (typeof balance.valueUsd !== "number") {
+      balance.valueUsd = 0;
+    }
+    if (typeof balance.balance === "string") {
+      balance.balance = balance.balance;
+    }
+    if (typeof balance.priceUsd === "string") {
+      balance.priceUsd = parseFloat(balance.priceUsd) || 0;
+    } else if (typeof balance.priceUsd !== "number") {
+      balance.priceUsd = 0;
+    }
     Object.assign(balance, assetInfo, {
       type: balance.type || assetInfo.type,
       isNative: balance.isNative ?? assetInfo.isNative,
@@ -4472,7 +4517,9 @@ function enrichBalancesWithAssetInfo(balances, assetsMap, caipToNetworkId7) {
       icon: assetInfo.icon || "https://pioneers.dev/coins/etherum.png",
       identifier: `${balance.caip}:${balance.pubkey}`,
       updated: Date.now(),
-      color: assetInfo.color
+      color: assetInfo.color,
+      valueUsd: balance.valueUsd,
+      priceUsd: balance.priceUsd
     });
     enrichedBalances.push(balance);
   }
@@ -5007,6 +5054,20 @@ class SDK {
               this.balances[index] = balance;
             }
             this.events.emit("BALANCE_UPDATE", balance);
+            console.log(tag7, "\uD83D\uDD04 Rebuilding dashboard after balance update...");
+            const previousTotal = this.dashboard?.totalValueUsd || 0;
+            this.dashboard = this.buildDashboardFromBalances();
+            const newTotal = this.dashboard?.totalValueUsd || 0;
+            if (Math.abs(newTotal - previousTotal) > 0.01) {
+              console.log(tag7, `\uD83D\uDCB0 Portfolio value changed: $${previousTotal.toFixed(2)} → $${newTotal.toFixed(2)}`);
+            }
+            this.events.emit("DASHBOARD_UPDATE", {
+              dashboard: this.dashboard,
+              trigger: "balance_update",
+              affectedAsset: balance.caip,
+              previousTotal,
+              newTotal
+            });
           } catch (e) {
             console.error(tag7, "Error processing balance update:", e);
           }

package/package.json

@@ -1,14 +1,14 @@
 {
   "author": "highlander",
   "name": "@pioneer-platform/pioneer-sdk",
-  "version": "8.15.31",
+  "version": "8.15.32",
   "dependencies": {
     "@keepkey/keepkey-sdk": "^0.2.62",
-    "@pioneer-platform/pioneer-caip": "^9.10.8",
-    "@pioneer-platform/pioneer-client": "^9.10.14",
-    "@pioneer-platform/pioneer-coins": "^9.11.8",
-    "@pioneer-platform/pioneer-discovery": "^8.15.31",
-    "@pioneer-platform/pioneer-events": "^8.12.3",
+    "@pioneer-platform/pioneer-caip": "^9.10.9",
+    "@pioneer-platform/pioneer-client": "^9.10.15",
+    "@pioneer-platform/pioneer-coins": "^9.11.9",
+    "@pioneer-platform/pioneer-discovery": "^8.15.32",
+    "@pioneer-platform/pioneer-events": "^8.12.4",
     "coinselect": "^3.1.13",
     "eventemitter3": "^5.0.1",
     "neotraverse": "^0.6.8",

package/src/fees/index.ts

@@ -48,6 +48,7 @@ function getNetworkName(networkId: string): string {
     'bip122:00000000001a91e3dace36e2be3bf030': 'Dogecoin',
     'bip122:000000000000000000651ef99cb9fcbe': 'Bitcoin Cash',
     'bip122:000007d91d1254d60e2dd1ae58038307': 'Dash',
+    'bip122:00040fe8ec8471911baa1db1266ea15d': 'Zcash',
     'bip122:4da631f2ac1bed857bd968c67c913978': 'DigiByte',
     'eip155:1': 'Ethereum',
     'eip155:56': 'BNB Smart Chain',

package/src/index.ts

@@ -552,6 +552,25 @@ export class SDK {
 
             // Emit SDK event for UI updates
             this.events.emit('BALANCE_UPDATE', balance);
+
+            // CRITICAL FIX: Rebuild dashboard when balance changes
+            console.log(tag, '🔄 Rebuilding dashboard after balance update...');
+            const previousTotal = this.dashboard?.totalValueUsd || 0;
+            this.dashboard = this.buildDashboardFromBalances();
+            const newTotal = this.dashboard?.totalValueUsd || 0;
+
+            if (Math.abs(newTotal - previousTotal) > 0.01) {
+              console.log(tag, `💰 Portfolio value changed: $${previousTotal.toFixed(2)} → $${newTotal.toFixed(2)}`);
+            }
+
+            // Emit dashboard update event for real-time UI updates
+            this.events.emit('DASHBOARD_UPDATE', {
+              dashboard: this.dashboard,
+              trigger: 'balance_update',
+              affectedAsset: balance.caip,
+              previousTotal,
+              newTotal
+            });
           } catch (e) {
             console.error(tag, 'Error processing balance update:', e);
           }

package/src/txbuilder/createUnsignedUxtoTx.ts

@@ -287,9 +287,26 @@ export async function createUnsignedUxtoTx(
       }
       } catch (error: any) {
         console.error(`${tag}: Failed to get fee rates from Pioneer API:`, error.message || error);
-        throw new Error(
-          `Unable to get fee rate for network ${networkId}: ${error.message || 'API unavailable'}`,
-        );
+
+        // Fallback to hardcoded default fees for known networks
+        const defaultFees: Record<string, { slow: number; average: number; fast: number; fastest: number }> = {
+          'bip122:000000000019d6689c085ae165831e93': { slow: 3, average: 5, fast: 10, fastest: 15 }, // BTC
+          'bip122:12a765e31ffd4059bada1e25190f6e98': { slow: 2, average: 3, fast: 5, fastest: 10 }, // LTC
+          'bip122:00000000001a91e3dace36e2be3bf030': { slow: 1, average: 1, fast: 2, fastest: 3 }, // DOGE
+          'bip122:000000000000000000651ef99cb9fcbe': { slow: 1, average: 1, fast: 2, fastest: 3 }, // BCH
+          'bip122:000007d91d1254d60e2dd1ae58038307': { slow: 1, average: 1, fast: 2, fastest: 3 }, // DASH
+          'bip122:4da631f2ac1bed857bd968c67c913978': { slow: 75, average: 80, fast: 100, fastest: 120 }, // DGB
+          'bip122:00040fe8ec8471911baa1db1266ea15d': { slow: 1, average: 1, fast: 2, fastest: 3 }, // ZEC
+        };
+
+        if (defaultFees[networkId]) {
+          console.warn(`${tag}: Using default fee rates for ${networkId}`);
+          feeRateFromNode = defaultFees[networkId];
+        } else {
+          throw new Error(
+            `Unable to get fee rate for network ${networkId}: ${error.message || 'API unavailable'}`,
+          );
+        }
       }
     }
 

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

@@ -220,6 +220,26 @@ 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;
+    }
+
     Object.assign(balance, assetInfo, {
       type: balance.type || assetInfo.type,
       isNative: balance.isNative ?? assetInfo.isNative,
@@ -228,6 +248,9 @@ export function enrichBalancesWithAssetInfo(
       identifier: `${balance.caip}:${balance.pubkey}`,
       updated: Date.now(),
       color: assetInfo.color,
+      // Ensure these are numbers (redundant but explicit)
+      valueUsd: balance.valueUsd,
+      priceUsd: balance.priceUsd,
     });
 
     enrichedBalances.push(balance);