@pioneer-platform/pioneer-sdk 4.20.0 → 4.20.2

package/src/txbuilder/createUnsignedEvmTx.ts

@@ -98,7 +98,7 @@ export async function createUnsignedEvmTx(
   memo,
   pubkeys,
   pioneer,
-  keepKeySdk,
+  pubkeyContext,
   isMax,
   feeLevel = 5, // Added feeLevel parameter with default of 5 (average)
 ) {
@@ -112,6 +112,11 @@ export async function createUnsignedEvmTx(
     // Extract chainId from networkId
     const chainId = extractChainIdFromNetworkId(networkId);
 
+    // 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}`);
+    }
+
     // Check if context is valid for this network
     const isValidForNetwork = (pubkey: any) => {
       if (!pubkey?.networks) return false;
@@ -122,66 +127,116 @@ export async function createUnsignedEvmTx(
       // For non-EVM, check exact match
       return pubkey.networks.includes(networkId);
     };
-    
-    // Check if we have a context at all
-    if (!keepKeySdk.pubkeyContext) {
-      console.log(tag, 'No context set - auto-selecting first matching pubkey');
-      keepKeySdk.pubkeyContext = pubkeys.find(pk => isValidForNetwork(pk));
-    } else {
-      // We have a context - check if it's valid for this network
-      console.log(tag, 'Current context networks:', keepKeySdk.pubkeyContext.networks, 'For networkId:', networkId);
-      
-      if (!isValidForNetwork(keepKeySdk.pubkeyContext)) {
-        // Context exists but wrong network - auto-correct
-        console.log(tag, 'Auto-correcting context - wrong network detected');
-        keepKeySdk.pubkeyContext = pubkeys.find(pk => isValidForNetwork(pk));
-      } else {
-        console.log(tag, 'Context is valid for this network - using existing context');
-      }
+
+    if (!isValidForNetwork(pubkeyContext)) {
+      throw new Error(`Pubkey context is for wrong network. Expected ${networkId}, got ${pubkeyContext.networks}`);
     }
-    
-    const address = keepKeySdk.pubkeyContext?.address || keepKeySdk.pubkeyContext?.pubkey;
-    console.log(tag, '✅ Using FROM address from pubkeyContext:', address, 'note:', keepKeySdk.pubkeyContext?.note);
+
+    const address = pubkeyContext.address || pubkeyContext.pubkey;
+    console.log(tag, '✅ Using FROM address from pubkeyContext:', address, 'note:', pubkeyContext.note);
     if (!address) throw new Error('No address found for the specified network');
 
-    // Fetch gas price in gwei and convert to wei
-    // Note: In the future, we should fetch different gas prices for different fee levels
-    // For now, we'll use a multiplier on the base gas price
+    // Fetch gas price and convert to wei
     const gasPriceData = await pioneer.GetGasPriceByNetwork({ networkId });
-    let baseGasPrice: bigint;
-
-    // Check if the returned value is reasonable (in wei or gwei)
-    // If it's less than 1 gwei (1e9 wei), it's probably already in wei but too low
-    // For mainnet, we need at least 10-30 gwei typically
-    const MIN_GAS_PRICE_WEI = BigInt(10e9); // 10 gwei minimum for mainnet
-
-    if (BigInt(gasPriceData.data) < MIN_GAS_PRICE_WEI) {
-      // The API is returning a value that's way too low (like 0.296 gwei)
-      // Use a reasonable default for mainnet
-      console.log(tag, 'Gas price from API too low:', gasPriceData.data, 'wei - using minimum:', MIN_GAS_PRICE_WEI.toString());
-      baseGasPrice = MIN_GAS_PRICE_WEI;
-    } else {
-      baseGasPrice = BigInt(gasPriceData.data);
-    }
+    console.log(tag, 'Gas price data from API:', JSON.stringify(gasPriceData.data));
 
-    // Apply fee level multiplier
-    // feeLevel: 1 = slow (80% of base), 5 = average (100%), 9 = fast (150%)
     let gasPrice: bigint;
-    if (feeLevel <= 2) {
-      // Slow - 80% of base price
-      gasPrice = (baseGasPrice * BigInt(80)) / BigInt(100);
-      console.log(tag, 'Using SLOW gas price (80% of base)');
-    } else if (feeLevel >= 8) {
-      // Fast - 150% of base price
-      gasPrice = (baseGasPrice * BigInt(150)) / BigInt(100);
-      console.log(tag, 'Using FAST gas price (150% of base)');
+
+    // Default fallback gas prices by chain ID (in gwei)
+    const defaultGasPrices: Record<number, number> = {
+      1: 30,      // Ethereum mainnet
+      56: 3,      // BSC
+      137: 50,    // Polygon
+      43114: 25,  // Avalanche
+      8453: 0.1,  // Base
+      10: 0.1,    // Optimism
+    };
+
+    const fallbackGasGwei = defaultGasPrices[chainId] || 20; // Default 20 gwei
+    const MIN_GAS_PRICE_WEI = BigInt(fallbackGasGwei * 1e9);
+
+    // Check if API returned an object with fee levels or a single value
+    if (typeof gasPriceData.data === 'object' && gasPriceData.data !== null && !Array.isArray(gasPriceData.data)) {
+      // API returned object with fee levels (e.g., { slow, average, fastest })
+      let selectedGasPrice: string | number | undefined;
+
+      if (feeLevel <= 2) {
+        // Slow
+        selectedGasPrice = gasPriceData.data.slow || gasPriceData.data.average || gasPriceData.data.fastest;
+        console.log(tag, 'Selecting SLOW gas price from API');
+      } else if (feeLevel >= 8) {
+        // Fast
+        selectedGasPrice = gasPriceData.data.fastest || gasPriceData.data.fast || gasPriceData.data.average;
+        console.log(tag, 'Selecting FAST gas price from API');
+      } else {
+        // Average
+        selectedGasPrice = gasPriceData.data.average || gasPriceData.data.fast || gasPriceData.data.fastest;
+        console.log(tag, 'Selecting AVERAGE gas price from API');
+      }
+
+      // Convert to number and validate
+      let gasPriceNum: number;
+      if (selectedGasPrice === undefined || selectedGasPrice === null) {
+        console.warn(tag, 'No valid gas price found in API response, using fallback:', fallbackGasGwei, 'gwei');
+        gasPriceNum = fallbackGasGwei;
+      } else {
+        gasPriceNum = typeof selectedGasPrice === 'string' ? parseFloat(selectedGasPrice) : selectedGasPrice;
+
+        // Check for NaN
+        if (isNaN(gasPriceNum) || !isFinite(gasPriceNum)) {
+          console.warn(tag, 'Invalid gas price (NaN or Infinite):', selectedGasPrice, '- using fallback:', fallbackGasGwei, 'gwei');
+          gasPriceNum = fallbackGasGwei;
+        }
+      }
+
+      // Assume API returns gwei, convert to wei
+      gasPrice = BigInt(Math.round(gasPriceNum * 1e9));
+
+      // Apply minimum gas price if too low
+      if (gasPrice < MIN_GAS_PRICE_WEI) {
+        console.warn(tag, 'Gas price from API too low:', gasPrice.toString(), 'wei - using minimum:', MIN_GAS_PRICE_WEI.toString());
+        gasPrice = MIN_GAS_PRICE_WEI;
+      }
     } else {
-      // Average - use base price
-      gasPrice = baseGasPrice;
-      console.log(tag, 'Using AVERAGE gas price (100% of base)');
+      // API returned a single value or something unexpected
+      let gasPriceNum: number;
+
+      if (gasPriceData.data === undefined || gasPriceData.data === null) {
+        console.warn(tag, 'Gas price API returned null/undefined, using fallback:', fallbackGasGwei, 'gwei');
+        gasPriceNum = fallbackGasGwei;
+      } else {
+        gasPriceNum = typeof gasPriceData.data === 'string' ? parseFloat(gasPriceData.data) : gasPriceData.data;
+
+        // Check for NaN
+        if (isNaN(gasPriceNum) || !isFinite(gasPriceNum)) {
+          console.warn(tag, 'Invalid gas price (NaN or Infinite):', gasPriceData.data, '- using fallback:', fallbackGasGwei, 'gwei');
+          gasPriceNum = fallbackGasGwei;
+        }
+      }
+
+      // Assume API returns gwei, convert to wei
+      const baseGasPrice = BigInt(Math.round(gasPriceNum * 1e9));
+
+      // Apply fee level multiplier
+      if (feeLevel <= 2) {
+        gasPrice = (baseGasPrice * BigInt(80)) / BigInt(100);
+        console.log(tag, 'Using SLOW gas price (80% of base)');
+      } else if (feeLevel >= 8) {
+        gasPrice = (baseGasPrice * BigInt(150)) / BigInt(100);
+        console.log(tag, 'Using FAST gas price (150% of base)');
+      } else {
+        gasPrice = baseGasPrice;
+        console.log(tag, 'Using AVERAGE gas price (100% of base)');
+      }
+
+      // Apply minimum gas price if too low
+      if (gasPrice < MIN_GAS_PRICE_WEI) {
+        console.warn(tag, 'Gas price too low:', gasPrice.toString(), 'wei - using minimum:', MIN_GAS_PRICE_WEI.toString());
+        gasPrice = MIN_GAS_PRICE_WEI;
+      }
     }
-    
-    console.log(tag, 'Using gasPrice:', gasPrice.toString(), 'wei (', Number(gasPrice) / 1e9, 'gwei)');
+
+    console.log(tag, 'Final gasPrice:', gasPrice.toString(), 'wei (', Number(gasPrice) / 1e9, 'gwei)');
 
     let nonce;
     try {
@@ -501,22 +556,22 @@ export async function createUnsignedEvmTx(
 
     // Address path for hardware wallets - use the path from the pubkey context
     // The pubkey context should have either addressNListMaster or pathMaster
-    if (keepKeySdk.pubkeyContext?.addressNListMaster) {
+    if (pubkeyContext.addressNListMaster) {
       // Direct use if we have addressNListMaster
-      unsignedTx.addressNList = keepKeySdk.pubkeyContext.addressNListMaster;
+      unsignedTx.addressNList = pubkeyContext.addressNListMaster;
       console.log(tag, '✅ Using addressNListMaster from pubkey context:', unsignedTx.addressNList, 'for address:', address);
-    } else if (keepKeySdk.pubkeyContext?.pathMaster) {
+    } else if (pubkeyContext.pathMaster) {
       // Convert BIP32 path to addressNList if we have pathMaster
-      unsignedTx.addressNList = bip32ToAddressNList(keepKeySdk.pubkeyContext.pathMaster);
-      console.log(tag, '✅ Converted pathMaster to addressNList:', keepKeySdk.pubkeyContext.pathMaster, '→', unsignedTx.addressNList);
-    } else if (keepKeySdk.pubkeyContext?.addressNList) {
+      unsignedTx.addressNList = bip32ToAddressNList(pubkeyContext.pathMaster);
+      console.log(tag, '✅ Converted pathMaster to addressNList:', pubkeyContext.pathMaster, '→', unsignedTx.addressNList);
+    } else if (pubkeyContext.addressNList) {
       // Use addressNList if available (but this would be the non-master path)
-      unsignedTx.addressNList = keepKeySdk.pubkeyContext.addressNList;
+      unsignedTx.addressNList = pubkeyContext.addressNList;
       console.log(tag, '✅ Using addressNList from pubkey context:', unsignedTx.addressNList);
-    } else if (keepKeySdk.pubkeyContext?.path) {
+    } else if (pubkeyContext.path) {
       // Last resort - convert regular path to addressNList
-      unsignedTx.addressNList = bip32ToAddressNList(keepKeySdk.pubkeyContext.path);
-      console.log(tag, '⚠️ Using regular path (not master):', keepKeySdk.pubkeyContext.path, '→', unsignedTx.addressNList);
+      unsignedTx.addressNList = bip32ToAddressNList(pubkeyContext.path);
+      console.log(tag, '⚠️ Using regular path (not master):', pubkeyContext.path, '→', unsignedTx.addressNList);
     } else {
       // Fallback to default account 0
       unsignedTx.addressNList = [0x80000000 + 44, 0x80000000 + 60, 0x80000000, 0, 0];

package/src/txbuilder/createUnsignedRippleTx.ts

@@ -15,7 +15,7 @@ export async function createUnsignedRippleTx(
   memo: string,
   pubkeys: any,
   pioneer: any,
-  keepKeySdk: any,
+  pubkeyContext: any,
   isMax: boolean,
 ): Promise<any> {
   let tag = TAG + ' | createUnsignedRippleTx | ';
@@ -25,20 +25,21 @@ export async function createUnsignedRippleTx(
 
     // Determine networkId from caip
     const networkId = caipToNetworkId(caip);
-    //console.log(tag, 'networkId:', networkId);
 
-    // Auto-correct context if wrong network
-    if (!keepKeySdk.pubkeyContext?.networks?.includes(networkId)) {
-      keepKeySdk.pubkeyContext = pubkeys.find((pk: any) => 
-        pk.networks?.includes(networkId)
-      );
+    // 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 (!keepKeySdk.pubkeyContext) {
-      throw new Error(`No relevant pubkeys found for networkId: ${networkId}`);
+
+    if (!pubkeyContext.networks?.includes(networkId)) {
+      throw new Error(`Pubkey context is for wrong network. Expected ${networkId}, got ${pubkeyContext.networks}`);
     }
 
-    const fromAddress = keepKeySdk.pubkeyContext.address || keepKeySdk.pubkeyContext.pubkey;
+    console.log(tag, `✅ Using pubkeyContext for network ${networkId}:`, {
+      address: pubkeyContext.address,
+    });
+
+    const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
 
     let accountInfo = await pioneer.GetAccountInfo({
       address: fromAddress,

package/src/txbuilder/createUnsignedStakingTx.ts

@@ -24,7 +24,7 @@ export async function createUnsignedStakingTx(
   params: StakingTxParams,
   pubkeys: any[],
   pioneer: any,
-  keepKeySdk: any,
+  pubkeyContext: any,
 ): Promise<any> {
   const tag = TAG + ' | createUnsignedStakingTx | ';
 
@@ -32,18 +32,20 @@ export async function createUnsignedStakingTx(
     if (!pioneer) throw new Error('Failed to init! pioneer');
 
     const networkId = caipToNetworkId(caip);
-    
-    // Auto-correct context if wrong network
-    if (!keepKeySdk.pubkeyContext?.networks?.includes(networkId)) {
-      keepKeySdk.pubkeyContext = pubkeys.find(pk => 
-        pk.networks?.includes(networkId)
-      );
+
+    // 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 (!keepKeySdk.pubkeyContext) {
-      throw new Error(`No relevant pubkeys found 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,
+    });
+
     // Map networkId to chain and get network-specific configs
     let chain: string;
     let chainId: string;
@@ -78,7 +80,7 @@ export async function createUnsignedStakingTx(
 
     console.log(tag, `Building ${params.type} transaction for ${chain}`);
 
-    const fromAddress = keepKeySdk.pubkeyContext.address || keepKeySdk.pubkeyContext.pubkey;
+    const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
     
     // Get account info
     const accountInfo = (await pioneer.GetAccountInfo({ network: chain, address: fromAddress }))

package/src/txbuilder/createUnsignedTendermintTx.ts

@@ -14,7 +14,7 @@ export async function createUnsignedTendermintTx(
   memo: string,
   pubkeys: any[],
   pioneer: any,
-  keepKeySdk: any,
+  pubkeyContext: any,
   isMax: boolean,
   to?: string,
 ): Promise<any> {
@@ -24,18 +24,22 @@ export async function createUnsignedTendermintTx(
     if (!pioneer) throw new Error('Failed to init! pioneer');
 
     const networkId = caipToNetworkId(caip);
-    
-    // Auto-correct context if wrong network
-    if (!keepKeySdk.pubkeyContext?.networks?.includes(networkId)) {
-      keepKeySdk.pubkeyContext = pubkeys.find(pk => 
-        pk.networks?.includes(networkId)
-      );
+
+    // Use the passed pubkeyContext directly - it's already been set by Pioneer SDK
+    // No need to auto-correct anymore since context management is centralized
+    if (!pubkeyContext) {
+      throw new Error(`No pubkey context provided for networkId: ${networkId}`);
     }
-    
-    if (!keepKeySdk.pubkeyContext) {
-      throw new Error(`No relevant pubkeys found 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,
+      addressNList: pubkeyContext.addressNList || pubkeyContext.addressNListMaster
+    });
+
     // Map networkId to a human-readable chain
     let chain: string;
     switch (networkId) {
@@ -57,13 +61,16 @@ export async function createUnsignedTendermintTx(
 
     //console.log(tag, `Resolved chain: ${chain} for networkId: ${networkId}`);
 
-    const fromAddress = keepKeySdk.pubkeyContext.address || keepKeySdk.pubkeyContext.pubkey;
+    const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
     let asset = caip.split(':')[1]; // Assuming format is "network:asset"
+
+    console.log(tag, `🔍 Fetching account info for address: ${fromAddress}`);
     const accountInfo = (await pioneer.GetAccountInfo({ network: chain, address: fromAddress }))
       .data;
-    //console.log('accountInfo: ', accountInfo);
+    console.log(tag, '📋 accountInfo:', JSON.stringify(accountInfo, null, 2));
+
     let balanceInfo = await pioneer.GetPubkeyBalance({ asset: chain, pubkey: fromAddress });
-    //console.log(tag, `balanceInfo: `, balanceInfo);
+    console.log(tag, `💰 balanceInfo:`, balanceInfo);
 
     let account_number, sequence;
     if (networkId === 'cosmos:cosmoshub-4' || networkId === 'cosmos:osmosis-1') {
@@ -77,9 +84,22 @@ export async function createUnsignedTendermintTx(
       sequence = accountInfo.result.value.sequence || '0';
     }
 
+    console.log(tag, `📊 Extracted account_number: ${account_number}, sequence: ${sequence}`);
+
+    // CRITICAL: Pioneer API may return stale data. The mayachain-network module already
+    // queries multiple nodes directly and uses consensus - but we're using the Pioneer API wrapper
+    // which adds caching. If we get account_number 0, warn about potential Pioneer API cache issue.
+    if (account_number === '0' || account_number === 0) {
+      console.log(tag, `⚠️  WARNING: Account number is 0 from Pioneer API`);
+      console.log(tag, `   This is likely due to stale Pioneer API cache`);
+      console.log(tag, `   The mayachain-network module queries nodes directly but Pioneer API may be cached`);
+      console.log(tag, `   Proceeding with account_number: 0 but transaction will likely fail`);
+      console.log(tag, `   TODO: Fix Pioneer API to use fresh data from mayachain-network module`);
+    }
+
     const fees = {
       'cosmos:thorchain-mainnet-v1': 0.02,
-      'cosmos:mayachain-mainnet-v1': 0.2,
+      'cosmos:mayachain-mainnet-v1': 0, // Increased to 0.5 CACAO (5000000000 base units) for reliable confirmation
       'cosmos:cosmoshub-4': 0.005,
       'cosmos:osmosis-1': 0.035,
     };
@@ -147,11 +167,14 @@ export async function createUnsignedTendermintTx(
           throw new Error(`Unsupported Maya chain CAIP: ${caip}`);
         }
 
+        // MAYA token uses 1e4 (4 decimals), CACAO uses 1e10 (10 decimals)
+        const decimals = mayaAsset === 'maya' ? 1e4 : 1e10;
+
         if (isMax) {
-          const fee = Math.floor(fees[networkId] * 1e10); // Convert fee to smallest unit and floor to int
-          amount = Math.max(0, Math.floor(balanceInfo.data * 1e10) - fee); // Floor to ensure no decimals
+          const fee = Math.floor(fees[networkId] * decimals); // Convert fee to smallest unit and floor to int
+          amount = Math.max(0, Math.floor(balanceInfo.data * decimals) - fee); // Floor to ensure no decimals
         } else {
-          amount = Math.max(Math.floor(amount * 1e10), 0); // Floor the multiplication result
+          amount = Math.max(Math.floor(amount * decimals), 0); // Floor the multiplication result
         }
 
         //console.log(tag, `amount: ${amount}, isMax: ${isMax}, fee: ${fees[networkId]}, asset: ${mayaAsset}`);
@@ -174,6 +197,7 @@ export async function createUnsignedTendermintTx(
               amount: amount.toString(),
               memo,
               sequence,
+              addressNList: pubkeyContext.addressNList || pubkeyContext.addressNListMaster, // CRITICAL: Use correct derivation path for signing
             })
           : mayachainDepositTemplate({
               account_number,

package/src/txbuilder/createUnsignedUxtoTx.ts

@@ -1,5 +1,34 @@
 import { caipToNetworkId, NetworkIdToChain } from '@pioneer-platform/pioneer-caip';
-import { bip32ToAddressNList } from '@pioneer-platform/pioneer-coins';
+import { bip32ToAddressNList, SLIP_44_BY_LONG, COIN_MAP_LONG } from '@pioneer-platform/pioneer-coins';
+import coinSelect from 'coinselect';
+import coinSelectSplit from 'coinselect/split';
+
+/**
+ * Get SLIP-44 coin type for a given network ID
+ * @param networkId - CAIP network identifier
+ * @returns SLIP-44 coin type number
+ */
+function getCoinTypeFromNetworkId(networkId: string): number {
+  const chain = NetworkIdToChain[networkId];
+  if (!chain) {
+    console.warn(`No chain mapping found for ${networkId}, defaulting to Bitcoin coin type 0`);
+    return 0;
+  }
+
+  const blockchainName = COIN_MAP_LONG[chain]?.toLowerCase();
+  if (!blockchainName) {
+    console.warn(`No blockchain name found for chain ${chain}, defaulting to Bitcoin coin type 0`);
+    return 0;
+  }
+
+  const coinType = SLIP_44_BY_LONG[blockchainName];
+  if (coinType === undefined) {
+    console.warn(`No SLIP-44 coin type found for ${blockchainName}, defaulting to Bitcoin coin type 0`);
+    return 0;
+  }
+
+  return coinType;
+}
 
 export async function createUnsignedUxtoTx(
   caip: string,
@@ -8,7 +37,7 @@ export async function createUnsignedUxtoTx(
   memo: string,
   pubkeys: any,
   pioneer: any,
-  keepKeySdk: any,
+  pubkeyContext: any,
   isMax: boolean, // Added isMax parameter
   feeLevel: number = 5, // Added feeLevel parameter with default of 5 (average)
   changeScriptType?: string, // Added changeScriptType parameter for user preference
@@ -20,11 +49,20 @@ export async function createUnsignedUxtoTx(
 
     const networkId = caipToNetworkId(caip);
 
-    // Auto-correct context if wrong network
-    if (!keepKeySdk.pubkeyContext?.networks?.includes(networkId)) {
-      keepKeySdk.pubkeyContext = pubkeys.find((pk) => pk.networks?.includes(networkId));
+    // 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,
+      scriptType: pubkeyContext.scriptType,
+    });
+
     // For UTXO, we still need all relevant pubkeys to aggregate UTXOs
     const relevantPubkeys = pubkeys.filter(
       (e) => e.networks && Array.isArray(e.networks) && e.networks.includes(networkId),
@@ -40,57 +78,11 @@ export async function createUnsignedUxtoTx(
 
     let chain = NetworkIdToChain[networkId];
 
-    // Determine the change script type - use preference or default to p2wpkh for lower fees
-    const actualChangeScriptType =
-      changeScriptType ||
-      relevantPubkeys.find((pk) => pk.scriptType === 'p2wpkh')?.scriptType || // Prefer native segwit if available
-      relevantPubkeys[0].scriptType || // Fall back to first available
-      'p2wpkh'; // Ultimate default
-    console.log(`${tag}: Using change script type: ${actualChangeScriptType}`);
-
-    // Find the xpub that matches the desired script type
-    const changeXpub =
-      relevantPubkeys.find((pk) => pk.scriptType === actualChangeScriptType)?.pubkey ||
-      relevantPubkeys.find((pk) => pk.scriptType === 'p2wpkh')?.pubkey || // Fall back to native segwit
-      relevantPubkeys[0].pubkey; // Last resort: use first available
-
-    console.log(
-      `${tag}: Change xpub selected for ${actualChangeScriptType}:`,
-      changeXpub?.substring(0, 10) + '...',
-    );
-
-    let changeAddressIndex = await pioneer.GetChangeAddress({
-      network: chain,
-      xpub: changeXpub,
-    });
-    changeAddressIndex = changeAddressIndex.data.changeIndex;
-
-    // Determine BIP path based on script type
-    let bipPath: string;
-    switch (actualChangeScriptType) {
-      case 'p2pkh':
-        bipPath = `m/44'/0'/0'/1/${changeAddressIndex}`; // BIP44 for legacy
-        break;
-      case 'p2sh-p2wpkh':
-        bipPath = `m/49'/0'/0'/1/${changeAddressIndex}`; // BIP49 for wrapped segwit
-        break;
-      case 'p2wpkh':
-      default:
-        bipPath = `m/84'/0'/0'/1/${changeAddressIndex}`; // BIP84 for native segwit
-        break;
-    }
-
-    const path = bipPath;
-    console.log(`${tag}: Change address path: ${path} (index: ${changeAddressIndex})`);
-
-    const changeAddress = {
-      path: path,
-      isChange: true,
-      index: changeAddressIndex,
-      addressNList: bip32ToAddressNList(path),
-      scriptType: actualChangeScriptType, // Store the script type with the change address
-    };
+    // Get correct coin type for this network
+    const coinType = getCoinTypeFromNetworkId(networkId);
+    console.log(`${tag}: Using SLIP-44 coin type ${coinType} for ${chain}`);
 
+    // Collect UTXOs first to determine the appropriate change address type
     const utxos: any[] = [];
     for (const pubkey of relevantPubkeys) {
       //console.log('pubkey: ',pubkey)
@@ -129,6 +121,81 @@ export async function createUnsignedUxtoTx(
       utxo.value = Number(utxo.value);
     }
 
+    // NOW determine change script type based on collected UTXOs
+    // Find the most common script type among input UTXOs to maintain consistency
+    const inputScriptTypes = utxos.map((u) => u.scriptType).filter(Boolean);
+    const scriptTypeCount: Record<string, number> = inputScriptTypes.reduce((acc, type) => {
+      acc[type] = (acc[type] || 0) + 1;
+      return acc;
+    }, {} as Record<string, number>);
+
+    // Get the most common input script type
+    const mostCommonInputType =
+      Object.entries(scriptTypeCount).sort(([, a], [, b]) => b - a)[0]?.[0] || 'p2pkh';
+
+    // Determine the change script type - priority order:
+    // 1. User explicit preference (changeScriptType parameter)
+    // 2. Most common input script type (maintain consistency)
+    // 3. First available pubkey script type
+    // 4. Default to p2pkh (legacy)
+    const actualChangeScriptType =
+      changeScriptType ||
+      mostCommonInputType ||
+      relevantPubkeys[0]?.scriptType ||
+      'p2pkh';
+
+    console.log(`${tag}: Input script types:`, scriptTypeCount);
+    console.log(`${tag}: Using change script type: ${actualChangeScriptType} (matches inputs: ${mostCommonInputType})`);
+
+    // Find and validate the xpub that matches the desired script type
+    const changeXpubInfo = relevantPubkeys.find((pk) => pk.scriptType === actualChangeScriptType);
+    if (!changeXpubInfo) {
+      throw new Error(
+        `No ${actualChangeScriptType} xpub available for change address. ` +
+          `Available types: ${relevantPubkeys.map((pk) => pk.scriptType).join(', ')}. ` +
+          `Cannot create change output with mismatched script type.`,
+      );
+    }
+
+    const changeXpub = changeXpubInfo.pubkey;
+    console.log(
+      `${tag}: Change xpub selected for ${actualChangeScriptType}:`,
+      changeXpub?.substring(0, 10) + '...',
+    );
+
+    // Get change address index from Pioneer API
+    let changeAddressIndex = await pioneer.GetChangeAddress({
+      network: chain,
+      xpub: changeXpub,
+    });
+    changeAddressIndex = changeAddressIndex.data.changeIndex;
+
+    // Determine BIP path based on script type AND coin type
+    let bipPath: string;
+    switch (actualChangeScriptType) {
+      case 'p2pkh':
+        bipPath = `m/44'/${coinType}'/0'/1/${changeAddressIndex}`; // BIP44 for legacy
+        break;
+      case 'p2sh-p2wpkh':
+        bipPath = `m/49'/${coinType}'/0'/1/${changeAddressIndex}`; // BIP49 for wrapped segwit
+        break;
+      case 'p2wpkh':
+      default:
+        bipPath = `m/84'/${coinType}'/0'/1/${changeAddressIndex}`; // BIP84 for native segwit
+        break;
+    }
+
+    const path = bipPath;
+    console.log(`${tag}: Change address path: ${path} (coin type: ${coinType}, index: ${changeAddressIndex})`);
+
+    const changeAddress = {
+      path: path,
+      isChange: true,
+      index: changeAddressIndex,
+      addressNList: bip32ToAddressNList(path),
+      scriptType: actualChangeScriptType,
+    };
+
     let feeRateFromNode: any;
     
     // HARDCODE DOGE FEES - API is unreliable for DOGE
@@ -294,12 +361,10 @@ export async function createUnsignedUxtoTx(
     if (isMax) {
       //console.log(tag, 'isMax:', isMax);
       // For max send, use coinSelectSplit
-      const { default: coinSelectSplit } = await import('coinselect/split');
       result = coinSelectSplit(utxos, [{ address: to }], effectiveFeeRate);
     } else {
       //console.log(tag, 'isMax:', isMax)
       // Regular send
-      const { default: coinSelect } = await import('coinselect');
       result = coinSelect(utxos, [{ address: to, value: amount }], effectiveFeeRate);
     }