@pioneer-platform/pioneer-sdk 4.20.0 → 4.20.1

package/src/index.ts

@@ -1,10 +1,10 @@
 import { KeepKeySdk } from '@keepkey/keepkey-sdk';
 import { caipToNetworkId, networkIdToCaip } from '@pioneer-platform/pioneer-caip';
-import { Pioneer } from '@pioneer-platform/pioneer-client';
+import Pioneer from '@pioneer-platform/pioneer-client';
 import { addressNListToBIP32, getPaths } from '@pioneer-platform/pioneer-coins';
 import { assetData } from '@pioneer-platform/pioneer-discovery';
 import { Events } from '@pioneer-platform/pioneer-events';
-import { EventEmitter } from 'events';
+import EventEmitter from 'events';
 
 import { getCharts } from './charts/index.js';
 //internal
@@ -15,13 +15,73 @@ import { TransactionManager } from './TransactionManager.js';
 import { createUnsignedTendermintTx } from './txbuilder/createUnsignedTendermintTx.js';
 import { createUnsignedStakingTx, type StakingTxParams } from './txbuilder/createUnsignedStakingTx.js';
 import { getFees, estimateTransactionFee, type NormalizedFeeRates, type FeeEstimate } from './fees/index.js';
-import { detectKkApiAvailability } from './utils/kkapi-detection.js';
-import { formatTime } from './utils/format-time.js';
-import { buildDashboardFromBalances } from './utils/build-dashboard.js';
-import { PubkeyManager, getPubkeyKey, deduplicatePubkeys, validatePubkey } from './utils/pubkey-helpers.js';
 
 const TAG = ' | Pioneer-sdk | ';
 
+// Utility function to detect if kkapi is available with smart environment detection
+async function detectKkApiAvailability(forceLocalhost?: boolean): Promise<{
+  isAvailable: boolean;
+  baseUrl: string;
+  basePath: string;
+}> {
+  const tag = `${TAG} | detectKkApiAvailability | `;
+
+  try {
+    // Smart detection: Check environment (Tauri, browser, or Node.js)
+    const isTauri = typeof window !== 'undefined' && '__TAURI__' in window;
+    const isBrowser = typeof window !== 'undefined';
+    const isNodeJS = typeof process !== 'undefined' && process.versions && process.versions.node;
+    const isLocalhost = isBrowser && window.location.hostname === 'localhost';
+
+    // If in Tauri, use kkapi:// (will be proxied by Tauri)
+    if (isTauri) {
+      return {
+        isAvailable: true,
+        baseUrl: 'kkapi://',
+        basePath: 'kkapi://spec/swagger.json',
+      };
+    }
+
+    // In Node.js test environment or localhost browser, test if localhost:1646 is available
+    // Force localhost if flag is set
+    const shouldTestLocalhost = forceLocalhost || isLocalhost || isNodeJS;
+
+    if (shouldTestLocalhost) {
+      const testEnv = isNodeJS ? 'Node.js test environment' : 'development browser';
+      try {
+        const httpResponse = await fetch('http://localhost:1646/api/v1/health', {
+          method: 'GET',
+          signal: AbortSignal.timeout(1000), // 1 second timeout for localhost
+        });
+
+        if (httpResponse.ok) {
+          return {
+            isAvailable: true,
+            baseUrl: 'http://localhost:1646',
+            basePath: 'http://localhost:1646/spec/swagger.json',
+          };
+        }
+      } catch (httpError: any) {
+        console.error('❌ [KKAPI DETECTION] HTTP localhost:1646 not available:', httpError.message);
+      }
+    }
+
+    // Fallback for production non-Tauri or when vault server is not running
+    console.warn('⚠️ [KKAPI DETECTION] Using fallback config (vault may not be available)');
+    return {
+      isAvailable: false,
+      baseUrl: 'http://localhost:1646',
+      basePath: 'http://localhost:1646/spec/swagger.json',
+    };
+  } catch (error) {
+    console.error('❌ [KKAPI DETECTION] Error during detection:', error);
+    return {
+      isAvailable: false,
+      baseUrl: 'http://localhost:1646',
+      basePath: 'http://localhost:1646/spec/swagger.json',
+    };
+  }
+}
 
 export interface PioneerSDKConfig {
   appName: string;
@@ -45,6 +105,18 @@ 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;
@@ -76,7 +148,7 @@ export class SDK {
     address?: string;
     master?: string;
   }[] = [];
-  private pubkeyManager: PubkeyManager = new PubkeyManager();
+  private pubkeySet: Set<string> = new Set(); // Track unique pubkey identifiers
   public wallets: any[];
   public balances: any[];
   public nodes: any[];
@@ -189,11 +261,10 @@ export class SDK {
 
     // Initialize pubkeys with deduplication if provided in config
     if (config.pubkeys && config.pubkeys.length > 0) {
-      this.pubkeyManager.setPubkeys(config.pubkeys);
-      this.pubkeys = this.pubkeyManager.getPubkeys();
+      this.setPubkeys(config.pubkeys);
     } else {
       this.pubkeys = [];
-      this.pubkeyManager.clear();
+      this.pubkeySet.clear();
     }
 
     this.balances = config.balances || [];
@@ -233,24 +304,59 @@ export class SDK {
     };
 
     // Helper method to generate unique key for a pubkey
-    this.getPubkeyKey = getPubkeyKey;
+    this.getPubkeyKey = (pubkey: any): string => {
+      return `${pubkey.pubkey}_${pubkey.pathMaster}`;
+    };
 
     // Helper method to deduplicate pubkeys array
-    this.deduplicatePubkeys = deduplicatePubkeys;
+    this.deduplicatePubkeys = (pubkeys: any[]): any[] => {
+      const seen = new Set<string>();
+      const deduped = pubkeys.filter((pubkey) => {
+        const key = this.getPubkeyKey(pubkey);
+        if (seen.has(key)) {
+          return false;
+        }
+        seen.add(key);
+        return true;
+      });
+      return deduped;
+    };
 
     // Helper method to validate and add a single pubkey
     this.addPubkey = (pubkey: any): boolean => {
-      const result = this.pubkeyManager.addPubkey(pubkey);
-      if (result) {
-        this.pubkeys = this.pubkeyManager.getPubkeys();
+      // Validate pubkey has required fields
+      if (!pubkey.pubkey || !pubkey.pathMaster) {
+        return false;
       }
-      return result;
+
+      const key = this.getPubkeyKey(pubkey);
+
+      // Check if already exists
+      if (this.pubkeySet.has(key)) {
+        return false;
+      }
+
+      // Add to both array and set
+      this.pubkeys.push(pubkey);
+      this.pubkeySet.add(key);
+      return true;
     };
 
     // Helper method to set pubkeys array with deduplication
     this.setPubkeys = (newPubkeys: any[]): void => {
-      this.pubkeyManager.setPubkeys(newPubkeys);
-      this.pubkeys = this.pubkeyManager.getPubkeys();
+      const tag = `${TAG} | setPubkeys | `;
+
+      // Clear existing
+      this.pubkeys = [];
+      this.pubkeySet.clear();
+
+      // Add each pubkey with validation
+      let added = 0;
+      for (const pubkey of newPubkeys) {
+        if (this.addPubkey(pubkey)) {
+          added++;
+        }
+      }
     };
 
     // Fast portfolio loading from kkapi:// cache
@@ -301,11 +407,9 @@ export class SDK {
           // Update pubkeys from cache
           if (portfolioData.pubkeys && portfolioData.pubkeys.length > 0) {
             // Convert vault pubkey format to pioneer-sdk format
-            // TODO: Implement convertVaultPubkeysToPioneerFormat method
-            const convertedPubkeys = portfolioData.pubkeys;
+            const convertedPubkeys = this.convertVaultPubkeysToPioneerFormat(portfolioData.pubkeys);
             // Use setPubkeys to ensure deduplication
-            this.pubkeyManager.setPubkeys(convertedPubkeys);
-            this.pubkeys = this.pubkeyManager.getPubkeys();
+            this.setPubkeys(convertedPubkeys);
             this.events.emit('SET_PUBKEYS', this.pubkeys);
           }
 
@@ -380,7 +484,7 @@ export class SDK {
               '[CACHE VALIDATION] ❌ Cache data corrupted, building dashboard from cached balances',
             );
             // Build dashboard from cached balances without hitting Pioneer APIs
-            const dashboardData = buildDashboardFromBalances(this.balances, this.blockchains, this.assetsMap);
+            const dashboardData = this.buildDashboardFromBalances();
             this.dashboard = dashboardData;
             this.events.emit('SET_DASHBOARD', this.dashboard);
           }
@@ -537,8 +641,182 @@ export class SDK {
       }
     };
     // Build dashboard from cached balances (no Pioneer API calls)
-    this.buildDashboardFromBalances = () => {
-      return buildDashboardFromBalances(this.balances, this.blockchains, this.assetsMap);
+    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;
     };
 
     this.syncMarket = async function () {
@@ -900,6 +1178,7 @@ export class SDK {
           balances: this.balances,
           pioneer: this.pioneer,
           pubkeys: this.pubkeys,
+          pubkeyContext: this.pubkeyContext,
           nodes: this.nodes,
           keepKeySdk: this.keepKeySdk,
         };
@@ -924,7 +1203,7 @@ export class SDK {
           delegateParams,
           this.pubkeys,
           this.pioneer,
-          this.keepKeySdk,
+          this.pubkeyContext,
         );
         console.log(tag, 'unsignedTx: ', unsignedTx);
         return unsignedTx;
@@ -945,7 +1224,7 @@ export class SDK {
           undelegateParams,
           this.pubkeys,
           this.pioneer,
-          this.keepKeySdk,
+          this.pubkeyContext,
         );
         console.log(tag, 'unsignedTx: ', unsignedTx);
         return unsignedTx;
@@ -966,7 +1245,7 @@ export class SDK {
           claimParams,
           this.pubkeys,
           this.pioneer,
-          this.keepKeySdk,
+          this.pubkeyContext,
         );
         console.log(tag, 'unsignedTx: ', unsignedTx);
         return unsignedTx;
@@ -987,7 +1266,7 @@ export class SDK {
           claimAllParams,
           this.pubkeys,
           this.pioneer,
-          this.keepKeySdk,
+          this.pubkeyContext,
         );
         //console.log(tag, 'unsignedTx: ', unsignedTx);
         return unsignedTx;
@@ -1005,6 +1284,7 @@ export class SDK {
           balances: this.balances,
           pioneer: this.pioneer,
           pubkeys: this.pubkeys,
+          pubkeyContext: this.pubkeyContext, // CRITICAL: Must include pubkeyContext for signing!
           nodes: this.nodes,
           keepKeySdk: this.keepKeySdk,
         };
@@ -1441,6 +1721,65 @@ export class SDK {
         throw e;
       }
     };
+    this.addPath = async function (path: any) {
+      const tag = `${TAG} | addPath | `;
+      try {
+        this.paths.push(path);
+        const pubkey = await getPubkey(path.networks[0], path, this.keepKeySdk, this.context);
+        this.addPubkey(pubkey);
+        await this.getBalancesForNetworks(path.networks);
+        this.buildDashboardFromBalances();
+        return { success: true, pubkey };
+      } catch (e) {
+        console.error(tag, 'Failed:', e);
+        throw e;
+      }
+    };
+    this.addPaths = async function (paths: any[]) {
+      const tag = `${TAG} | addPaths | `;
+      try {
+        console.log(tag, `Adding ${paths.length} paths in batch mode...`);
+
+        // Add all paths to the paths array
+        this.paths.push(...paths);
+
+        // Get pubkeys for all paths
+        const newPubkeys = [];
+        for (const path of paths) {
+          try {
+            const pubkey = await getPubkey(path.networks[0], path, this.keepKeySdk, this.context);
+            this.addPubkey(pubkey);
+            newPubkeys.push(pubkey);
+          } catch (error: any) {
+            console.warn(tag, `Failed to get pubkey for path ${path.note}:`, error.message);
+          }
+        }
+
+        console.log(tag, `Successfully added ${newPubkeys.length} pubkeys`);
+
+        // Collect unique networks from all paths
+        const networkSet = new Set<string>();
+        for (const path of paths) {
+          if (path.networks && Array.isArray(path.networks)) {
+            path.networks.forEach((net: string) => networkSet.add(net));
+          }
+        }
+
+        const uniqueNetworks = [...networkSet];
+        console.log(tag, `Fetching balances for ${uniqueNetworks.length} unique networks in single API call...`);
+
+        // Single API call for all networks
+        await this.getBalancesForNetworks(uniqueNetworks);
+        this.buildDashboardFromBalances();
+
+        console.log(tag, `Batch add complete: ${paths.length} paths, ${newPubkeys.length} pubkeys, ${this.balances?.length || 0} balances`);
+
+        return { success: true, pubkeys: newPubkeys };
+      } catch (e) {
+        console.error(tag, 'Failed:', e);
+        throw e;
+      }
+    };
     this.getAssets = async function () {
       /*
         Get Asset Rules
@@ -1583,24 +1922,6 @@ export class SDK {
           let marketInfo = await this.pioneer.GetPortfolioBalances(assetQuery);
           console.timeEnd('GetPortfolioBalances Response Time');
 
-          // DEFENSIVE: Validate response structure to prevent "balances.filter is not a function"
-          if (!marketInfo || !marketInfo.data) {
-            console.error(tag, 'Invalid response structure:', marketInfo);
-            throw new Error('GetPortfolioBalances returned invalid response: missing data field');
-          }
-
-          if (!Array.isArray(marketInfo.data)) {
-            console.error(
-              tag,
-              'GetPortfolioBalances returned non-array data:',
-              typeof marketInfo.data,
-              marketInfo.data
-            );
-            throw new Error(
-              `GetPortfolioBalances returned invalid data type: expected array, got ${typeof marketInfo.data}`
-            );
-          }
-
           let balances = marketInfo.data;
 
           const bitcoinBalances = balances.filter(
@@ -2038,18 +2359,29 @@ export class SDK {
         }
 
         // Auto-set pubkey context for this asset's network
-        // Use the first matching pubkey from assetPubkeys we already filtered
+        // IMPORTANT: Only auto-set if no pubkey context exists OR if current context is for wrong network
+        // This preserves custom pubkey contexts set via setPubkeyContext()
         if (assetPubkeys && assetPubkeys.length > 0) {
-          this.pubkeyContext = assetPubkeys[0];
-          // Also set it on keepKeySdk so tx builders can access it
-          if (this.keepKeySdk) {
-            this.keepKeySdk.pubkeyContext = assetPubkeys[0];
+          const networkId = caipToNetworkId(asset.caip || asset.networkId);
+          const currentContextValid = this.pubkeyContext?.networks?.includes(networkId);
+
+          if (!this.pubkeyContext || !currentContextValid) {
+            // No context or wrong network - auto-set to first matching pubkey
+            this.pubkeyContext = assetPubkeys[0];
+            console.log(
+              tag,
+              'Auto-set pubkey context for network:',
+              this.pubkeyContext.address || this.pubkeyContext.pubkey,
+            );
+          } else {
+            // Valid context already exists for this network - preserve it
+            console.log(
+              tag,
+              'Preserving existing pubkey context for network:',
+              this.pubkeyContext.address || this.pubkeyContext.pubkey,
+              `(addressNList: [${(this.pubkeyContext.addressNList || this.pubkeyContext.addressNListMaster).join(', ')}])`,
+            );
           }
-          console.log(
-            tag,
-            'Auto-set pubkey context for network:',
-            this.pubkeyContext.address || this.pubkeyContext.pubkey,
-          );
         }
 
         this.events.emit('SET_ASSET_CONTEXT', this.assetContext);
@@ -2084,16 +2416,14 @@ export class SDK {
             ethereum account 0/1/2
         */
         this.pubkeyContext = pubkey;
-        // Also set it on keepKeySdk so tx builders can access it
-        if (this.keepKeySdk) {
-          this.keepKeySdk.pubkeyContext = pubkey;
-        }
         console.log(
           tag,
           'Pubkey context set to:',
           pubkey.address || pubkey.pubkey,
           'note:',
           pubkey.note,
+          'addressNList:',
+          pubkey.addressNList || pubkey.addressNListMaster,
         );
 
         return true;