@pioneer-platform/pioneer-sdk 8.15.44 → 8.19.0

package/package.json

@@ -1,14 +1,14 @@
 {
   "author": "highlander",
   "name": "@pioneer-platform/pioneer-sdk",
-  "version": "8.15.44",
+  "version": "8.19.0",
   "dependencies": {
-    "@keepkey/keepkey-sdk": "^0.2.62",
-    "@pioneer-platform/pioneer-caip": "^9.10.21",
+    "keepkey-vault-sdk": "^1.0.2",
+    "@pioneer-platform/pioneer-caip": "^9.14.0",
     "@pioneer-platform/pioneer-client": "^9.10.24",
-    "@pioneer-platform/pioneer-coins": "^9.11.21",
-    "@pioneer-platform/pioneer-discovery": "^8.15.44",
-    "@pioneer-platform/pioneer-events": "^8.12.13",
+    "@pioneer-platform/pioneer-coins": "^9.15.0",
+    "@pioneer-platform/pioneer-discovery": "^8.19.0",
+    "@pioneer-platform/pioneer-events": "^8.15.0",
     "coinselect": "^3.1.13",
     "eventemitter3": "^5.0.1",
     "neotraverse": "^0.6.8",

package/src/TransactionManager.ts

@@ -6,7 +6,9 @@ import type EventEmitter from 'events';
 import { CAIP_TO_COIN_MAP, SUPPORTED_CAIPS } from './supportedCaips';
 import { createUnsignedEvmTx } from './txbuilder/createUnsignedEvmTx';
 import { createUnsignedRippleTx } from './txbuilder/createUnsignedRippleTx';
+import { createUnsignedSolanaTx } from './txbuilder/createUnsignedSolanaTx';
 import { createUnsignedTendermintTx } from './txbuilder/createUnsignedTendermintTx';
+import { createUnsignedTronTx } from './txbuilder/createUnsignedTronTx';
 import { createUnsignedUxtoTx } from './txbuilder/createUnsignedUxtoTx';
 
 const TAG = ' | Transaction | ';
@@ -138,16 +140,43 @@ export class TransactionManager {
           break;
         }
         case 'OTHER': {
-          unsignedTx = await createUnsignedRippleTx(
-            caip,
-            to,
-            amount,
-            memo,
-            this.pubkeys,
-            this.pioneer,
-            this.pubkeyContext,
-            isMax,
-          );
+          // Distinguish between different chains in the OTHER category
+          if (caip.startsWith('solana:')) {
+            unsignedTx = await createUnsignedSolanaTx(
+              caip,
+              to,
+              amount,
+              memo,
+              this.pubkeys,
+              this.pioneer,
+              this.pubkeyContext,
+              isMax,
+            );
+          } else if (caip === 'ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144') {
+            unsignedTx = await createUnsignedRippleTx(
+              caip,
+              to,
+              amount,
+              memo,
+              this.pubkeys,
+              this.pioneer,
+              this.pubkeyContext,
+              isMax,
+            );
+          } else if (caip.startsWith('tron:')) {
+            unsignedTx = await createUnsignedTronTx(
+              caip,
+              to,
+              amount,
+              memo,
+              this.pubkeys,
+              this.pioneer,
+              this.pubkeyContext,
+              isMax,
+            );
+          } else {
+            throw new Error(`Unsupported OTHER CAIP for transaction building: ${caip}`);
+          }
           break;
         }
         default: {
@@ -331,10 +360,79 @@ export class TransactionManager {
           break;
         }
         case 'OTHER': {
-          if (caip === 'ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144') {
+          if (caip.startsWith('solana:')) {
+            // Solana signing via keepkey-server REST API
+            const solanaSignRequest = {
+              addressNList: unsignedTx.addressNList,
+              serialized: unsignedTx.serialized,
+              fromAddress: unsignedTx.fromAddress,
+              toAddress: unsignedTx.toAddress,
+              lamports: unsignedTx.lamports,
+              blockhash: unsignedTx.blockhash
+            };
+
+            try {
+              const response = await fetch('http://localhost:1646/solana/sign-transaction', {
+                method: 'POST',
+                headers: {
+                  'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(solanaSignRequest)
+              });
+
+              if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(`Solana signing failed: ${errorData.error || response.statusText}`);
+              }
+
+              const responseSign = await response.json();
+              if (responseSign?.serialized) {
+                signedTx = responseSign.serialized;
+              } else {
+                throw new Error('Solana signing failed - no serialized transaction in response');
+              }
+            } catch (e: any) {
+              console.error(tag, 'Solana signing error:', e);
+              throw new Error(`Solana signing failed: ${e.message}`);
+            }
+          } else if (caip === 'ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144') {
             let responseSign = await this.keepKeySdk.xrp.xrpSignTransaction(unsignedTx);
             if (typeof responseSign === 'string') responseSign = JSON.parse(responseSign);
             signedTx = responseSign.value.signatures[0].serializedTx;
+          } else if (caip.startsWith('tron:')) {
+            // TRON signing via keepkey-server REST API
+            const tronSignRequest = {
+              addressNList: unsignedTx.addressNList,
+              from: unsignedTx.from,
+              to: unsignedTx.to,
+              amount: unsignedTx.amountInSun,
+              memo: unsignedTx.memo || '',
+            };
+
+            try {
+              const response = await fetch('http://localhost:1646/tron/sign-transaction', {
+                method: 'POST',
+                headers: {
+                  'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(tronSignRequest)
+              });
+
+              if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(`TRON signing failed: ${errorData.error || response.statusText}`);
+              }
+
+              const responseSign = await response.json();
+              if (responseSign?.serialized) {
+                signedTx = responseSign.serialized;
+              } else {
+                throw new Error('TRON signing failed - no serialized transaction in response');
+              }
+            } catch (e: any) {
+              console.error(tag, 'TRON signing error:', e);
+              throw new Error(`TRON signing failed: ${e.message}`);
+            }
           } else {
             throw new Error(`Unsupported OTHER CAIP: ${caip}`);
           }

package/src/getPubkey.ts

@@ -38,7 +38,9 @@ export const getPubkey = async (networkId: string, path: any, sdk: any, context:
       'eip155:137': 'EVM',
       'eip155:*': 'EVM',
       'ripple:4109c6f2045fc7eff4cde8f9905d19c2': 'XRP',
-      'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': 'SOLANA',  // Solana (not yet supported by KeepKey)
+      'solana:5eykt4usfv8p8njdtrepy1vzqkqzkvdp': 'SOLANA',  // Solana
+      'tron:0x2b6653dc': 'TRON',  // TRON (Shasta testnet)
+      'ton:-239': 'TON',  // TON (testnet)
       'zcash:main': 'UTXO',
     };
 
@@ -73,8 +75,32 @@ export const getPubkey = async (networkId: string, path: any, sdk: any, context:
           ({ address } = await sdk.address.xrpGetAddress(addressInfo));
           break;
         case 'SOLANA':
-          console.warn(`⚠️ Solana address derivation not yet supported by KeepKey SDK. Skipping ${networkId}`);
-          return null;  // Skip Solana for now until KeepKey SDK supports it
+          // Check if SDK has solanaGetAddress method
+          if (sdk.address.solanaGetAddress) {
+            ({ address } = await sdk.address.solanaGetAddress(addressInfo));
+          } else {
+            console.warn(`⚠️ Solana address derivation not yet supported by KeepKey SDK. Skipping ${networkId}`);
+            return null;
+          }
+          break;
+        case 'TRON':
+          // Check if SDK has tronGetAddress method
+          if (sdk.address.tronGetAddress) {
+            ({ address } = await sdk.address.tronGetAddress(addressInfo));
+          } else {
+            console.warn(`⚠️ TRON address derivation not yet supported by KeepKey SDK. Skipping ${networkId}`);
+            return null;
+          }
+          break;
+        case 'TON':
+          // Check if SDK has tonGetAddress method
+          if (sdk.address.tonGetAddress) {
+            ({ address } = await sdk.address.tonGetAddress(addressInfo));
+          } else {
+            console.warn(`⚠️ TON address derivation not yet supported by KeepKey SDK. Skipping ${networkId}`);
+            return null;
+          }
+          break;
         default:
           throw new Error(`Unsupported network type for networkId: ${networkId}`);
       }

package/src/index.ts

@@ -1,4 +1,4 @@
-import { KeepKeySdk } from '@keepkey/keepkey-sdk';
+import { KeepKeySdk } from 'keepkey-vault-sdk';
 import { caipToNetworkId, networkIdToCaip } from '@pioneer-platform/pioneer-caip';
 import { Pioneer } from '@pioneer-platform/pioneer-client';
 import { addressNListToBIP32, getPaths } from '@pioneer-platform/pioneer-coins';
@@ -10,7 +10,7 @@ import { getCharts } from './charts/index.js';
 //internal
 import { logger } from './utils/logger.js';
 import { getPubkey } from './getPubkey.js';
-import { optimizedGetPubkeys } from './kkapi-batch-client.js';
+import { optimizedGetPubkeys, checkKkapiHealth } from './kkapi-batch-client.js';
 import { OfflineClient } from './offline-client.js';
 import { TransactionManager } from './TransactionManager.js';
 import { createUnsignedTendermintTx } from './txbuilder/createUnsignedTendermintTx.js';
@@ -301,6 +301,11 @@ export class SDK {
       const key = getPubkeyKey(pubkey);
       if (this.pubkeySet.has(key)) return false;
 
+      // PHASE 4: Normalize network IDs to lowercase for consistency
+      if (pubkey.networks && Array.isArray(pubkey.networks)) {
+        pubkey.networks = pubkey.networks.map((n: string) => n.toLowerCase());
+      }
+
       this.pubkeys.push(pubkey);
       this.pubkeySet.add(key);
       return true;
@@ -375,6 +380,12 @@ export class SDK {
 
           // Update SDK state if we have balances
           if (allBalances.length > 0) {
+            // PHASE 5: Normalize all CAIPs to lowercase for consistency
+            allBalances.forEach((balance: any) => {
+              if (balance.caip) balance.caip = balance.caip.toLowerCase();
+              if (balance.networkId) balance.networkId = balance.networkId.toLowerCase();
+            });
+
             this.balances = allBalances;
             this.events.emit('SET_BALANCES', this.balances);
           }
@@ -1840,6 +1851,12 @@ export class SDK {
 
         console.log(`⏱️  [PERF] Enrichment completed in ${(performance.now() - enrichStart).toFixed(0)}ms`);
 
+        // PHASE 5: Normalize all CAIPs to lowercase for consistency
+        balances.forEach((balance: any) => {
+          if (balance.caip) balance.caip = balance.caip.toLowerCase();
+          if (balance.networkId) balance.networkId = balance.networkId.toLowerCase();
+        });
+
         // CRITICAL: Deduplicate balances BEFORE setting
         // Merge new balances with existing balances, deduplicating by identifier (caip:pubkey)
         console.log(tag, `⚙️  Merging balances: ${balances.length} new + ${this.balances.length} existing`);
@@ -2061,6 +2078,10 @@ export class SDK {
         }
 
         if (!asset.caip) throw Error('Invalid Asset! missing caip!');
+
+        // PHASE 6: Normalize CAIP to lowercase for consistency
+        asset.caip = asset.caip.toLowerCase();
+
         if (!asset.networkId) asset.networkId = caipToNetworkId(asset.caip);
 
         // Validate pubkeys for network (throws descriptive errors)
@@ -2318,6 +2339,10 @@ export class SDK {
         }
 
         if (!asset.caip) throw Error('Invalid Asset! missing caip!');
+
+        // PHASE 6: Normalize CAIP to lowercase for consistency
+        asset.caip = asset.caip.toLowerCase();
+
         if (!asset.networkId) asset.networkId = caipToNetworkId(asset.caip);
 
         console.log(tag, 'networkId:', asset.networkId);

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;
+  }
+}