@pioneer-platform/pioneer-sdk 4.20.3 → 4.20.5

package/src/index.ts

@@ -15,73 +15,13 @@ 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';
+// Utils
+import { detectKkApiAvailability } from './utils/kkapi-detection.js';
+import { formatTime } from './utils/format-time.js';
+import { buildDashboardFromBalances } from './utils/build-dashboard.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;
@@ -105,18 +45,6 @@ export interface PioneerSDKConfig {
   forceLocalhost?: boolean;
 }
 
-// Helper function to format time differences
-function formatTime(durationMs) {
-  let seconds = Math.floor((durationMs / 1000) % 60);
-  let minutes = Math.floor((durationMs / (1000 * 60)) % 60);
-  let hours = Math.floor((durationMs / (1000 * 60 * 60)) % 24);
-
-  let formatted = '';
-  if (hours > 0) formatted += `${hours}h `;
-  if (minutes > 0 || hours > 0) formatted += `${minutes}m `;
-  formatted += `${seconds}s`;
-  return formatted.trim();
-}
 
 export class SDK {
   public status: string;
@@ -642,181 +570,7 @@ export class SDK {
     };
     // Build dashboard from cached balances (no Pioneer API calls)
     this.buildDashboardFromBalances = function () {
-      const tag = `${TAG} | buildDashboardFromBalances | `;
-      console.log(tag, '[DASHBOARD] Building dashboard from cached balances...');
-
-      const dashboardData: {
-        networks: {
-          networkId: string;
-          totalValueUsd: number;
-          gasAssetCaip: string | null;
-          gasAssetSymbol: string | null;
-          icon: string | null;
-          color: string | null;
-          totalNativeBalance: string;
-        }[];
-        totalValueUsd: number;
-        networkPercentages: { networkId: string; percentage: number }[];
-      } = {
-        networks: [],
-        totalValueUsd: 0,
-        networkPercentages: [],
-      };
-
-      let totalPortfolioValue = 0;
-      const networksTemp: {
-        networkId: string;
-        totalValueUsd: number;
-        gasAssetCaip: string | null;
-        gasAssetSymbol: string | null;
-        icon: string | null;
-        color: string | null;
-        totalNativeBalance: string;
-      }[] = [];
-
-      console.log(tag, 'this.balances: ', this.balances);
-
-      // Calculate totals for each blockchain
-      for (const blockchain of this.blockchains) {
-        const filteredBalances = this.balances.filter((b) => {
-          const networkId = caipToNetworkId(b.caip);
-          return (
-            networkId === blockchain ||
-            (blockchain === 'eip155:*' && networkId.startsWith('eip155:'))
-          );
-        });
-
-        // Deduplicate balances based on caip + pubkey combination
-        const balanceMap = new Map();
-
-        // Special handling for Bitcoin to work around API bug
-        const isBitcoin = blockchain.includes('bip122:000000000019d6689c085ae165831e93');
-        if (isBitcoin) {
-          console.log(tag, 'Bitcoin network detected - checking for duplicate balances');
-          // Group Bitcoin balances by value to detect duplicates
-          const bitcoinByValue = new Map();
-          filteredBalances.forEach((balance) => {
-            const valueKey = `${balance.balance}_${balance.valueUsd}`;
-            if (!bitcoinByValue.has(valueKey)) {
-              bitcoinByValue.set(valueKey, []);
-            }
-            bitcoinByValue.get(valueKey).push(balance);
-          });
-
-          // Check if all three address types have the same non-zero balance (API bug)
-          for (const [valueKey, balances] of bitcoinByValue.entries()) {
-            if (balances.length === 3 && parseFloat(balances[0].valueUsd || '0') > 0) {
-              console.log(
-                tag,
-                'BITCOIN API BUG DETECTED: All 3 address types have same balance, keeping only xpub',
-              );
-              // Keep only the xpub (or first one if no xpub)
-              const xpubBalance = balances.find((b) => b.pubkey?.startsWith('xpub')) || balances[0];
-              const key = `${xpubBalance.caip}_${xpubBalance.pubkey || 'default'}`;
-              balanceMap.set(key, xpubBalance);
-            } else {
-              // Add all balances normally
-              balances.forEach((balance) => {
-                const key = `${balance.caip}_${balance.pubkey || 'default'}`;
-                balanceMap.set(key, balance);
-              });
-            }
-          }
-        } else {
-          // Standard deduplication for non-Bitcoin networks
-          filteredBalances.forEach((balance) => {
-            const key = `${balance.caip}_${balance.pubkey || 'default'}`;
-            // Only keep the first occurrence or the one with higher value
-            if (
-              !balanceMap.has(key) ||
-              parseFloat(balance.valueUsd || '0') > parseFloat(balanceMap.get(key).valueUsd || '0')
-            ) {
-              balanceMap.set(key, balance);
-            }
-          });
-        }
-
-        const networkBalances = Array.from(balanceMap.values());
-
-        // Ensure we're working with numbers for calculations
-        const networkTotal = networkBalances.reduce((sum, balance, idx) => {
-          const valueUsd =
-            typeof balance.valueUsd === 'string'
-              ? parseFloat(balance.valueUsd)
-              : balance.valueUsd || 0;
-
-          if (blockchain.includes('bip122:000000000019d6689c085ae165831e93')) {
-            console.log(
-              tag,
-              `[BITCOIN DEBUG ${idx}] pubkey:`,
-              balance.pubkey?.substring(0, 10) + '...',
-              '| balance:',
-              balance.balance,
-              '| valueUsd:',
-              balance.valueUsd,
-              '→ parsed:',
-              valueUsd,
-              '| running sum:',
-              sum + valueUsd,
-            );
-          }
-
-          return sum + valueUsd;
-        }, 0);
-
-        // Get native asset for this blockchain
-        const nativeAssetCaip = networkIdToCaip(blockchain);
-        const gasAsset = networkBalances.find((b) => b.caip === nativeAssetCaip);
-
-        // Calculate total native balance (sum of all balances for the native asset)
-        const totalNativeBalance = networkBalances
-          .filter((b) => b.caip === nativeAssetCaip)
-          .reduce((sum, balance) => {
-            const balanceNum =
-              typeof balance.balance === 'string'
-                ? parseFloat(balance.balance)
-                : balance.balance || 0;
-            return sum + balanceNum;
-          }, 0)
-          .toString();
-
-        // Get colors from assetMap since balances don't have them
-        const assetInfo = nativeAssetCaip ? this.assetsMap.get(nativeAssetCaip) : null;
-
-        networksTemp.push({
-          networkId: blockchain,
-          totalValueUsd: networkTotal,
-          gasAssetCaip: nativeAssetCaip || null,
-          gasAssetSymbol: gasAsset?.ticker || gasAsset?.symbol || assetInfo?.symbol || null,
-          icon: gasAsset?.icon || assetInfo?.icon || null,
-          color: gasAsset?.color || assetInfo?.color || null,
-          totalNativeBalance,
-        });
-
-        totalPortfolioValue += networkTotal;
-      }
-
-      // Sort networks by USD value and assign to dashboard
-      dashboardData.networks = networksTemp.sort((a, b) => b.totalValueUsd - a.totalValueUsd);
-      dashboardData.totalValueUsd = totalPortfolioValue;
-
-      // Calculate network percentages for pie chart
-      dashboardData.networkPercentages = dashboardData.networks
-        .map((network) => ({
-          networkId: network.networkId,
-          percentage:
-            totalPortfolioValue > 0
-              ? Number(((network.totalValueUsd / totalPortfolioValue) * 100).toFixed(2))
-              : 0,
-        }))
-        .filter((entry) => entry.percentage > 0); // Remove zero percentages
-
-      console.log(
-        `[FAST DASHBOARD] ✅ Built dashboard: ${
-          dashboardData.networks.length
-        } networks, $${totalPortfolioValue.toFixed(2)} total`,
-      );
-      return dashboardData;
+      return buildDashboardFromBalances(this.balances, this.blockchains, this.assetsMap);
     };
 
     this.syncMarket = async function () {