@pioneer-platform/pioneer-sdk 8.15.13 → 8.15.15

package/src/utils/pubkey-sync.ts

@@ -0,0 +1,86 @@
+// Pubkey synchronization utilities for blockchain wallets
+
+import { addressNListToBIP32 } from '@pioneer-platform/pioneer-coins';
+import { matchesNetwork, normalizeNetworkId } from './network-helpers.js';
+
+const log = require('@pioneer-platform/loggerdog')();
+
+/**
+ * Synchronize pubkeys for all blockchains
+ * Fetches missing pubkeys from hardware wallet
+ */
+export async function syncPubkeysForBlockchains(
+  blockchains: string[],
+  paths: any[],
+  existingPubkeys: any[],
+  keepKeySdk: any,
+  context: string,
+  getPubkeyFn: (blockchain: string, path: any, sdk: any, ctx: string) => Promise<any>,
+  addPubkeyCallback: (pubkey: any) => void,
+  tag: string
+): Promise<void> {
+  for (const blockchain of blockchains) {
+    const networkId = normalizeNetworkId(blockchain);
+    const pathsForChain = paths.filter(path => matchesNetwork(path, networkId));
+
+    if (pathsForChain.length === 0) {
+      const availablePaths = paths.map(p => p.note || p.path || 'unnamed').join(', ');
+      throw new Error(
+        `No paths found for ${networkId}. ` +
+        `Available paths: ${availablePaths || 'none'}`
+      );
+    }
+
+    log.info(tag, `Syncing ${pathsForChain.length} pubkeys for ${networkId}...`);
+
+    for (const path of pathsForChain) {
+      const pathBip32 = addressNListToBIP32(path.addressNListMaster);
+      const existingPubkey = existingPubkeys.find(p => p.pathMaster === pathBip32);
+
+      if (!existingPubkey) {
+        log.debug(tag, `Fetching pubkey for path ${pathBip32}...`);
+        const newPubkey = await getPubkeyFn(blockchain, path, keepKeySdk, context);
+
+        if (!newPubkey) {
+          throw new Error(
+            `Pubkey fetch failed for ${networkId} at path ${pathBip32}. ` +
+            `Ensure hardware wallet is connected and unlocked.`
+          );
+        }
+
+        addPubkeyCallback(newPubkey);
+        log.debug(tag, `✓ Added pubkey for ${pathBip32}`);
+      }
+    }
+  }
+
+  log.info(tag, `✅ Pubkey sync complete. Total pubkeys: ${existingPubkeys.length}`);
+}
+
+/**
+ * Count missing pubkeys for blockchains
+ * Useful for progress estimation
+ */
+export function countMissingPubkeys(
+  blockchains: string[],
+  paths: any[],
+  existingPubkeys: any[]
+): number {
+  let missingCount = 0;
+
+  for (const blockchain of blockchains) {
+    const networkId = normalizeNetworkId(blockchain);
+    const pathsForChain = paths.filter(path => matchesNetwork(path, networkId));
+
+    for (const path of pathsForChain) {
+      const pathBip32 = addressNListToBIP32(path.addressNListMaster);
+      const existingPubkey = existingPubkeys.find(p => p.pathMaster === pathBip32);
+
+      if (!existingPubkey) {
+        missingCount++;
+      }
+    }
+  }
+
+  return missingCount;
+}

package/src/utils/sync-state.ts

@@ -0,0 +1,93 @@
+// Sync state management and asset info utilities
+
+const log = require('@pioneer-platform/loggerdog')();
+const TAG = ' | sync-state | ';
+
+export interface SyncState {
+  isSynced: boolean;              // Has fresh data from full sync?
+  isInitialSync: boolean;          // First sync (no cache)?
+  cacheAge: number;                // Seconds since last cache update
+  syncProgress: number;            // 0-100 percentage of completion
+  syncedChains: number;            // Number of chains synced
+  totalChains: number;             // Total chains to sync
+  lastSyncTime: number | null;    // Timestamp of last successful sync
+  syncSource: 'cache' | 'fresh' | 'none';  // Where data came from
+}
+
+/**
+ * Resolve asset info from multiple sources
+ * Priority: assetsMap > assetData discovery > placeholder
+ */
+export function resolveAssetInfo(
+  assetsMap: Map<string, any>,
+  assetData: any,
+  asset: any,
+): any {
+  const tag = TAG + ' | resolveAssetInfo | ';
+
+  // Try to find the asset in the local assetsMap
+  let assetInfo = assetsMap.get(asset.caip.toLowerCase());
+  log.debug(tag, 'assetInfo from assetsMap:', assetInfo);
+
+  // Check discovery
+  const assetInfoDiscovery = assetData[asset.caip];
+  log.debug(tag, 'assetInfoDiscovery:', assetInfoDiscovery);
+  if (assetInfoDiscovery) {
+    assetInfo = assetInfoDiscovery;
+  }
+
+  // If the asset is not found, create a placeholder object
+  if (!assetInfo) {
+    log.debug(tag, 'Building placeholder asset for', asset.caip);
+    assetInfo = {
+      caip: asset.caip.toLowerCase(),
+      networkId: asset.networkId,
+      symbol: asset.symbol || 'UNKNOWN',
+      name: asset.name || 'Unknown Asset',
+      icon: asset.icon || 'https://pioneers.dev/coins/ethereum.png',
+    };
+  }
+
+  return assetInfo;
+}
+
+export function createInitialSyncState(totalChains: number): SyncState {
+  return {
+    isSynced: false,
+    isInitialSync: true,
+    cacheAge: 0,
+    syncProgress: 0,
+    syncedChains: 0,
+    totalChains,
+    lastSyncTime: null,
+    syncSource: 'none'
+  };
+}
+
+export function createCacheSyncState(lastUpdated: number, totalChains: number): SyncState {
+  const cacheAge = lastUpdated ? Math.floor((Date.now() - lastUpdated) / 1000) : 0;
+
+  return {
+    isSynced: true,
+    isInitialSync: false,
+    cacheAge,
+    syncProgress: 100,
+    syncedChains: totalChains,
+    totalChains,
+    lastSyncTime: lastUpdated || Date.now(),
+    syncSource: 'cache'
+  };
+}
+
+export function createFreshSyncState(totalChains: number): SyncState {
+  return {
+    isSynced: true,
+    isInitialSync: false,
+    cacheAge: 0,
+    syncProgress: 100,
+    syncedChains: totalChains,
+    totalChains,
+    lastSyncTime: Date.now(),
+    syncSource: 'fresh'
+  };
+}