@pioneer-platform/pioneer-sdk 8.15.41 → 8.17.0

package/package.json

@@ -1,14 +1,14 @@
 {
   "author": "highlander",
   "name": "@pioneer-platform/pioneer-sdk",
-  "version": "8.15.41",
+  "version": "8.17.0",
   "dependencies": {
-    "@keepkey/keepkey-sdk": "^0.2.62",
-    "@pioneer-platform/pioneer-caip": "^9.10.18",
+    "keepkey-vault-sdk": "^1.0.2",
+    "@pioneer-platform/pioneer-caip": "^9.12.0",
     "@pioneer-platform/pioneer-client": "^9.10.24",
-    "@pioneer-platform/pioneer-coins": "^9.11.18",
-    "@pioneer-platform/pioneer-discovery": "^8.15.41",
-    "@pioneer-platform/pioneer-events": "^8.12.13",
+    "@pioneer-platform/pioneer-coins": "^9.13.0",
+    "@pioneer-platform/pioneer-discovery": "^8.17.0",
+    "@pioneer-platform/pioneer-events": "^8.13.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';
@@ -128,6 +128,7 @@ export class SDK {
   public assetsMap: any;
   public dashboard: any;
   public nfts: any[];
+  public pendingTransactions: any[]; // Track recent/pending transactions
   public events: any;
   public pairWallet: (options: any) => Promise<any>;
   public setContext: (context: string) => Promise<{ success: boolean }>;
@@ -236,6 +237,7 @@ export class SDK {
     this.nodes = config.nodes || [];
     this.charts = ['covalent', 'zapper'];
     this.nfts = [];
+    this.pendingTransactions = []; // Initialize empty pending transactions array
     this.isPioneer = null;
     this.pioneer = null;
     this.context = '';
@@ -299,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;
@@ -373,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);
           }
@@ -814,6 +827,46 @@ export class SDK {
         let txManager = new TransactionManager(transactionDependencies, this.events);
         let unsignedTx = await txManager.transfer(sendPayload);
         console.log(tag, 'unsignedTx: ', unsignedTx);
+
+        // CRITICAL: Store transaction details in assetContext for optimistic balance update
+        // These will be used by broadcastTx to debit the balance immediately
+        if (this.assetContext && sendPayload) {
+          this.assetContext.sendAmount = sendPayload.amount;
+          this.assetContext.sendTo = sendPayload.to;
+          this.assetContext.sendMemo = sendPayload.memo;
+
+          // Extract fee from unsignedTx if available
+          // Different chains have different fee structures
+          let estimatedFee = '0';
+          if (unsignedTx) {
+            // UTXO chains
+            if (unsignedTx.fee) {
+              estimatedFee = typeof unsignedTx.fee === 'string'
+                ? unsignedTx.fee
+                : unsignedTx.fee.toString();
+            }
+            // EVM chains
+            else if (unsignedTx.gasPrice && unsignedTx.gasLimit) {
+              const gasPrice = parseFloat(unsignedTx.gasPrice);
+              const gasLimit = parseFloat(unsignedTx.gasLimit);
+              // Convert from gwei to native token (rough estimate)
+              estimatedFee = ((gasPrice * gasLimit) / 1000000000).toFixed(8);
+            }
+            // Tendermint chains
+            else if (unsignedTx.fee && unsignedTx.fee.amount && Array.isArray(unsignedTx.fee.amount)) {
+              estimatedFee = unsignedTx.fee.amount[0]?.amount || '0';
+            }
+          }
+
+          this.assetContext.sendFee = estimatedFee;
+
+          console.log(tag, '💾 Stored transaction details for optimistic update:', {
+            amount: this.assetContext.sendAmount,
+            fee: this.assetContext.sendFee,
+            to: this.assetContext.sendTo
+          });
+        }
+
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -943,12 +996,149 @@ export class SDK {
           serialized: signedTx,
         };
         let txid = await txManager.broadcast(payload);
+
+        // OPTIMISTIC UPDATE: Debit balance immediately after successful broadcast
+        if (txid && !txid.error) {
+          // Extract transaction details from assetContext (set during buildTx)
+          const amount = this.assetContext?.sendAmount || '0';
+          const fee = this.assetContext?.sendFee || '0';
+          const to = this.assetContext?.sendTo || '';
+          const from = this.pubkeyContext?.address || this.pubkeyContext?.master || '';
+
+          // Only perform optimistic update if we have valid transaction details
+          if (amount !== '0' && parseFloat(amount) > 0) {
+            console.log(tag, '💰 Performing optimistic balance update:', {
+              caip,
+              amount,
+              fee,
+              from,
+              to
+            });
+
+            // Debit the balance optimistically
+            this.debitBalance(caip, amount, fee);
+
+            // Track pending transaction
+            this.addPendingTransaction({
+              txid,
+              caip,
+              amount,
+              to,
+              from,
+              fee,
+              broadcastTime: Date.now(),
+              status: 'pending'
+            });
+          }
+        }
+
         return txid;
       } catch (e) {
         console.error(e);
         throw e;
       }
     };
+
+    // Add pending transaction to tracking array
+    this.addPendingTransaction = function (txData: {
+      txid: string;
+      caip: string;
+      amount: string;
+      to: string;
+      from: string;
+      fee: string;
+      broadcastTime: number;
+      status: 'pending' | 'confirmed' | 'failed';
+    }) {
+      const tag = TAG + ' | addPendingTransaction | ';
+      console.log(tag, 'Adding pending transaction:', txData);
+
+      // Add to pending transactions array (most recent first)
+      this.pendingTransactions.unshift({
+        ...txData,
+        status: txData.status || 'pending',
+        addedAt: Date.now()
+      });
+
+      // Keep only last 50 pending transactions to avoid memory bloat
+      if (this.pendingTransactions.length > 50) {
+        this.pendingTransactions = this.pendingTransactions.slice(0, 50);
+      }
+
+      // Emit events for UI updates
+      this.events.emit('PENDING_TX_ADDED', txData);
+      this.events.emit('PENDING_TXS_UPDATED', this.pendingTransactions);
+
+      console.log(tag, `Pending transactions count: ${this.pendingTransactions.length}`);
+
+      return txData;
+    };
+
+    // Optimistically debit balance after broadcast (before confirmation)
+    this.debitBalance = function (caip: string, amount: string, fee: string = '0') {
+      const tag = TAG + ' | debitBalance | ';
+      console.log(tag, 'Debiting balance:', { caip, amount, fee });
+
+      // Find the balance entry for this asset
+      const balanceIndex = this.balances.findIndex((b: any) => b.caip === caip);
+
+      if (balanceIndex === -1) {
+        console.warn(tag, 'Balance not found for CAIP:', caip);
+        return null;
+      }
+
+      const currentBalance = this.balances[balanceIndex];
+      const currentBalanceNum = parseFloat(currentBalance.balance || '0');
+      const amountNum = parseFloat(amount);
+      const feeNum = parseFloat(fee);
+      const totalDebit = amountNum + feeNum;
+
+      // Calculate new balance
+      const newBalanceNum = currentBalanceNum - totalDebit;
+
+      // Safety check: don't allow negative balance
+      if (newBalanceNum < 0) {
+        console.warn(tag, 'Cannot debit - would result in negative balance:', {
+          current: currentBalanceNum,
+          debit: totalDebit,
+          result: newBalanceNum
+        });
+        return null;
+      }
+
+      // Update the balance with optimistic flag
+      const updatedBalance = {
+        ...currentBalance,
+        balance: newBalanceNum.toFixed(8),
+        valueUsd: newBalanceNum * (parseFloat(currentBalance.priceUsd) || 0),
+        updated: Date.now(),
+        optimistic: true, // Mark as optimistic update (will be replaced by real data on next sync)
+        previousBalance: currentBalanceNum // Store previous balance for rollback if needed
+      };
+
+      this.balances[balanceIndex] = updatedBalance;
+
+      console.log(tag, '✅ Balance updated:', {
+        previous: currentBalanceNum.toFixed(8),
+        new: newBalanceNum.toFixed(8),
+        deducted: totalDebit.toFixed(8)
+      });
+
+      // Emit balance update events
+      this.events.emit('BALANCES_UPDATED', this.balances);
+      this.events.emit('SET_BALANCES', this.balances);
+
+      // Rebuild dashboard with updated balances
+      try {
+        this.dashboard = this.buildDashboardFromBalances();
+        this.events.emit('SET_DASHBOARD', this.dashboard);
+        console.log(tag, '✅ Dashboard rebuilt with updated balance');
+      } catch (dashboardError) {
+        console.error(tag, 'Error rebuilding dashboard:', dashboardError);
+      }
+
+      return updatedBalance;
+    };
     this.swap = async function (swapPayload) {
       let tag = `${TAG} | swap | `;
       try {
@@ -1622,6 +1812,14 @@ export class SDK {
         const assetQuery: { caip: string; pubkey: string }[] = [];
         for (const networkId of networkIds) {
           const pubkeys = findPubkeysForNetwork(this.pubkeys, networkId, this.paths, tag);
+          console.log(`🔍 [DIAGNOSTIC] ${networkId}: Found ${pubkeys.length} pubkeys`);
+          if (networkId.startsWith('bip122:000000000019')) {
+            console.log('🔍 [BITCOIN DIAGNOSTIC] Bitcoin pubkeys:', pubkeys.map((p: any) => ({
+              pubkey: p.pubkey?.substring(0, 20) + '...',
+              networks: p.networks,
+              symbol: p.symbol
+            })));
+          }
           const caip = await networkIdToCaip(networkId);
           assetQuery.push(...buildAssetQuery(pubkeys, caip));
         }
@@ -1653,8 +1851,36 @@ export class SDK {
 
         console.log(`⏱️  [PERF] Enrichment completed in ${(performance.now() - enrichStart).toFixed(0)}ms`);
 
-        // Update state and emit events
-        this.balances = balances;
+        // 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`);
+
+        // Create a Map with identifier as key to deduplicate
+        // Put NEW balances LAST so they override stale cached data
+        const uniqueBalances = new Map(
+          [...this.balances, ...balances].map((balance: any) => [
+            balance.identifier || `${balance.caip}:${balance.pubkey}`,
+            balance
+          ])
+        );
+
+        const beforeCount = [...this.balances, ...balances].length;
+        this.balances = Array.from(uniqueBalances.values());
+        const duplicatesRemoved = beforeCount - this.balances.length;
+
+        if (duplicatesRemoved > 0) {
+          console.log(tag, `🔧 Removed ${duplicatesRemoved} duplicate balances`);
+        }
+
+        console.log(tag, `✅ Final balance count: ${this.balances.length} unique balances`);
+
+        // Emit events
         this.events.emit('SET_BALANCES', this.balances);
 
         // Build and emit dashboard
@@ -1852,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)
@@ -1902,7 +2132,7 @@ export class SDK {
           'bip122:12a765e31ffd4059bada1e25190f6e98': { address: 'https://blockchair.com/litecoin/address/', tx: 'https://blockchair.com/litecoin/transaction/' },
           'bip122:00000000001a91e3dace36e2be3bf030': { address: 'https://dogechain.info/address/', tx: 'https://dogechain.info/tx/' },
           'bip122:000000000000000000651ef99cb9fcbe': { address: 'https://blockchair.com/bitcoin-cash/address/', tx: 'https://blockchair.com/bitcoin-cash/transaction/' },
-          'bip122:000007d91d1254d60e2dd1ae58038307': { address: 'https://chainz.cryptoid.info/dash/address.dws?', tx: 'https://chainz.cryptoid.info/dash/tx.dws?' },
+          'bip122:000007d91d1254d60e2dd1ae58038307': { address: 'https://explorer.dash.org/insight/address/', tx: 'https://explorer.dash.org/insight/tx/' },
           'bip122:4da631f2ac1bed857bd968c67c913978': { address: 'https://digiexplorer.info/address/', tx: 'https://digiexplorer.info/tx/' },
           'bip122:00040fe8ec8471911baa1db1266ea15d': { address: 'https://explorer.zcha.in/accounts/', tx: 'https://explorer.zcha.in/transactions/' },
           'cosmos:cosmoshub-4': { address: 'https://www.mintscan.io/cosmos/address/', tx: 'https://www.mintscan.io/cosmos/tx/' },
@@ -2109,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);