@pioneer-platform/pioneer-sdk 8.15.41 → 8.17.0

package/src/kkapi-batch-client.ts

@@ -32,42 +32,93 @@ export interface KkapiHealthStatus {
   device_connected: boolean;
   cached_pubkeys: number;
   vault_version?: string;
+  apiVersion?: number;
+  supportedChains?: string[];
 }
 
 /**
  * Check if kkapi:// vault is available and ready
  */
 export async function checkKkapiHealth(baseUrl: string = 'kkapi://'): Promise<KkapiHealthStatus> {
+  // Default V1 supported chains (legacy chains without Solana, TRON, TON)
+  const V1_SUPPORTED_CHAINS = [
+    'bip122:000000000019d6689c085ae165831e93',  // BTC
+    'bip122:000000000000000000651ef99cb9fcbe',  // BCH
+    'bip122:000007d91d1254d60e2dd1ae58038307',  // DASH
+    'bip122:00000000001a91e3dace36e2be3bf030',  // DOGE
+    'bip122:12a765e31ffd4059bada1e25190f6e98',  // LTC
+    'bip122:4da631f2ac1bed857bd968c67c913978',  // DGB
+    'bip122:00040fe8ec8471911baa1db1266ea15d',  // ZEC
+    'eip155:1',      // ETH
+    'eip155:137',    // MATIC
+    'eip155:8453',   // BASE
+    'eip155:56',     // BSC
+    'cosmos:cosmoshub-4',          // ATOM
+    'cosmos:osmosis-1',            // OSMO
+    'cosmos:mayachain-mainnet-v1', // MAYA
+    'cosmos:thorchain-mainnet-v1', // RUNE
+    'ripple:4109c6f2045fc7eff4cde8f9905d19c2',  // XRP
+  ];
+
   try {
     const healthResponse = await fetch(`${baseUrl}/api/health`);
+
+    // If health endpoint doesn't exist (404), assume v1 server (Desktop app)
+    if (healthResponse.status === 404) {
+      console.log('📡 [VERSION] No /api/health endpoint - assuming v1 server (Desktop app)');
+      return {
+        available: true,
+        device_connected: true,
+        cached_pubkeys: 0,
+        apiVersion: 1,
+        supportedChains: V1_SUPPORTED_CHAINS
+      };
+    }
+
     if (!healthResponse.ok) {
-      return { available: false, device_connected: false, cached_pubkeys: 0 };
+      return {
+        available: false,
+        device_connected: false,
+        cached_pubkeys: 0,
+        apiVersion: 1,
+        supportedChains: V1_SUPPORTED_CHAINS
+      };
     }
 
     const healthData = await healthResponse.json();
-    if (healthData.cached_pubkeys !== undefined) {
+
+    // V2 server returns apiVersion and supportedChains
+    if (healthData.apiVersion === 2 && healthData.supportedChains) {
       return {
         available: true,
         device_connected: healthData.device_connected || false,
         cached_pubkeys: healthData.cached_pubkeys || 0,
-        vault_version: healthData.version
+        vault_version: healthData.version,
+        apiVersion: healthData.apiVersion,
+        supportedChains: healthData.supportedChains
       };
     }
 
-    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();
+    // V1 server or old format - use default v1 chains
     return {
       available: true,
-      device_connected: true,
-      cached_pubkeys: cacheData.cached_pubkeys || 0,
-      vault_version: cacheData.vault_version
+      device_connected: healthData.device_connected || false,
+      cached_pubkeys: healthData.cached_pubkeys || 0,
+      vault_version: healthData.version,
+      apiVersion: 1,
+      supportedChains: V1_SUPPORTED_CHAINS
     };
+
   } catch (error: any) {
-    return { available: false, device_connected: false, cached_pubkeys: 0 };
+    // Network error or server unreachable - assume v1 for backward compatibility
+    console.log('📡 [VERSION] Health check failed - assuming v1 server');
+    return {
+      available: false,
+      device_connected: false,
+      cached_pubkeys: 0,
+      apiVersion: 1,
+      supportedChains: V1_SUPPORTED_CHAINS
+    };
   }
 }
 
@@ -138,6 +189,28 @@ export async function optimizedGetPubkeys(
 
   const vaultHealth = await checkKkapiHealth(baseUrl);
 
+  // Filter blockchains based on server's supportedChains
+  let supportedBlockchains = blockchains;
+  if (vaultHealth.supportedChains && vaultHealth.supportedChains.length > 0) {
+    console.log(`📡 [VERSION] Server API v${vaultHealth.apiVersion} supports ${vaultHealth.supportedChains.length} chains`);
+
+    // Filter blockchains to only include ones the server supports
+    const unsupportedBlockchains: string[] = [];
+    supportedBlockchains = blockchains.filter(blockchain => {
+      // Check if this blockchain is in the server's supported list
+      const isSupported = vaultHealth.supportedChains!.includes(blockchain);
+      if (!isSupported) {
+        unsupportedBlockchains.push(blockchain);
+      }
+      return isSupported;
+    });
+
+    if (unsupportedBlockchains.length > 0) {
+      console.log(`⏭️  [VERSION] Skipping ${unsupportedBlockchains.length} unsupported chains:`, unsupportedBlockchains.join(', '));
+    }
+    console.log(`✅ [VERSION] Using ${supportedBlockchains.length} supported chains`);
+  }
+
   let pubkeys: any[] = [];
   let remainingPaths: any[] = [];
   let remainingBlockchains: string[] = [];
@@ -146,15 +219,15 @@ export async function optimizedGetPubkeys(
     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];
+
+    for (let i = 0; i < supportedBlockchains.length; i++) {
+      const blockchain = supportedBlockchains[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)) {
@@ -164,8 +237,12 @@ export async function optimizedGetPubkeys(
       }
     }
   } else {
-    remainingPaths = paths;
-    remainingBlockchains = blockchains;
+    // Filter paths to only include supported blockchains
+    remainingPaths = paths.filter(path =>
+      path.networks && Array.isArray(path.networks) &&
+      path.networks.some((network: string) => supportedBlockchains.includes(network))
+    );
+    remainingBlockchains = supportedBlockchains;
   }
 
   if (remainingPaths.length > 0) {

package/src/supportedCaips.ts

@@ -30,7 +30,12 @@ export const CAIP_TO_COIN_MAP: { [key: string]: string } = {
   'bip122:00040fe8ec8471911baa1db1266ea15d/slip44:133': 'Zcash',
 };
 
-export const OTHER_SUPPORT = ['ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144'];
+export const OTHER_SUPPORT = [
+  'ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144', // XRP
+  'solana:5eykt4usfv8p8njdtrepy1vzqkqzkvdp/solana:so11111111111111111111111111111111111111112', // SOL
+  'tron:0x2b6653dc/slip44:195',  // TRX
+  'ton:-239/slip44:607',          // TON
+];
 
 export const SUPPORTED_CAIPS = {
   UTXO: UTXO_SUPPORT,

package/src/txbuilder/createUnsignedSolanaTx.ts

@@ -0,0 +1,132 @@
+/*
+  Create Unsigned Solana Transaction
+*/
+// @ts-ignore
+import { caipToNetworkId } from '@pioneer-platform/pioneer-caip';
+// @ts-ignore
+import {
+  Connection,
+  PublicKey,
+  Transaction,
+  SystemProgram,
+  LAMPORTS_PER_SOL,
+} from '@solana/web3.js';
+
+const TAG = ' | createUnsignedSolanaTx | ';
+
+// Default Solana RPC (could be made configurable)
+const DEFAULT_RPC_URL = 'https://api.mainnet-beta.solana.com';
+
+export async function createUnsignedSolanaTx(
+  caip: string,
+  to: string,
+  amount: any,
+  memo: string,
+  pubkeys: any,
+  pioneer: any,
+  pubkeyContext: any,
+  isMax: boolean,
+): Promise<any> {
+  let tag = TAG + ' | createUnsignedSolanaTx | ';
+
+  try {
+    if (!pioneer) throw new Error('Failed to init! pioneer');
+
+    // Determine networkId from caip
+    const networkId = caipToNetworkId(caip);
+
+    // Use the passed pubkeyContext directly - it's already been set by Pioneer SDK
+    if (!pubkeyContext) {
+      throw new Error(`No pubkey context provided for networkId: ${networkId}`);
+    }
+
+    if (!pubkeyContext.networks?.includes(networkId)) {
+      throw new Error(
+        `Pubkey context is for wrong network. Expected ${networkId}, got ${pubkeyContext.networks}`,
+      );
+    }
+
+    console.log(tag, `✅ Using pubkeyContext for network ${networkId}:`, {
+      address: pubkeyContext.address,
+    });
+
+    const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
+
+    // Get account balance to calculate max amount if needed
+    let accountInfo = await pioneer.GetAccountInfo({
+      address: fromAddress,
+      network: 'solana',
+    });
+    accountInfo = accountInfo.data;
+
+    // Calculate amount
+    let amountInSol: number;
+    if (isMax) {
+      // Reserve fee (approximately 0.000005 SOL = 5000 lamports)
+      const feeInSol = 0.000005;
+      amountInSol = parseFloat(accountInfo.balance) - feeInSol;
+      if (amountInSol <= 0) {
+        throw new Error('Insufficient balance to cover fee');
+      }
+    } else {
+      amountInSol = parseFloat(amount);
+    }
+
+    // Build transaction using @solana/web3.js
+    const connection = new Connection(DEFAULT_RPC_URL, 'confirmed');
+
+    // Convert to PublicKey objects
+    const fromPubkey = new PublicKey(fromAddress);
+    const toPubkey = new PublicKey(to);
+
+    // Convert SOL to lamports
+    const lamports = Math.floor(amountInSol * LAMPORTS_PER_SOL);
+
+    // Get recent blockhash
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+
+    // Create transfer instruction
+    const transferInstruction = SystemProgram.transfer({
+      fromPubkey,
+      toPubkey,
+      lamports,
+    });
+
+    // Create transaction
+    const transaction = new Transaction({
+      feePayer: fromPubkey,
+      blockhash,
+      lastValidBlockHeight,
+    }).add(transferInstruction);
+
+    // Add memo instruction if provided
+    if (memo && memo.trim() !== '') {
+      // TODO: Add memo instruction
+      console.log(tag, 'Memo support not yet implemented');
+    }
+
+    // Serialize transaction message for signing
+    const serialized = transaction.serializeMessage();
+
+    const unsignedTx = {
+      transaction,
+      serialized: serialized.toString('base64'),
+      blockhash,
+      lastValidBlockHeight,
+      addressNList: pubkeyContext.addressNList || pubkeyContext.addressNListMaster,
+      fromAddress,
+      toAddress: to,
+      amount: amountInSol,
+      lamports,
+      caip,
+      networkId,
+    };
+
+    console.log(tag, '✅ Solana transaction built successfully');
+
+    return unsignedTx;
+  } catch (error) {
+    console.error(tag, 'Error:', error);
+    throw error;
+  }
+}

package/src/txbuilder/createUnsignedTronTx.ts

@@ -0,0 +1,97 @@
+/*
+  Create Unsigned TRON Transaction
+*/
+// @ts-ignore
+import { caipToNetworkId } from '@pioneer-platform/pioneer-caip';
+
+const TAG = ' | createUnsignedTronTx | ';
+
+export async function createUnsignedTronTx(
+  caip: string,
+  to: string,
+  amount: any,
+  memo: string,
+  pubkeys: any,
+  pioneer: any,
+  pubkeyContext: any,
+  isMax: boolean,
+): Promise<any> {
+  let tag = TAG + ' | createUnsignedTronTx | ';
+
+  try {
+    if (!pioneer) throw new Error('Failed to init! pioneer');
+
+    // Determine networkId from caip
+    const networkId = caipToNetworkId(caip);
+
+    // Use the passed pubkeyContext directly - it's already been set by Pioneer SDK
+    if (!pubkeyContext) {
+      throw new Error(`No pubkey context provided for networkId: ${networkId}`);
+    }
+
+    if (!pubkeyContext.networks?.includes(networkId)) {
+      throw new Error(
+        `Pubkey context is for wrong network. Expected ${networkId}, got ${pubkeyContext.networks}`,
+      );
+    }
+
+    console.log(tag, `✅ Using pubkeyContext for network ${networkId}:`, {
+      address: pubkeyContext.address,
+    });
+
+    const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
+
+    // Calculate amount in TRX (6 decimals for TRON)
+    let amountInTrx: number;
+    if (isMax) {
+      // For max transfers, get account balance
+      try {
+        let accountInfo = await pioneer.GetAccountInfo({
+          address: fromAddress,
+          network: 'tron',
+        });
+        accountInfo = accountInfo.data;
+
+        // Reserve fee (approximately 0.1 TRX)
+        const feeInTrx = 0.1;
+        amountInTrx = parseFloat(accountInfo.balance) - feeInTrx;
+        if (amountInTrx <= 0) {
+          throw new Error('Insufficient balance to cover fee');
+        }
+      } catch (e: any) {
+        console.warn(tag, 'GetAccountInfo not available for TRON, max transfer not supported:', e.message);
+        throw new Error('Max transfer not supported for TRON - Pioneer backend needs TRON account info support');
+      }
+    } else {
+      // For non-max transfers, use the provided amount directly
+      amountInTrx = parseFloat(amount);
+    }
+
+    // Convert TRX to sun (1 TRX = 1,000,000 sun)
+    const amountInSun = Math.floor(amountInTrx * 1000000);
+
+    // Build unsigned transaction object for TRON
+    const unsignedTx = {
+      from: fromAddress,
+      to: to,
+      amount: amountInTrx,
+      amountInSun: amountInSun,
+      memo: memo || '',
+      addressNList: pubkeyContext.addressNList || pubkeyContext.addressNListMaster,
+      caip,
+      networkId,
+    };
+
+    console.log(tag, '✅ TRON transaction built successfully');
+    console.log(tag, 'Transaction details:', {
+      from: fromAddress,
+      to: to,
+      amount: `${amountInTrx} TRX (${amountInSun} sun)`,
+    });
+
+    return unsignedTx;
+  } catch (error) {
+    console.error(tag, 'Error:', error);
+    throw error;
+  }
+}

package/src/utils/portfolio-helpers.ts

@@ -57,8 +57,8 @@ const EXPLORER_BASE_URLS: Record<string, { address: string; tx: string }> = {
   },
   // Dash
   'bip122:000007d91d1254d60e2dd1ae58038307': {
-    address: 'https://chainz.cryptoid.info/dash/address.dws?',
-    tx: 'https://chainz.cryptoid.info/dash/tx.dws?'
+    address: 'https://explorer.dash.org/insight/address/',
+    tx: 'https://explorer.dash.org/insight/tx/'
   },
   // DigiByte
   'bip122:4da631f2ac1bed857bd968c67c913978': {