@pioneer-platform/pioneer-sdk 8.14.0 → 8.15.2

package/package.json

@@ -1,14 +1,14 @@
 {
   "author": "highlander",
   "name": "@pioneer-platform/pioneer-sdk",
-  "version": "8.14.0",
+  "version": "8.15.2",
   "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.12.0",
+    "@pioneer-platform/pioneer-discovery": "^8.14.1",
     "@pioneer-platform/pioneer-events": "^8.12.0",
     "coinselect": "^3.1.13",
     "eventemitter3": "^5.0.1",

package/src/fees/index.ts

@@ -89,13 +89,19 @@ export async function getFees(
   try {
     console.log(tag, `Fetching fees for network: ${networkId}`);
 
-    // For Cosmos chains, always use hardcoded fees
+    // For Cosmos chains, always use hardcoded fees (multiple Cosmos chains)
     const networkType = getNetworkType(networkId);
     if (networkType === 'COSMOS') {
       console.log(tag, 'Using hardcoded fees for Cosmos network:', networkId);
       return getCosmosFees(networkId);
     }
 
+    // Hardcode XRP fees (fixed fee model)
+    if (networkId === 'ripple:4109c6f2045fc7eff4cde8f9905d19c2') {
+      console.log(tag, 'Using hardcoded fees for Ripple: 0.00001 XRP');
+      return getRippleFees(networkId);
+    }
+
     // Hardcode DOGE fees at 10 sat/byte (API and Blockbook often unreliable for DOGE)
     if (networkId === 'bip122:00000000001a91e3dace36e2be3bf030') {
       console.log(tag, 'Using hardcoded fees for Dogecoin: 10 sat/byte');
@@ -535,6 +541,48 @@ function getCosmosFees(networkId: string): NormalizedFeeRates {
   };
 }
 
+/**
+ * Get hardcoded Ripple fees
+ * XRP uses a fixed fee model with very low transaction costs
+ */
+function getRippleFees(networkId: string): NormalizedFeeRates {
+  const networkName = getNetworkName(networkId);
+
+  // XRP standard fee is 0.00001 XRP (10 drops)
+  // This is sufficient for most transactions and is the network minimum
+  const standardFee = '0.00001';
+
+  return {
+    slow: {
+      label: 'Standard',
+      value: standardFee,
+      unit: 'XRP',
+      description: `Fixed fee for ${networkName}. XRP uses a deterministic fee model.`,
+      estimatedTime: '~4 seconds',
+      priority: 'low',
+    },
+    average: {
+      label: 'Standard',
+      value: standardFee,
+      unit: 'XRP',
+      description: `Fixed fee for ${networkName}. XRP uses a deterministic fee model.`,
+      estimatedTime: '~4 seconds',
+      priority: 'medium',
+    },
+    fastest: {
+      label: 'Standard',
+      value: standardFee,
+      unit: 'XRP',
+      description: `Fixed fee for ${networkName}. XRP uses a deterministic fee model.`,
+      estimatedTime: '~4 seconds',
+      priority: 'high',
+    },
+    networkId,
+    networkType: 'RIPPLE',
+    raw: { hardcoded: true, fee: standardFee, unit: 'XRP' },
+  };
+}
+
 /**
  * Get fallback fees when API fails
  */

package/src/index.ts

@@ -782,6 +782,13 @@ export class SDK {
     this.buildDashboardFromBalances = function () {
       return buildDashboardFromBalances(this.balances, this.blockchains, this.assetsMap);
     };
+    // ✅ PHASE 3: Infer asset type from CAIP structure (fallback helper)
+    this.inferTypeFromCaip = function (caip: string): string {
+      if (caip.includes('/slip44:')) return 'native';
+      if (caip.includes('/erc20:') || caip.includes('/bep20:') || caip.includes('/spl:')) return 'token';
+      if (caip.includes('/denom:')) return 'native'; // Cosmos denoms
+      return 'unknown';
+    };
     this.syncMarket = async function () {
       return syncMarket(this.balances, this.pioneer);
     };
@@ -1880,7 +1887,7 @@ export class SDK {
         throw error;
       }
     };
-    this.getBalancesForNetworks = async function (networkIds: string[]) {
+    this.getBalancesForNetworks = async function (networkIds: string[], forceRefresh?: boolean) {
       const tag = `${TAG} | getBalancesForNetworks | `;
       try {
         // Add defensive check for pioneer initialization
@@ -1893,6 +1900,11 @@ export class SDK {
           throw new Error('Pioneer client not initialized. Call init() first.');
         }
 
+        // Log force refresh request
+        if (forceRefresh) {
+          console.log(tag, '🔄 Force refresh requested - bypassing balance cache');
+        }
+
         // DIAGNOSTIC: Log input
         console.log('🔍 [DIAGNOSTIC] Input networks:', networkIds);
         console.log('🔍 [DIAGNOSTIC] Total pubkeys:', this.pubkeys.length);
@@ -1987,7 +1999,11 @@ export class SDK {
 
         try {
           // Wrap assetQuery in object with pubkeys field (API expects { pubkeys: [...] })
-          let marketInfo = await this.pioneer.GetPortfolioBalances({ pubkeys: assetQuery });
+          // Pass forceRefresh as query parameter if provided
+          let marketInfo = await this.pioneer.GetPortfolioBalances(
+            { pubkeys: assetQuery },
+            forceRefresh ? { forceRefresh: true } : undefined
+          );
           const apiCallTime = performance.now() - apiCallStart;
           console.timeEnd('GetPortfolioBalances Response Time');
           console.log(`⏱️  [PERF] API call completed in ${apiCallTime.toFixed(0)}ms`);
@@ -2000,12 +2016,30 @@ export class SDK {
           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;
+
+            // ✅ PHASE 3: Add fallback for missing asset metadata
+            if (!assetInfo) {
+              console.warn(`⚠️  [ENRICHMENT] Asset metadata missing for ${balance.caip}, using fallback enrichment`);
+
+              // Fallback: Use API-provided values or infer from CAIP
+              const inferredType = this.inferTypeFromCaip(balance.caip);
+              Object.assign(balance, {
+                type: balance.type || inferredType,
+                isNative: balance.isNative ?? (inferredType === 'native'),
+                networkId: caipToNetworkId(balance.caip),
+                icon: 'https://pioneers.dev/coins/unknown.png',
+                identifier: `${balance.caip}:${balance.pubkey}`,
+                updated: Date.now(),
+              });
+              continue;
+            }
 
             // Get color from mapping (fallback to assetInfo.color if it exists)
             const color = ASSET_COLORS[balance.caip] || assetInfo.color;
 
             Object.assign(balance, assetInfo, {
+              type: balance.type || assetInfo.type,           // ✅ PHASE 3: Prefer API type, fallback to assetInfo
+              isNative: balance.isNative ?? assetInfo.isNative, // ✅ PHASE 3: Prefer API isNative
               networkId: caipToNetworkId(balance.caip),
               icon: assetInfo.icon || 'https://pioneers.dev/coins/etherum.png',
               identifier: `${balance.caip}:${balance.pubkey}`,
@@ -2041,11 +2075,11 @@ export class SDK {
         throw e;
       }
     };
-    this.getBalances = async function () {
+    this.getBalances = async function (forceRefresh?: boolean) {
       const tag = `${TAG} | getBalances | `;
       try {
         // Simply call the shared function with all blockchains
-        return await this.getBalancesForNetworks(this.blockchains);
+        return await this.getBalancesForNetworks(this.blockchains, forceRefresh);
       } catch (e) {
         console.error(tag, 'Error in getBalances: ', e);
         throw e;
@@ -2110,57 +2144,21 @@ export class SDK {
     this.getCharts = async function () {
       const tag = `${TAG} | getCharts | `;
       try {
-        console.log(tag, 'Fetching charts from batch endpoint');
-
-        // 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
-        let newBalances = [];
-        try {
-          const chartsResponse = await this.pioneer.GetCharts({
-            pubkeys: pubkeysForBatch
-          });
-          newBalances = chartsResponse?.data?.balances || [];
-          console.log(tag, `Received ${newBalances.length} balances from batch endpoint`);
-        } catch (chartsError: any) {
-          // GetCharts API may not be available - gracefully continue without charts data
-          console.warn(tag, `GetCharts API not available (${chartsError.message}), continuing without charts data`);
-        }
+        console.log(tag, 'Fetching charts (portfolio + tokens + staking)...');
+
+        // Use the NEW modular chart implementation
+        // This calls /charts/portfolio (BLOCKING) which fetches tokens from Zapper/Unchained
+        const { getCharts: getChartsModular } = await import('./charts');
+        
+        // Call new implementation with all required parameters
+        const newBalances = await getChartsModular(
+          this.blockchains,
+          this.pioneer,
+          this.pubkeys,
+          this.context
+        );
+        
+        console.log(tag, `Modular charts returned ${newBalances.length} balances (native + tokens + staking)`);
 
         // Deduplicate balances using a Map with `identifier` as the key
         const uniqueBalances = new Map(
@@ -2172,11 +2170,15 @@ export class SDK {
             },
           ]),
         );
-        console.log(tag, 'uniqueBalances: ', uniqueBalances.size);
+        console.log(tag, 'Deduplicated to:', uniqueBalances.size, 'unique balances');
 
         // Convert Map back to array and set this.balances
         this.balances = Array.from(uniqueBalances.values());
-        console.log(tag, 'Updated this.balances: ', this.balances.length);
+        
+        // Log breakdown of balance types
+        const tokens = this.balances.filter((b: any) => b.token === true);
+        const native = this.balances.filter((b: any) => b.token !== true);
+        console.log(tag, `Balance breakdown: ${native.length} native + ${tokens.length} tokens = ${this.balances.length} total`);
 
         return this.balances;
       } catch (e) {
@@ -2208,10 +2210,15 @@ export class SDK {
         return { success: false };
       }
     };
-    this.refresh = async (): Promise<any> => {
+    this.refresh = async (forceRefresh?: boolean): Promise<any> => {
       const tag = `${TAG} | refresh | `;
       try {
-        await this.sync();
+        if (forceRefresh) {
+          console.log(tag, '🔄 Force refresh - fetching fresh balances from blockchain');
+          await this.getBalances(true);
+        } else {
+          await this.sync();
+        }
         return this.balances;
       } catch (e) {
         console.error(tag, 'e: ', e);