@pioneer-platform/pioneer-sdk 0.0.81 → 4.13.30

package/src/kkapi-batch-client.ts

@@ -0,0 +1,191 @@
+/**
+ * KKAPI Batch Client for Pioneer SDK
+ * 
+ * Provides batch operations for kkapi:// protocol to optimize performance:
+ * 1. Single batch call to get ALL cached pubkeys
+ * 2. Audit which ones are missing
+ * 3. Individual fallback only for missing pubkeys
+ */
+
+export interface KkapiPubkey {
+  pubkey: string;
+  address: string;
+  path: string;
+  pathMaster: string;
+  scriptType: string;
+  networks: string[];
+  type: string;
+  note?: string;
+  available_scripts_types?: string[];
+  context?: string;
+}
+
+export interface KkapiBatchPubkeysResponse {
+  pubkeys: KkapiPubkey[];
+  cached_count: number;
+  total_requested: number;
+  device_id?: string;
+}
+
+export interface KkapiHealthStatus {
+  available: boolean;
+  device_connected: boolean;
+  cached_pubkeys: number;
+  vault_version?: string;
+}
+
+/**
+ * Check if kkapi:// vault is available and ready
+ */
+export async function checkKkapiHealth(baseUrl: string = 'kkapi://'): Promise<KkapiHealthStatus> {
+  try {
+    const healthResponse = await fetch(`${baseUrl}/api/health`);
+    if (!healthResponse.ok) {
+      return { available: false, device_connected: false, cached_pubkeys: 0 };
+    }
+
+    const healthData = await healthResponse.json();
+    if (healthData.cached_pubkeys !== undefined) {
+      return {
+        available: true,
+        device_connected: healthData.device_connected || false,
+        cached_pubkeys: healthData.cached_pubkeys || 0,
+        vault_version: healthData.version
+      };
+    }
+
+    const cacheResponse = await fetch(`${baseUrl}/api/cache/status`);
+    if (!cacheResponse.ok) {
+      return { available: true, device_connected: true, cached_pubkeys: 0 };
+    }
+
+    const cacheData = await cacheResponse.json();
+    return {
+      available: true,
+      device_connected: true,
+      cached_pubkeys: cacheData.cached_pubkeys || 0,
+      vault_version: cacheData.vault_version
+    };
+  } catch (error: any) {
+    return { available: false, device_connected: false, cached_pubkeys: 0 };
+  }
+}
+
+/**
+ * Get multiple pubkeys in a single batch call from kkapi:// vault
+ * Returns cached pubkeys and indicates which paths are missing
+ */
+export async function batchGetPubkeys(paths: any[], context: string, baseUrl: string = 'kkapi://'): Promise<KkapiBatchPubkeysResponse> {
+  try {
+    const batchRequest = {
+      paths: paths.map(path => ({
+        address_n: path.addressNList,
+        script_type: path.script_type,
+        networks: path.networks,
+        type: path.type,
+        note: path.note
+      })),
+      context: context
+    };
+    const response = await fetch(`${baseUrl}/api/pubkeys/batch`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(batchRequest)
+    });
+
+    if (!response.ok) {
+      throw new Error(`Batch request failed: ${response.status}`);
+    }
+
+    const batchResponse: KkapiBatchPubkeysResponse = await response.json();
+    
+    return batchResponse;
+
+  } catch (error: any) {
+    return {
+      pubkeys: [],
+      cached_count: 0,
+      total_requested: paths.length
+    };
+  }
+}
+
+/**
+ * Optimized getPubkeys that uses batch fetching with individual fallback
+ * 
+ * Strategy:
+ * 1. Try batch fetch from kkapi:// vault first (fast)
+ * 2. Audit which pubkeys are missing 
+ * 3. Individual keepkey-sdk calls only for missing ones
+ */
+export async function optimizedGetPubkeys(
+  blockchains: string[], 
+  paths: any[], 
+  keepKeySdk: any, 
+  context: string,
+  getPubkeyFunction: (networkId: string, path: any, sdk: any, context: string) => Promise<any>
+): Promise<any[]> {
+  let baseUrl: string;
+  if (typeof window !== 'undefined' && '__TAURI__' in window) {
+    baseUrl = 'kkapi://';
+  } else if (typeof window !== 'undefined' && window.location.hostname === 'localhost') {
+    baseUrl = 'http://localhost:1646';
+  } else {
+    baseUrl = 'http://localhost:1646';
+  }
+
+  const vaultHealth = await checkKkapiHealth(baseUrl);
+
+  let pubkeys: any[] = [];
+  let remainingPaths: any[] = [];
+  let remainingBlockchains: string[] = [];
+
+  if (vaultHealth.available && vaultHealth.cached_pubkeys > 0) {
+    const batchResponse = await batchGetPubkeys(paths, context, baseUrl);
+    pubkeys = batchResponse.pubkeys;
+    const cachedPaths = new Set(batchResponse.pubkeys.map(p => p.path));
+    
+    for (let i = 0; i < blockchains.length; i++) {
+      const blockchain = blockchains[i];
+      const pathsForChain = paths.filter(path => path.networks && Array.isArray(path.networks) && path.networks.includes(blockchain));
+      
+      for (const path of pathsForChain) {
+        const { addressNListToBIP32 } = await import('@pioneer-platform/pioneer-coins');
+        const pathBip32 = addressNListToBIP32(path.addressNList);
+        
+        if (!cachedPaths.has(pathBip32)) {
+          remainingPaths.push(path);
+          if (!remainingBlockchains.includes(blockchain)) {
+            remainingBlockchains.push(blockchain);
+          }
+        }
+      }
+    }
+  } else {
+    remainingPaths = paths;
+    remainingBlockchains = blockchains;
+  }
+
+  if (remainingPaths.length > 0) {
+    
+    for (let i = 0; i < remainingBlockchains.length; i++) {
+      const blockchain = remainingBlockchains[i];
+      const pathsForChain = remainingPaths.filter(path => path.networks && Array.isArray(path.networks) && path.networks.includes(blockchain));
+      
+      for (const path of pathsForChain) {
+        try {
+          const pubkey = await getPubkeyFunction(blockchain, path, keepKeySdk, context);
+          if (pubkey) {
+            pubkeys.push(pubkey);
+          }
+        } catch (error: any) {
+          throw error;
+        }
+      }
+    }
+  }
+
+  return pubkeys;
+} 

package/src/offline-client.ts

@@ -0,0 +1,287 @@
+// Offline-first client for KeepKey Vault integration
+
+const TAG = ' | offline-client | ';
+
+export interface OfflineClientConfig {
+  vaultUrl: string;
+  timeout: number;
+  fallbackToRemote: boolean;
+}
+
+export interface BootstrapRequest {
+  device_id?: string;
+  paths: string[];
+  include: {
+    pubkeys: boolean;
+    addresses: boolean;
+    balances: boolean;
+    transactions: boolean;
+  };
+  cache_strategy: 'prefer_cache' | 'force_refresh' | 'cache_only';
+}
+
+export interface BootstrapResponse {
+  device_id: string;
+  response_time_ms: number;
+  cache_status: {
+    total_requested: number;
+    cache_hits: number;
+    cache_misses: number;
+    missing_paths: string[];
+    cache_freshness: string;
+  };
+  data: {
+    pubkeys: Record<string, any>;
+    addresses: Record<string, any>;
+    balances: Record<string, any>;
+  };
+  background_tasks: {
+    missing_data_fetch: string;
+    balance_refresh: string;
+    transaction_sync: string;
+  };
+}
+
+export interface FastHealthResponse {
+  status: string;
+  device_connected: boolean;
+  device_id?: string;
+  cache_status: string;
+  response_time_ms: number;
+}
+
+export class OfflineClient {
+  private config: OfflineClientConfig;
+  private isVaultAvailable: boolean = false;
+  private lastHealthCheck: number = 0;
+  private healthCheckCacheMs: number = 5000; // 5 second cache
+
+  constructor(config: OfflineClientConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Fast health check with caching
+   */
+  async checkVaultHealth(forceRefresh = false): Promise<boolean> {
+    const now = Date.now();
+    
+    if (!forceRefresh && (now - this.lastHealthCheck) < this.healthCheckCacheMs) {
+      return this.isVaultAvailable;
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+
+    try {
+      const response = await fetch(`${this.config.vaultUrl}/api/v1/health/fast`, {
+        method: 'GET',
+        signal: controller.signal,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      clearTimeout(timeoutId);
+      
+      if (response.ok) {
+        const health: FastHealthResponse = await response.json();
+        this.isVaultAvailable = health.status === 'healthy';
+        this.lastHealthCheck = now;
+        
+        return this.isVaultAvailable;
+      } else {
+        this.isVaultAvailable = false;
+        return false;
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      this.isVaultAvailable = false;
+      this.lastHealthCheck = now;
+      return false;
+    }
+  }
+
+  /**
+   * Get complete wallet bootstrap data
+   */
+  async getWalletBootstrap(paths: string[], includeOptions = {
+    pubkeys: true,
+    addresses: true,
+    balances: true,
+    transactions: false
+  }): Promise<BootstrapResponse | null> {
+    const isAvailable = await this.checkVaultHealth();
+    if (!isAvailable) {
+      return null;
+    }
+
+    const request: BootstrapRequest = {
+      paths,
+      include: includeOptions,
+      cache_strategy: 'prefer_cache'
+    };
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout * 2);
+
+    try {
+      const startTime = performance.now();
+      
+      const response = await fetch(`${this.config.vaultUrl}/api/v1/wallet/bootstrap`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(request),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        throw new Error(`Bootstrap request failed: ${response.status} ${response.statusText}`);
+      }
+
+      const bootstrap: BootstrapResponse = await response.json();
+
+      return bootstrap;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      return null;
+    }
+  }
+
+  /**
+   * Convert vault bootstrap response to pioneer-sdk format
+   */
+  convertBootstrapToPubkeys(bootstrap: BootstrapResponse): any[] {
+    const pubkeys: any[] = [];
+    
+    for (const [path, pubkeyData] of Object.entries(bootstrap.data.pubkeys)) {
+      const addressData = bootstrap.data.addresses[path];
+      const balanceData = bootstrap.data.balances[path];
+      
+      const pubkey = {
+        pubkey: pubkeyData.pubkey,
+        address: addressData?.address || '',
+        path,
+        pathMaster: path, // For now, same as path
+        networks: this.getNetworksForPath(path),
+        coin: pubkeyData.coin,
+        script_type: addressData?.script_type || 'p2pkh',
+        cached: pubkeyData.cached,
+        source: 'vault_cache'
+      };
+      
+      pubkeys.push(pubkey);
+    }
+    
+    return pubkeys;
+  }
+
+  /**
+   * Get network identifiers for a BIP32 path
+   */
+  private getNetworksForPath(path: string): string[] {
+    const parts = path.split('/');
+    if (parts.length < 3) return ['bitcoin'];
+    
+    const coinType = parts[2].replace("'", "");
+    const coinTypeMap: Record<string, string[]> = {
+      '0': ['bip122:000000000019d6689c085ae165831e93'], // Bitcoin
+      '1': ['bip122:000000000019d6689c085ae165831e93'], // Bitcoin testnet
+      '2': ['bip122:000000000000000082ccf8f1557c5d40'], // Litecoin
+      '3': ['bip122:12a765e31ffd4059bada1e25190f6e98'], // Dogecoin
+      '5': ['bip122:000000000000000000651ef99cb9fcbe'], // Dash
+      '60': ['eip155:1'], // Ethereum
+      '118': ['cosmos:cosmoshub-4'], // Cosmos
+      '144': ['bip122:000000000000000000651ef99cb9fcbe'], // Ripple
+      '145': ['bip122:000000000000000082ccf8f1557c5d40'], // Bitcoin Cash
+    };
+    
+    return coinTypeMap[coinType] || ['bitcoin'];
+  }
+
+  /**
+   * Initialize offline mode
+   */
+  async initOffline(paths: string[]): Promise<{ pubkeys: any[], balances: any[], cached: boolean }> {
+    const startTime = performance.now();
+    const bootstrap = await this.getWalletBootstrap(paths);
+    
+    if (bootstrap) {
+      const pubkeys = this.convertBootstrapToPubkeys(bootstrap);
+      const balances = this.extractBalancesFromBootstrap(bootstrap);
+      
+      return {
+        pubkeys,
+        balances,
+        cached: true
+      };
+    }
+    
+    return {
+      pubkeys: [],
+      balances: [],
+      cached: false
+    };
+  }
+
+  /**
+   * Extract balance information from bootstrap response
+   */
+  private extractBalancesFromBootstrap(bootstrap: BootstrapResponse): any[] {
+    const balances: any[] = [];
+    
+    for (const [path, balanceData] of Object.entries(bootstrap.data.balances)) {
+      const addressData = bootstrap.data.addresses[path];
+      const pubkeyData = bootstrap.data.pubkeys[path];
+      
+      if (balanceData && addressData) {
+        const balance = {
+          address: addressData.address,
+          balance: balanceData.confirmed,
+          unconfirmed: balanceData.unconfirmed,
+          currency: balanceData.currency,
+          valueUsd: balanceData.usd_value,
+          networks: this.getNetworksForPath(path),
+          path,
+          cached: balanceData.cached,
+          last_updated: balanceData.last_updated
+        };
+        
+        balances.push(balance);
+      }
+    }
+    
+    return balances;
+  }
+
+  /**
+   * Get current availability status
+   */
+  isAvailable(): boolean {
+    return this.isVaultAvailable;
+  }
+
+  /**
+   * Background sync
+   */
+  async backgroundSync(paths: string[]): Promise<void> {
+    try {
+      const bootstrap = await this.getWalletBootstrap(paths, {
+        pubkeys: true,
+        addresses: true,
+        balances: true,
+        transactions: true
+      });
+      
+      if (bootstrap) {
+        // TODO: Emit events for updated data
+      }
+    } catch (error) {
+      // Silent error handling
+    }
+  }
+} 

package/src/supportedCaips.ts

@@ -0,0 +1,36 @@
+// supportedCaips.ts
+
+export const UTXO_SUPPORT = [
+  'bip122:000000000019d6689c085ae165831e93/slip44:0', // BTC
+  'bip122:000000000000000000651ef99cb9fcbe/slip44:145', // BCH
+  'bip122:000007d91d1254d60e2dd1ae58038307/slip44:5', // DASH
+  'bip122:00000000001a91e3dace36e2be3bf030/slip44:3', // DOGE
+  'bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2', // LTC
+];
+
+export const TENDERMINT_SUPPORT = [
+  'cosmos:mayachain-mainnet-v1/slip44:931', // CACAO (native)
+  'cosmos:mayachain-mainnet-v1/denom:maya', // MAYA token
+  'cosmos:osmosis-1/slip44:118',
+  'cosmos:cosmoshub-4/slip44:118',
+  'cosmos:kaiyo-1/slip44:118',
+  'cosmos:thorchain-mainnet-v1/slip44:931',
+];
+
+// Mapping of CAIP identifiers to KeepKey coin names for UTXO chains
+export const CAIP_TO_COIN_MAP: { [key: string]: string } = {
+  'bip122:000000000019d6689c085ae165831e93/slip44:0': 'Bitcoin',
+  'bip122:000000000000000000651ef99cb9fcbe/slip44:145': 'BitcoinCash',
+  'bip122:000007d91d1254d60e2dd1ae58038307/slip44:5': 'Dash',
+  'bip122:00000000001a91e3dace36e2be3bf030/slip44:3': 'Dogecoin',
+  'bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2': 'Litecoin',
+};
+
+export const OTHER_SUPPORT = ['ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144'];
+
+export const SUPPORTED_CAIPS = {
+  UTXO: UTXO_SUPPORT,
+  TENDERMINT: TENDERMINT_SUPPORT,
+  EIP155: ['eip155:*'],
+  OTHER: OTHER_SUPPORT,
+};