@pioneer-platform/pioneer-sdk 4.20.0 → 4.20.1

package/dist/index.cjs

@@ -505,49 +505,6 @@ var require_utils = __commonJS((exports2, module2) => {
   };
 });
 
-// ../../../node_modules/coinselect/split.js
-var require_split = __commonJS((exports2, module2) => {
-  var utils = require_utils();
-  module2.exports = function split(utxos, outputs, feeRate) {
-    if (!isFinite(utils.uintOrNaN(feeRate)))
-      return {};
-    var bytesAccum = utils.transactionBytes(utxos, outputs);
-    var fee = feeRate * bytesAccum;
-    if (outputs.length === 0)
-      return { fee };
-    var inAccum = utils.sumOrNaN(utxos);
-    var outAccum = utils.sumForgiving(outputs);
-    var remaining = inAccum - outAccum - fee;
-    if (!isFinite(remaining) || remaining < 0)
-      return { fee };
-    var unspecified = outputs.reduce(function(a, x) {
-      return a + !isFinite(x.value);
-    }, 0);
-    if (remaining === 0 && unspecified === 0)
-      return utils.finalize(utxos, outputs, feeRate);
-    var splitOutputsCount = outputs.reduce(function(a, x) {
-      if (x.value !== undefined)
-        return a;
-      return a + 1;
-    }, 0);
-    var splitValue = Math.floor(remaining / splitOutputsCount);
-    if (!outputs.every(function(x) {
-      return x.value !== undefined || splitValue > utils.dustThreshold(x, feeRate);
-    }))
-      return { fee };
-    outputs = outputs.map(function(x) {
-      if (x.value !== undefined)
-        return x;
-      var y = {};
-      for (var k in x)
-        y[k] = x[k];
-      y.value = splitValue;
-      return y;
-    });
-    return utils.finalize(utxos, outputs, feeRate);
-  };
-});
-
 // ../../../node_modules/coinselect/accumulative.js
 var require_accumulative = __commonJS((exports2, module2) => {
   var utils = require_utils();
@@ -628,6 +585,49 @@ var require_coinselect = __commonJS((exports2, module2) => {
   };
 });
 
+// ../../../node_modules/coinselect/split.js
+var require_split = __commonJS((exports2, module2) => {
+  var utils = require_utils();
+  module2.exports = function split(utxos, outputs, feeRate) {
+    if (!isFinite(utils.uintOrNaN(feeRate)))
+      return {};
+    var bytesAccum = utils.transactionBytes(utxos, outputs);
+    var fee = feeRate * bytesAccum;
+    if (outputs.length === 0)
+      return { fee };
+    var inAccum = utils.sumOrNaN(utxos);
+    var outAccum = utils.sumForgiving(outputs);
+    var remaining = inAccum - outAccum - fee;
+    if (!isFinite(remaining) || remaining < 0)
+      return { fee };
+    var unspecified = outputs.reduce(function(a, x) {
+      return a + !isFinite(x.value);
+    }, 0);
+    if (remaining === 0 && unspecified === 0)
+      return utils.finalize(utxos, outputs, feeRate);
+    var splitOutputsCount = outputs.reduce(function(a, x) {
+      if (x.value !== undefined)
+        return a;
+      return a + 1;
+    }, 0);
+    var splitValue = Math.floor(remaining / splitOutputsCount);
+    if (!outputs.every(function(x) {
+      return x.value !== undefined || splitValue > utils.dustThreshold(x, feeRate);
+    }))
+      return { fee };
+    outputs = outputs.map(function(x) {
+      if (x.value !== undefined)
+        return x;
+      var y = {};
+      for (var k in x)
+        y[k] = x[k];
+      y.value = splitValue;
+      return y;
+    });
+    return utils.finalize(utxos, outputs, feeRate);
+  };
+});
+
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
@@ -636,12 +636,12 @@ __export(exports_src, {
 });
 module.exports = __toCommonJS(exports_src);
 var import_keepkey_sdk = require("@keepkey/keepkey-sdk");
-var import_pioneer_caip7 = require("@pioneer-platform/pioneer-caip");
+var import_pioneer_caip6 = require("@pioneer-platform/pioneer-caip");
 var import_pioneer_client = __toESM(require_lib());
 var import_pioneer_coins4 = require("@pioneer-platform/pioneer-coins");
 var import_pioneer_discovery2 = require("@pioneer-platform/pioneer-discovery");
 var import_pioneer_events = require("@pioneer-platform/pioneer-events");
-var import_events = require("events");
+var import_events = __toESM(require("events"));
 
 // src/charts/utils.ts
 var import_pioneer_discovery = require("@pioneer-platform/pioneer-discovery");
@@ -1230,42 +1230,31 @@ var getPubkey = async (networkId, path, sdk, context) => {
       console.error("⏰ [PUBKEY] Address retrieval timeout for", networkId);
     }, 30000);
     try {
-      let result;
       switch (networkType) {
         case "UTXO":
-          result = await sdk.address.utxoGetAddress(addressInfo);
+          ({ address } = await sdk.address.utxoGetAddress(addressInfo));
           break;
         case "EVM":
-          result = await sdk.address.ethereumGetAddress(addressInfo);
+          ({ address } = await sdk.address.ethereumGetAddress(addressInfo));
           break;
         case "OSMOSIS":
-          result = await sdk.address.osmosisGetAddress(addressInfo);
+          ({ address } = await sdk.address.osmosisGetAddress(addressInfo));
           break;
         case "COSMOS":
-          result = await sdk.address.cosmosGetAddress(addressInfo);
+          ({ address } = await sdk.address.cosmosGetAddress(addressInfo));
           break;
         case "MAYACHAIN":
-          result = await sdk.address.mayachainGetAddress(addressInfo);
+          ({ address } = await sdk.address.mayachainGetAddress(addressInfo));
           break;
         case "THORCHAIN":
-          result = await sdk.address.thorchainGetAddress(addressInfo);
+          ({ address } = await sdk.address.thorchainGetAddress(addressInfo));
           break;
         case "XRP":
-          result = await sdk.address.xrpGetAddress(addressInfo);
+          ({ address } = await sdk.address.xrpGetAddress(addressInfo));
           break;
         default:
           throw new Error(`Unsupported network type for networkId: ${networkId}`);
       }
-      if (!result) {
-        throw new Error(`Address call returned null/undefined for ${networkType} (${networkId})`);
-      }
-      if (typeof result === "object" && result.address) {
-        address = result.address;
-      } else if (typeof result === "string") {
-        address = result;
-      } else {
-        throw new Error(`Invalid address response format for ${networkType} (${networkId}): ${JSON.stringify(result)}`);
-      }
       clearTimeout(addressTimeout);
     } catch (addressError) {
       clearTimeout(addressTimeout);
@@ -1280,6 +1269,10 @@ var getPubkey = async (networkId, path, sdk, context) => {
     pubkey.master = address;
     pubkey.address = address;
     if (["xpub", "ypub", "zpub"].includes(path.type)) {
+      console.log("\uD83D\uDD11 [XPUB] Starting xpub retrieval for path type:", path.type);
+      console.log("\uD83D\uDD11 [XPUB] Network:", networkId);
+      console.log("\uD83D\uDD11 [XPUB] Path:", import_pioneer_coins.addressNListToBIP32(path.addressNList));
+      console.log("\uD83D\uDD11 [XPUB] Script type:", path.script_type);
       const pathQuery = {
         symbol: "BTC",
         coin: "Bitcoin",
@@ -1287,26 +1280,58 @@ var getPubkey = async (networkId, path, sdk, context) => {
         address_n: path.addressNList,
         showDisplay: false
       };
+      console.log("\uD83D\uDD11 [XPUB] Calling sdk.system.info.getPublicKey with:", JSON.stringify(pathQuery, null, 2));
       const xpubTimeout = setTimeout(() => {
-        console.error("getPublicKey timeout after 20 seconds");
+        console.error("⏰ [XPUB TIMEOUT] getPublicKey timeout after 20 seconds");
+        console.error("⏰ [XPUB TIMEOUT] Path:", import_pioneer_coins.addressNListToBIP32(path.addressNList));
+        console.error("⏰ [XPUB TIMEOUT] This is a CRITICAL FAILURE - UTXO balances require xpubs");
       }, 20000);
       try {
+        console.log("\uD83D\uDD11 [XPUB] Calling getPublicKey...");
         const responsePubkey = await sdk.system.info.getPublicKey(pathQuery);
         clearTimeout(xpubTimeout);
+        console.log("✅ [XPUB] getPublicKey SUCCESS");
+        console.log("✅ [XPUB] Response:", JSON.stringify(responsePubkey, null, 2));
+        if (!responsePubkey || !responsePubkey.xpub) {
+          const error = new Error("FAIL FAST: getPublicKey returned null or missing xpub");
+          console.error("❌ [XPUB] CRITICAL:", error.message);
+          console.error("❌ [XPUB] Response was:", responsePubkey);
+          throw error;
+        }
         if (path.script_type === "p2wpkh") {
+          console.log("\uD83D\uDD11 [XPUB] Converting xpub to zpub for native segwit");
           responsePubkey.xpub = import_pioneer_coins.xpubConvert(responsePubkey.xpub, "zpub");
         } else if (path.script_type === "p2sh-p2wpkh") {
+          console.log("\uD83D\uDD11 [XPUB] Converting xpub to ypub for wrapped segwit");
           responsePubkey.xpub = import_pioneer_coins.xpubConvert(responsePubkey.xpub, "ypub");
         }
+        console.log("✅ [XPUB] Final xpub:", responsePubkey.xpub.substring(0, 20) + "...");
         pubkey.pubkey = responsePubkey.xpub;
         pubkey.path = import_pioneer_coins.addressNListToBIP32(path.addressNList);
         pubkey.pathMaster = import_pioneer_coins.addressNListToBIP32(path.addressNListMaster);
+        console.log("✅ [XPUB] Xpub retrieval COMPLETE for", path.note || path.type);
       } catch (xpubError) {
         clearTimeout(xpubTimeout);
-        console.error("getPublicKey failed:", xpubError);
-        throw xpubError;
+        console.error("❌ [XPUB] CRITICAL FAILURE - getPublicKey failed");
+        console.error("❌ [XPUB] Error:", xpubError);
+        console.error("❌ [XPUB] Error message:", xpubError.message);
+        console.error("❌ [XPUB] Error stack:", xpubError.stack);
+        console.error("❌ [XPUB] Path:", import_pioneer_coins.addressNListToBIP32(path.addressNList));
+        console.error("❌ [XPUB] Network:", networkId);
+        console.error("❌ [XPUB] Query:", JSON.stringify(pathQuery, null, 2));
+        console.error("❌ [XPUB] SDK available:", !!sdk);
+        console.error("❌ [XPUB] SDK.system available:", !!sdk?.system);
+        console.error("❌ [XPUB] SDK.system.info available:", !!sdk?.system?.info);
+        console.error("❌ [XPUB] SDK.system.info.getPublicKey available:", !!sdk?.system?.info?.getPublicKey);
+        console.error("");
+        console.error("\uD83D\uDEA8 FAIL FAST: Cannot proceed without xpub for UTXO chains");
+        console.error("\uD83D\uDEA8 UTXO balance queries REQUIRE extended public keys (xpubs)");
+        console.error("\uD83D\uDEA8 This is a device communication or SDK issue that must be resolved");
+        console.error("");
+        throw new Error(`FAIL FAST - xpub retrieval failed for ${networkId} at ${import_pioneer_coins.addressNListToBIP32(path.addressNList)}: ${xpubError.message}`);
       }
     } else {
+      console.log("\uD83D\uDD11 [PUBKEY] Non-xpub path (address-based), using address as pubkey");
       pubkey.pubkey = address;
       pubkey.path = import_pioneer_coins.addressNListToBIP32(path.addressNList);
       pubkey.pathMaster = import_pioneer_coins.addressNListToBIP32(path.addressNListMaster);
@@ -1716,13 +1741,16 @@ async function fetchTokenPriceInUsd(contractAddress) {
   }
   return price;
 }
-async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, keepKeySdk, isMax, feeLevel = 5) {
+async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pubkeyContext, isMax, feeLevel = 5) {
   const tag5 = TAG + " | createUnsignedEvmTx | ";
   try {
     if (!pioneer)
       throw new Error("Failed to initialize Pioneer");
     const networkId = import_pioneer_caip.caipToNetworkId(caip);
     const chainId = extractChainIdFromNetworkId(networkId);
+    if (!pubkeyContext) {
+      throw new Error(`No pubkey context provided for networkId: ${networkId}`);
+    }
     const isValidForNetwork = (pubkey) => {
       if (!pubkey?.networks)
         return false;
@@ -1731,43 +1759,83 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, kee
       }
       return pubkey.networks.includes(networkId);
     };
-    if (!keepKeySdk.pubkeyContext) {
-      console.log(tag5, "No context set - auto-selecting first matching pubkey");
-      keepKeySdk.pubkeyContext = pubkeys.find((pk) => isValidForNetwork(pk));
-    } else {
-      console.log(tag5, "Current context networks:", keepKeySdk.pubkeyContext.networks, "For networkId:", networkId);
-      if (!isValidForNetwork(keepKeySdk.pubkeyContext)) {
-        console.log(tag5, "Auto-correcting context - wrong network detected");
-        keepKeySdk.pubkeyContext = pubkeys.find((pk) => isValidForNetwork(pk));
-      } else {
-        console.log(tag5, "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(tag5, "✅ Using FROM address from pubkeyContext:", address, "note:", keepKeySdk.pubkeyContext?.note);
+    const address = pubkeyContext.address || pubkeyContext.pubkey;
+    console.log(tag5, "✅ Using FROM address from pubkeyContext:", address, "note:", pubkeyContext.note);
     if (!address)
       throw new Error("No address found for the specified network");
     const gasPriceData = await pioneer.GetGasPriceByNetwork({ networkId });
-    let baseGasPrice;
-    const MIN_GAS_PRICE_WEI = BigInt(10000000000);
-    if (BigInt(gasPriceData.data) < MIN_GAS_PRICE_WEI) {
-      console.log(tag5, "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(tag5, "Gas price data from API:", JSON.stringify(gasPriceData.data));
     let gasPrice;
-    if (feeLevel <= 2) {
-      gasPrice = baseGasPrice * BigInt(80) / BigInt(100);
-      console.log(tag5, "Using SLOW gas price (80% of base)");
-    } else if (feeLevel >= 8) {
-      gasPrice = baseGasPrice * BigInt(150) / BigInt(100);
-      console.log(tag5, "Using FAST gas price (150% of base)");
+    const defaultGasPrices = {
+      1: 30,
+      56: 3,
+      137: 50,
+      43114: 25,
+      8453: 0.1,
+      10: 0.1
+    };
+    const fallbackGasGwei = defaultGasPrices[chainId] || 20;
+    const MIN_GAS_PRICE_WEI = BigInt(fallbackGasGwei * 1e9);
+    if (typeof gasPriceData.data === "object" && gasPriceData.data !== null && !Array.isArray(gasPriceData.data)) {
+      let selectedGasPrice;
+      if (feeLevel <= 2) {
+        selectedGasPrice = gasPriceData.data.slow || gasPriceData.data.average || gasPriceData.data.fastest;
+        console.log(tag5, "Selecting SLOW gas price from API");
+      } else if (feeLevel >= 8) {
+        selectedGasPrice = gasPriceData.data.fastest || gasPriceData.data.fast || gasPriceData.data.average;
+        console.log(tag5, "Selecting FAST gas price from API");
+      } else {
+        selectedGasPrice = gasPriceData.data.average || gasPriceData.data.fast || gasPriceData.data.fastest;
+        console.log(tag5, "Selecting AVERAGE gas price from API");
+      }
+      let gasPriceNum;
+      if (selectedGasPrice === undefined || selectedGasPrice === null) {
+        console.warn(tag5, "No valid gas price found in API response, using fallback:", fallbackGasGwei, "gwei");
+        gasPriceNum = fallbackGasGwei;
+      } else {
+        gasPriceNum = typeof selectedGasPrice === "string" ? parseFloat(selectedGasPrice) : selectedGasPrice;
+        if (isNaN(gasPriceNum) || !isFinite(gasPriceNum)) {
+          console.warn(tag5, "Invalid gas price (NaN or Infinite):", selectedGasPrice, "- using fallback:", fallbackGasGwei, "gwei");
+          gasPriceNum = fallbackGasGwei;
+        }
+      }
+      gasPrice = BigInt(Math.round(gasPriceNum * 1e9));
+      if (gasPrice < MIN_GAS_PRICE_WEI) {
+        console.warn(tag5, "Gas price from API too low:", gasPrice.toString(), "wei - using minimum:", MIN_GAS_PRICE_WEI.toString());
+        gasPrice = MIN_GAS_PRICE_WEI;
+      }
     } else {
-      gasPrice = baseGasPrice;
-      console.log(tag5, "Using AVERAGE gas price (100% of base)");
+      let gasPriceNum;
+      if (gasPriceData.data === undefined || gasPriceData.data === null) {
+        console.warn(tag5, "Gas price API returned null/undefined, using fallback:", fallbackGasGwei, "gwei");
+        gasPriceNum = fallbackGasGwei;
+      } else {
+        gasPriceNum = typeof gasPriceData.data === "string" ? parseFloat(gasPriceData.data) : gasPriceData.data;
+        if (isNaN(gasPriceNum) || !isFinite(gasPriceNum)) {
+          console.warn(tag5, "Invalid gas price (NaN or Infinite):", gasPriceData.data, "- using fallback:", fallbackGasGwei, "gwei");
+          gasPriceNum = fallbackGasGwei;
+        }
+      }
+      const baseGasPrice = BigInt(Math.round(gasPriceNum * 1e9));
+      if (feeLevel <= 2) {
+        gasPrice = baseGasPrice * BigInt(80) / BigInt(100);
+        console.log(tag5, "Using SLOW gas price (80% of base)");
+      } else if (feeLevel >= 8) {
+        gasPrice = baseGasPrice * BigInt(150) / BigInt(100);
+        console.log(tag5, "Using FAST gas price (150% of base)");
+      } else {
+        gasPrice = baseGasPrice;
+        console.log(tag5, "Using AVERAGE gas price (100% of base)");
+      }
+      if (gasPrice < MIN_GAS_PRICE_WEI) {
+        console.warn(tag5, "Gas price too low:", gasPrice.toString(), "wei - using minimum:", MIN_GAS_PRICE_WEI.toString());
+        gasPrice = MIN_GAS_PRICE_WEI;
+      }
     }
-    console.log(tag5, "Using gasPrice:", gasPrice.toString(), "wei (", Number(gasPrice) / 1e9, "gwei)");
+    console.log(tag5, "Final gasPrice:", gasPrice.toString(), "wei (", Number(gasPrice) / 1e9, "gwei)");
     let nonce;
     try {
       const nonceData = await pioneer.GetNonceByNetwork({ networkId, address });
@@ -1958,18 +2026,18 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, kee
         throw new Error(`Unsupported asset type for CAIP ${caip}`);
       }
     }
-    if (keepKeySdk.pubkeyContext?.addressNListMaster) {
-      unsignedTx.addressNList = keepKeySdk.pubkeyContext.addressNListMaster;
+    if (pubkeyContext.addressNListMaster) {
+      unsignedTx.addressNList = pubkeyContext.addressNListMaster;
       console.log(tag5, "✅ Using addressNListMaster from pubkey context:", unsignedTx.addressNList, "for address:", address);
-    } else if (keepKeySdk.pubkeyContext?.pathMaster) {
-      unsignedTx.addressNList = import_pioneer_coins2.bip32ToAddressNList(keepKeySdk.pubkeyContext.pathMaster);
-      console.log(tag5, "✅ Converted pathMaster to addressNList:", keepKeySdk.pubkeyContext.pathMaster, "→", unsignedTx.addressNList);
-    } else if (keepKeySdk.pubkeyContext?.addressNList) {
-      unsignedTx.addressNList = keepKeySdk.pubkeyContext.addressNList;
+    } else if (pubkeyContext.pathMaster) {
+      unsignedTx.addressNList = import_pioneer_coins2.bip32ToAddressNList(pubkeyContext.pathMaster);
+      console.log(tag5, "✅ Converted pathMaster to addressNList:", pubkeyContext.pathMaster, "→", unsignedTx.addressNList);
+    } else if (pubkeyContext.addressNList) {
+      unsignedTx.addressNList = pubkeyContext.addressNList;
       console.log(tag5, "✅ Using addressNList from pubkey context:", unsignedTx.addressNList);
-    } else if (keepKeySdk.pubkeyContext?.path) {
-      unsignedTx.addressNList = import_pioneer_coins2.bip32ToAddressNList(keepKeySdk.pubkeyContext.path);
-      console.log(tag5, "⚠️ Using regular path (not master):", keepKeySdk.pubkeyContext.path, "→", unsignedTx.addressNList);
+    } else if (pubkeyContext.path) {
+      unsignedTx.addressNList = import_pioneer_coins2.bip32ToAddressNList(pubkeyContext.path);
+      console.log(tag5, "⚠️ Using regular path (not master):", pubkeyContext.path, "→", unsignedTx.addressNList);
     } else {
       unsignedTx.addressNList = [2147483648 + 44, 2147483648 + 60, 2147483648, 0, 0];
       console.warn(tag5, "⚠️ No path info in pubkey context, using default account 0");
@@ -1984,19 +2052,22 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, kee
 // src/txbuilder/createUnsignedRippleTx.ts
 var import_pioneer_caip2 = require("@pioneer-platform/pioneer-caip");
 var TAG2 = " | createUnsignedUxtoTx | ";
-async function createUnsignedRippleTx(caip, to, amount, memo, pubkeys, pioneer, keepKeySdk, isMax) {
+async function createUnsignedRippleTx(caip, to, amount, memo, pubkeys, pioneer, pubkeyContext, isMax) {
   let tag5 = TAG2 + " | createUnsignedRippleTx | ";
   try {
     if (!pioneer)
       throw new Error("Failed to init! pioneer");
     const networkId = import_pioneer_caip2.caipToNetworkId(caip);
-    if (!keepKeySdk.pubkeyContext?.networks?.includes(networkId)) {
-      keepKeySdk.pubkeyContext = pubkeys.find((pk) => pk.networks?.includes(networkId));
+    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(tag5, `✅ Using pubkeyContext for network ${networkId}:`, {
+      address: pubkeyContext.address
+    });
+    const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
     let accountInfo = await pioneer.GetAccountInfo({
       address: fromAddress,
       network: "ripple"
@@ -2094,6 +2165,7 @@ var cosmosTransferTemplate = (params) => ({
 // src/txbuilder/templates/mayachain.ts
 var mayachainTransferTemplate = (params) => ({
   signerAddress: params.from_address,
+  addressNList: params.addressNList,
   signDoc: {
     account_number: params.account_number,
     chain_id: params.chain_id,
@@ -2199,18 +2271,22 @@ var thorchainDepositTemplate = (params) => ({
 
 // src/txbuilder/createUnsignedTendermintTx.ts
 var TAG3 = " | createUnsignedTendermintTx | ";
-async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pioneer, keepKeySdk, isMax, to) {
+async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pioneer, pubkeyContext, isMax, to) {
   const tag5 = TAG3 + " | createUnsignedTendermintTx | ";
   try {
     if (!pioneer)
       throw new Error("Failed to init! pioneer");
     const networkId = import_pioneer_caip3.caipToNetworkId(caip);
-    if (!keepKeySdk.pubkeyContext?.networks?.includes(networkId)) {
-      keepKeySdk.pubkeyContext = pubkeys.find((pk) => pk.networks?.includes(networkId));
+    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(tag5, `✅ Using pubkeyContext for network ${networkId}:`, {
+      address: pubkeyContext.address,
+      addressNList: pubkeyContext.addressNList || pubkeyContext.addressNListMaster
+    });
     let chain;
     switch (networkId) {
       case "cosmos:thorchain-mainnet-v1":
@@ -2228,10 +2304,13 @@ async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pio
       default:
         throw new Error(`Unhandled networkId: ${networkId}`);
     }
-    const fromAddress = keepKeySdk.pubkeyContext.address || keepKeySdk.pubkeyContext.pubkey;
+    const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
     let asset = caip.split(":")[1];
+    console.log(tag5, `\uD83D\uDD0D Fetching account info for address: ${fromAddress}`);
     const accountInfo = (await pioneer.GetAccountInfo({ network: chain, address: fromAddress })).data;
+    console.log(tag5, "\uD83D\uDCCB accountInfo:", JSON.stringify(accountInfo, null, 2));
     let balanceInfo = await pioneer.GetPubkeyBalance({ asset: chain, pubkey: fromAddress });
+    console.log(tag5, `\uD83D\uDCB0 balanceInfo:`, balanceInfo);
     let account_number, sequence;
     if (networkId === "cosmos:cosmoshub-4" || networkId === "cosmos:osmosis-1") {
       account_number = accountInfo.account.account_number || "0";
@@ -2240,9 +2319,17 @@ async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pio
       account_number = accountInfo.result.value.account_number || "0";
       sequence = accountInfo.result.value.sequence || "0";
     }
+    console.log(tag5, `\uD83D\uDCCA Extracted account_number: ${account_number}, sequence: ${sequence}`);
+    if (account_number === "0" || account_number === 0) {
+      console.log(tag5, `⚠️  WARNING: Account number is 0 from Pioneer API`);
+      console.log(tag5, `   This is likely due to stale Pioneer API cache`);
+      console.log(tag5, `   The mayachain-network module queries nodes directly but Pioneer API may be cached`);
+      console.log(tag5, `   Proceeding with account_number: 0 but transaction will likely fail`);
+      console.log(tag5, `   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,
       "cosmos:cosmoshub-4": 0.005,
       "cosmos:osmosis-1": 0.035
     };
@@ -2301,11 +2388,12 @@ async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pio
         } else {
           throw new Error(`Unsupported Maya chain CAIP: ${caip}`);
         }
+        const decimals = mayaAsset === "maya" ? 1e4 : 10000000000;
         if (isMax) {
-          const fee = Math.floor(fees[networkId] * 10000000000);
-          amount = Math.max(0, Math.floor(balanceInfo.data * 10000000000) - fee);
+          const fee = Math.floor(fees[networkId] * decimals);
+          amount = Math.max(0, Math.floor(balanceInfo.data * decimals) - fee);
         } else {
-          amount = Math.max(Math.floor(amount * 10000000000), 0);
+          amount = Math.max(Math.floor(amount * decimals), 0);
         }
         return to ? mayachainTransferTemplate({
           account_number,
@@ -2324,7 +2412,8 @@ async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pio
           asset: mayaAsset,
           amount: amount.toString(),
           memo,
-          sequence
+          sequence,
+          addressNList: pubkeyContext.addressNList || pubkeyContext.addressNListMaster
         }) : mayachainDepositTemplate({
           account_number,
           chain_id: "mayachain-mainnet-v1",
@@ -2399,52 +2488,50 @@ async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pio
 // src/txbuilder/createUnsignedUxtoTx.ts
 var import_pioneer_caip4 = require("@pioneer-platform/pioneer-caip");
 var import_pioneer_coins3 = require("@pioneer-platform/pioneer-coins");
-async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, keepKeySdk, isMax, feeLevel = 5, changeScriptType) {
+var import_coinselect = __toESM(require_coinselect());
+var import_split = __toESM(require_split());
+function getCoinTypeFromNetworkId(networkId) {
+  const chain = import_pioneer_caip4.NetworkIdToChain[networkId];
+  if (!chain) {
+    console.warn(`No chain mapping found for ${networkId}, defaulting to Bitcoin coin type 0`);
+    return 0;
+  }
+  const blockchainName = import_pioneer_coins3.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 = import_pioneer_coins3.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;
+}
+async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pubkeyContext, isMax, feeLevel = 5, changeScriptType) {
   let tag5 = " | createUnsignedUxtoTx | ";
   try {
     if (!pioneer)
       throw Error("Failed to init! pioneer");
     const networkId = import_pioneer_caip4.caipToNetworkId(caip);
-    if (!keepKeySdk.pubkeyContext?.networks?.includes(networkId)) {
-      keepKeySdk.pubkeyContext = pubkeys.find((pk) => pk.networks?.includes(networkId));
+    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(tag5, `✅ Using pubkeyContext for network ${networkId}:`, {
+      address: pubkeyContext.address,
+      scriptType: pubkeyContext.scriptType
+    });
     const relevantPubkeys = pubkeys.filter((e) => e.networks && Array.isArray(e.networks) && e.networks.includes(networkId));
     const segwitNetworks = [
       "bip122:000000000019d6689c085ae165831e93"
     ];
     const isSegwit = segwitNetworks.includes(networkId);
     let chain = import_pioneer_caip4.NetworkIdToChain[networkId];
-    const actualChangeScriptType = changeScriptType || relevantPubkeys.find((pk) => pk.scriptType === "p2wpkh")?.scriptType || relevantPubkeys[0].scriptType || "p2wpkh";
-    console.log(`${tag5}: Using change script type: ${actualChangeScriptType}`);
-    const changeXpub = relevantPubkeys.find((pk) => pk.scriptType === actualChangeScriptType)?.pubkey || relevantPubkeys.find((pk) => pk.scriptType === "p2wpkh")?.pubkey || relevantPubkeys[0].pubkey;
-    console.log(`${tag5}: Change xpub selected for ${actualChangeScriptType}:`, changeXpub?.substring(0, 10) + "...");
-    let changeAddressIndex = await pioneer.GetChangeAddress({
-      network: chain,
-      xpub: changeXpub
-    });
-    changeAddressIndex = changeAddressIndex.data.changeIndex;
-    let bipPath;
-    switch (actualChangeScriptType) {
-      case "p2pkh":
-        bipPath = `m/44'/0'/0'/1/${changeAddressIndex}`;
-        break;
-      case "p2sh-p2wpkh":
-        bipPath = `m/49'/0'/0'/1/${changeAddressIndex}`;
-        break;
-      case "p2wpkh":
-      default:
-        bipPath = `m/84'/0'/0'/1/${changeAddressIndex}`;
-        break;
-    }
-    const path = bipPath;
-    console.log(`${tag5}: Change address path: ${path} (index: ${changeAddressIndex})`);
-    const changeAddress = {
-      path,
-      isChange: true,
-      index: changeAddressIndex,
-      addressNList: import_pioneer_coins3.bip32ToAddressNList(path),
-      scriptType: actualChangeScriptType
-    };
+    const coinType = getCoinTypeFromNetworkId(networkId);
+    console.log(`${tag5}: Using SLIP-44 coin type ${coinType} for ${chain}`);
     const utxos = [];
     for (const pubkey of relevantPubkeys) {
       try {
@@ -2470,6 +2557,48 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, ke
     for (const utxo of utxos) {
       utxo.value = Number(utxo.value);
     }
+    const inputScriptTypes = utxos.map((u) => u.scriptType).filter(Boolean);
+    const scriptTypeCount = inputScriptTypes.reduce((acc, type) => {
+      acc[type] = (acc[type] || 0) + 1;
+      return acc;
+    }, {});
+    const mostCommonInputType = Object.entries(scriptTypeCount).sort(([, a], [, b2]) => b2 - a)[0]?.[0] || "p2pkh";
+    const actualChangeScriptType = changeScriptType || mostCommonInputType || relevantPubkeys[0]?.scriptType || "p2pkh";
+    console.log(`${tag5}: Input script types:`, scriptTypeCount);
+    console.log(`${tag5}: Using change script type: ${actualChangeScriptType} (matches inputs: ${mostCommonInputType})`);
+    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(`${tag5}: Change xpub selected for ${actualChangeScriptType}:`, changeXpub?.substring(0, 10) + "...");
+    let changeAddressIndex = await pioneer.GetChangeAddress({
+      network: chain,
+      xpub: changeXpub
+    });
+    changeAddressIndex = changeAddressIndex.data.changeIndex;
+    let bipPath;
+    switch (actualChangeScriptType) {
+      case "p2pkh":
+        bipPath = `m/44'/${coinType}'/0'/1/${changeAddressIndex}`;
+        break;
+      case "p2sh-p2wpkh":
+        bipPath = `m/49'/${coinType}'/0'/1/${changeAddressIndex}`;
+        break;
+      case "p2wpkh":
+      default:
+        bipPath = `m/84'/${coinType}'/0'/1/${changeAddressIndex}`;
+        break;
+    }
+    const path = bipPath;
+    console.log(`${tag5}: Change address path: ${path} (coin type: ${coinType}, index: ${changeAddressIndex})`);
+    const changeAddress = {
+      path,
+      isChange: true,
+      index: changeAddressIndex,
+      addressNList: import_pioneer_coins3.bip32ToAddressNList(path),
+      scriptType: actualChangeScriptType
+    };
     let feeRateFromNode;
     if (networkId === "bip122:00000000001a91e3dace36e2be3bf030") {
       console.log(`${tag5}: Using hardcoded fees for DOGE (10 sat/byte)`);
@@ -2587,11 +2716,9 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, ke
     })));
     let result;
     if (isMax) {
-      const { default: coinSelectSplit } = await Promise.resolve().then(() => __toESM(require_split()));
-      result = coinSelectSplit(utxos, [{ address: to }], effectiveFeeRate);
+      result = import_split.default(utxos, [{ address: to }], effectiveFeeRate);
     } else {
-      const { default: coinSelect } = await Promise.resolve().then(() => __toESM(require_coinselect()));
-      result = coinSelect(utxos, [{ address: to, value: amount }], effectiveFeeRate);
+      result = import_coinselect.default(utxos, [{ address: to, value: amount }], effectiveFeeRate);
     }
     console.log(tag5, "coinSelect result object:", result);
     console.log(tag5, "coinSelect result.inputs:", result?.inputs);
@@ -2708,6 +2835,7 @@ class TransactionManager {
   assetContext;
   balances;
   pubkeys;
+  pubkeyContext;
   nodes;
   pioneer;
   keepKeySdk;
@@ -2717,6 +2845,7 @@ class TransactionManager {
     this.assetContext = dependencies.assetContext;
     this.balances = dependencies.balances;
     this.pubkeys = dependencies.pubkeys;
+    this.pubkeyContext = dependencies.pubkeyContext;
     this.nodes = dependencies.nodes;
     this.pioneer = dependencies.pioneer;
     this.keepKeySdk = dependencies.keepKeySdk;
@@ -2750,20 +2879,20 @@ class TransactionManager {
       let unsignedTx;
       switch (type) {
         case "UTXO": {
-          unsignedTx = await createUnsignedUxtoTx(caip, to, amount, memo, this.pubkeys, this.pioneer, this.keepKeySdk, isMax, feeLevel, changeScriptType);
+          unsignedTx = await createUnsignedUxtoTx(caip, to, amount, memo, this.pubkeys, this.pioneer, this.pubkeyContext, isMax, feeLevel, changeScriptType);
           break;
         }
         case "TENDERMINT": {
           const txType = "transfer";
-          unsignedTx = await createUnsignedTendermintTx(caip, txType, amount, memo, this.pubkeys, this.pioneer, this.keepKeySdk, isMax, to);
+          unsignedTx = await createUnsignedTendermintTx(caip, txType, amount, memo, this.pubkeys, this.pioneer, this.pubkeyContext, isMax, to);
           break;
         }
         case "EIP155": {
-          unsignedTx = await createUnsignedEvmTx(caip, to, amount, memo, this.pubkeys, this.pioneer, this.keepKeySdk, isMax, feeLevel);
+          unsignedTx = await createUnsignedEvmTx(caip, to, amount, memo, this.pubkeys, this.pioneer, this.pubkeyContext, isMax, feeLevel);
           break;
         }
         case "OTHER": {
-          unsignedTx = await createUnsignedRippleTx(caip, to, amount, memo, this.pubkeys, this.pioneer, this.keepKeySdk, isMax);
+          unsignedTx = await createUnsignedRippleTx(caip, to, amount, memo, this.pubkeys, this.pioneer, this.pubkeyContext, isMax);
           break;
         }
         default: {
@@ -2862,9 +2991,20 @@ class TransactionManager {
             }
             case "cosmos:mayachain-mainnet-v1/slip44:931":
             case "cosmos:mayachain-mainnet-v1/denom:maya": {
+              console.log(tag5, "\uD83D\uDD0D ===== MAYACHAIN SIGNING AUDIT =====");
+              console.log(tag5, "\uD83D\uDCCB unsignedTx:", JSON.stringify(unsignedTx, null, 2));
+              console.log(tag5, "\uD83D\uDD11 unsignedTx.addressNList:", unsignedTx.addressNList);
+              console.log(tag5, "\uD83D\uDCCD unsignedTx.signerAddress:", unsignedTx.signerAddress);
+              console.log(tag5, "\uD83C\uDF10 pubkeyContext:", this.pubkeyContext);
+              console.log(tag5, "\uD83D\uDD10 pubkeyContext.addressNList:", this.pubkeyContext?.addressNList);
+              console.log(tag5, "\uD83D\uDD10 pubkeyContext.addressNListMaster:", this.pubkeyContext?.addressNListMaster);
+              console.log(tag5, "\uD83D\uDCEC pubkeyContext.address:", this.pubkeyContext?.address);
+              console.log(tag5, "=======================================");
               if (unsignedTx.signDoc.msgs[0].type === "mayachain/MsgSend") {
                 const responseSign = await this.keepKeySdk.mayachain.mayachainSignAminoTransfer(unsignedTx);
                 signedTx = responseSign.serialized;
+                console.log(tag5, "✅ Signing completed");
+                console.log(tag5, "\uD83D\uDCE6 responseSign:", responseSign);
               } else if (unsignedTx.signDoc.msgs[0].type === "mayachain/MsgDeposit") {
                 const responseSign = await this.keepKeySdk.mayachain.mayachainSignAminoDeposit(unsignedTx);
                 signedTx = responseSign.serialized;
@@ -3056,18 +3196,21 @@ var cosmosClaimAllRewardsTemplate = (params) => ({
 
 // src/txbuilder/createUnsignedStakingTx.ts
 var TAG5 = " | createUnsignedStakingTx | ";
-async function createUnsignedStakingTx(caip, params, pubkeys, pioneer, keepKeySdk) {
+async function createUnsignedStakingTx(caip, params, pubkeys, pioneer, pubkeyContext) {
   const tag5 = TAG5 + " | createUnsignedStakingTx | ";
   try {
     if (!pioneer)
       throw new Error("Failed to init! pioneer");
     const networkId = import_pioneer_caip5.caipToNetworkId(caip);
-    if (!keepKeySdk.pubkeyContext?.networks?.includes(networkId)) {
-      keepKeySdk.pubkeyContext = pubkeys.find((pk) => pk.networks?.includes(networkId));
+    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(tag5, `✅ Using pubkeyContext for network ${networkId}:`, {
+      address: pubkeyContext.address
+    });
     let chain;
     let chainId;
     let denom;
@@ -3098,7 +3241,7 @@ async function createUnsignedStakingTx(caip, params, pubkeys, pioneer, keepKeySd
         throw new Error(`Unsupported networkId for staking: ${networkId}`);
     }
     console.log(tag5, `Building ${params.type} transaction for ${chain}`);
-    const fromAddress = keepKeySdk.pubkeyContext.address || keepKeySdk.pubkeyContext.pubkey;
+    const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
     const accountInfo = (await pioneer.GetAccountInfo({ network: chain, address: fromAddress })).data;
     console.log(tag5, "accountInfo: ", accountInfo);
     let account_number;
@@ -3221,6 +3364,12 @@ function getNetworkName(networkId) {
   };
   return networkNames[networkId] || networkId;
 }
+function withTimeout(promise, timeoutMs) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => setTimeout(() => reject(new Error("Request timeout")), timeoutMs))
+  ]);
+}
 async function getFees(pioneer, networkId) {
   const tag5 = TAG6 + " | getFees | ";
   try {
@@ -3230,10 +3379,6 @@ async function getFees(pioneer, networkId) {
       console.log(tag5, "Using hardcoded fees for Cosmos network:", networkId);
       return getCosmosFees(networkId);
     }
-    if (networkType === "RIPPLE") {
-      console.log(tag5, "Using hardcoded fees for Ripple:", networkId);
-      return getRippleFees(networkId);
-    }
     if (networkId === "bip122:00000000001a91e3dace36e2be3bf030") {
       console.log(tag5, "Using hardcoded fees for Dogecoin: 10 sat/byte");
       return {
@@ -3266,15 +3411,51 @@ async function getFees(pioneer, networkId) {
         raw: { hardcoded: true, reason: "DOGE fee estimation unreliable" }
       };
     }
-    const feeResponse = await (pioneer.GetFeeRateByNetwork ? pioneer.GetFeeRateByNetwork({ networkId }) : pioneer.GetFeeRate({ networkId }));
+    let feeResponse;
+    if (networkId === "bip122:000007d91d1254d60e2dd1ae58038307") {
+      try {
+        const apiCall = pioneer.GetFeeRateByNetwork ? pioneer.GetFeeRateByNetwork({ networkId }) : pioneer.GetFeeRate({ networkId });
+        feeResponse = await withTimeout(apiCall, 3000);
+      } catch (timeoutError) {
+        console.warn(tag5, "Dash fee API timeout, using fallback fees");
+        return {
+          slow: {
+            label: "Economy",
+            value: "5",
+            unit: "sat/byte",
+            description: "Low priority - 30+ minutes",
+            estimatedTime: "~30 minutes",
+            priority: "low"
+          },
+          average: {
+            label: "Standard",
+            value: "8",
+            unit: "sat/byte",
+            description: "Normal priority - 10-30 minutes",
+            estimatedTime: "~15 minutes",
+            priority: "medium"
+          },
+          fastest: {
+            label: "Priority",
+            value: "10",
+            unit: "sat/byte",
+            description: "High priority - next block",
+            estimatedTime: "~5 minutes",
+            priority: "high"
+          },
+          networkId,
+          networkType: "UTXO",
+          raw: { hardcoded: true, reason: "Dash API timeout, using conservative fallback fees" }
+        };
+      }
+    } else {
+      feeResponse = await (pioneer.GetFeeRateByNetwork ? pioneer.GetFeeRateByNetwork({ networkId }) : pioneer.GetFeeRate({ networkId }));
+    }
     if (!feeResponse || !feeResponse.data) {
       throw new Error(`No fee data returned for ${networkId}`);
     }
     const feeData = feeResponse.data;
     console.log(tag5, "Raw fee data:", feeData);
-    if (feeData.success === false || feeData.error) {
-      throw new Error(feeData.error || `API error for ${networkId}`);
-    }
     const networkName = getNetworkName(networkId);
     let normalizedFees = normalizeFeeData(feeData, networkType, networkName, networkId);
     normalizedFees = ensureFeeDifferentiation(normalizedFees, networkType);
@@ -3480,7 +3661,7 @@ function getCosmosFees(networkId) {
   const networkName = getNetworkName(networkId);
   const cosmosFeesMap = {
     "cosmos:thorchain-mainnet-v1": { base: 0.02, unit: "RUNE", denom: "rune" },
-    "cosmos:mayachain-mainnet-v1": { base: 0.2, unit: "MAYA", denom: "maya" },
+    "cosmos:mayachain-mainnet-v1": { base: 0.5, unit: "CACAO", denom: "cacao" },
     "cosmos:cosmoshub-4": { base: 0.005, unit: "ATOM", denom: "uatom" },
     "cosmos:osmosis-1": { base: 0.035, unit: "OSMO", denom: "uosmo" }
   };
@@ -3518,39 +3699,6 @@ function getCosmosFees(networkId) {
     raw: { hardcoded: true, base: feeConfig.base, unit: feeConfig.unit, denom: feeConfig.denom }
   };
 }
-function getRippleFees(networkId) {
-  const networkName = getNetworkName(networkId);
-  const baseFee = "0.00001";
-  return {
-    slow: {
-      label: "Standard",
-      value: baseFee,
-      unit: "XRP",
-      description: `Fixed network fee for ${networkName}. All transactions use the same fee.`,
-      estimatedTime: "~4 seconds",
-      priority: "low"
-    },
-    average: {
-      label: "Standard",
-      value: baseFee,
-      unit: "XRP",
-      description: `Fixed network fee for ${networkName}. All transactions use the same fee.`,
-      estimatedTime: "~4 seconds",
-      priority: "medium"
-    },
-    fastest: {
-      label: "Standard",
-      value: baseFee,
-      unit: "XRP",
-      description: `Fixed network fee for ${networkName}. All transactions use the same fee.`,
-      estimatedTime: "~4 seconds",
-      priority: "high"
-    },
-    networkId,
-    networkType: "RIPPLE",
-    raw: { hardcoded: true, baseFee, reason: "Ripple uses fixed network fees" }
-  };
-}
 function getFallbackFees(networkId) {
   const networkType = getNetworkType(networkId);
   const networkName = getNetworkName(networkId);
@@ -3624,9 +3772,10 @@ function estimateTransactionFee(feeRate, unit, networkType, txSize) {
   }
 }
 
-// src/utils/kkapi-detection.ts
+// src/index.ts
+var TAG7 = " | Pioneer-sdk | ";
 async function detectKkApiAvailability(forceLocalhost) {
-  const tag5 = " | detectKkApiAvailability | ";
+  const tag5 = `${TAG7} | detectKkApiAvailability | `;
   try {
     const isTauri = typeof window !== "undefined" && "__TAURI__" in window;
     const isBrowser = typeof window !== "undefined";
@@ -3673,8 +3822,6 @@ async function detectKkApiAvailability(forceLocalhost) {
     };
   }
 }
-
-// src/utils/format-time.ts
 function formatTime(durationMs) {
   let seconds = Math.floor(durationMs / 1000 % 60);
   let minutes = Math.floor(durationMs / (1000 * 60) % 60);
@@ -3688,150 +3835,6 @@ function formatTime(durationMs) {
   return formatted.trim();
 }
 
-// src/utils/build-dashboard.ts
-var import_pioneer_caip6 = require("@pioneer-platform/pioneer-caip");
-var TAG7 = " | build-dashboard | ";
-function buildDashboardFromBalances(balances, blockchains, assetsMap) {
-  console.log(TAG7, "[DASHBOARD] Building dashboard from cached balances...");
-  const dashboardData = {
-    networks: [],
-    totalValueUsd: 0,
-    networkPercentages: []
-  };
-  let totalPortfolioValue = 0;
-  const networksTemp = [];
-  console.log(TAG7, "balances: ", balances);
-  for (const blockchain of blockchains) {
-    const filteredBalances = balances.filter((b2) => {
-      const networkId = import_pioneer_caip6.caipToNetworkId(b2.caip);
-      return networkId === blockchain || blockchain === "eip155:*" && networkId.startsWith("eip155:");
-    });
-    const balanceMap = new Map;
-    const isBitcoin = blockchain.includes("bip122:000000000019d6689c085ae165831e93");
-    if (isBitcoin) {
-      console.log(TAG7, "Bitcoin network detected - checking for duplicate balances");
-      const bitcoinByValue = new Map;
-      filteredBalances.forEach((balance) => {
-        const valueKey = `${balance.balance}_${balance.valueUsd}`;
-        if (!bitcoinByValue.has(valueKey)) {
-          bitcoinByValue.set(valueKey, []);
-        }
-        bitcoinByValue.get(valueKey).push(balance);
-      });
-      for (const [valueKey, balances2] of bitcoinByValue.entries()) {
-        if (balances2.length === 3 && parseFloat(balances2[0].valueUsd || "0") > 0) {
-          console.log(TAG7, "BITCOIN API BUG DETECTED: All 3 address types have same balance, keeping only xpub");
-          const xpubBalance = balances2.find((b2) => b2.pubkey?.startsWith("xpub")) || balances2[0];
-          const key = `${xpubBalance.caip}_${xpubBalance.pubkey || "default"}`;
-          balanceMap.set(key, xpubBalance);
-        } else {
-          balances2.forEach((balance) => {
-            const key = `${balance.caip}_${balance.pubkey || "default"}`;
-            balanceMap.set(key, balance);
-          });
-        }
-      }
-    } else {
-      filteredBalances.forEach((balance) => {
-        const key = `${balance.caip}_${balance.pubkey || "default"}`;
-        if (!balanceMap.has(key) || parseFloat(balance.valueUsd || "0") > parseFloat(balanceMap.get(key).valueUsd || "0")) {
-          balanceMap.set(key, balance);
-        }
-      });
-    }
-    const networkBalances = Array.from(balanceMap.values());
-    const networkTotal = networkBalances.reduce((sum, balance, idx) => {
-      const valueUsd = typeof balance.valueUsd === "string" ? parseFloat(balance.valueUsd) : balance.valueUsd || 0;
-      if (blockchain.includes("bip122:000000000019d6689c085ae165831e93")) {
-        console.log(TAG7, `[BITCOIN DEBUG ${idx}] pubkey:`, balance.pubkey?.substring(0, 10) + "...", "| balance:", balance.balance, "| valueUsd:", balance.valueUsd, "→ parsed:", valueUsd, "| running sum:", sum + valueUsd);
-      }
-      return sum + valueUsd;
-    }, 0);
-    const nativeAssetCaip = import_pioneer_caip6.networkIdToCaip(blockchain);
-    const gasAsset = networkBalances.find((b2) => b2.caip === nativeAssetCaip);
-    const totalNativeBalance = networkBalances.filter((b2) => b2.caip === nativeAssetCaip).reduce((sum, balance) => {
-      const balanceNum = typeof balance.balance === "string" ? parseFloat(balance.balance) : balance.balance || 0;
-      return sum + balanceNum;
-    }, 0).toString();
-    const assetInfo = nativeAssetCaip ? assetsMap.get(nativeAssetCaip) : null;
-    networksTemp.push({
-      networkId: blockchain,
-      totalValueUsd: networkTotal,
-      gasAssetCaip: nativeAssetCaip || null,
-      gasAssetSymbol: gasAsset?.ticker || gasAsset?.symbol || assetInfo?.symbol || null,
-      icon: gasAsset?.icon || assetInfo?.icon || null,
-      color: gasAsset?.color || assetInfo?.color || null,
-      totalNativeBalance
-    });
-    totalPortfolioValue += networkTotal;
-  }
-  dashboardData.networks = networksTemp.sort((a, b2) => b2.totalValueUsd - a.totalValueUsd);
-  dashboardData.totalValueUsd = totalPortfolioValue;
-  dashboardData.networkPercentages = dashboardData.networks.map((network) => ({
-    networkId: network.networkId,
-    percentage: totalPortfolioValue > 0 ? Number((network.totalValueUsd / totalPortfolioValue * 100).toFixed(2)) : 0
-  })).filter((entry) => entry.percentage > 0);
-  console.log(`[FAST DASHBOARD] ✅ Built dashboard: ${dashboardData.networks.length} networks, $${totalPortfolioValue.toFixed(2)} total`);
-  return dashboardData;
-}
-
-// src/utils/pubkey-helpers.ts
-function getPubkeyKey(pubkey) {
-  return `${pubkey.pubkey}_${pubkey.pathMaster}`;
-}
-function deduplicatePubkeys(pubkeys) {
-  const seen = new Set;
-  const deduped = pubkeys.filter((pubkey) => {
-    const key = getPubkeyKey(pubkey);
-    if (seen.has(key)) {
-      return false;
-    }
-    seen.add(key);
-    return true;
-  });
-  return deduped;
-}
-function validatePubkey(pubkey) {
-  return !!(pubkey.pubkey && pubkey.pathMaster);
-}
-
-class PubkeyManager {
-  pubkeys = [];
-  pubkeySet = new Set;
-  addPubkey(pubkey) {
-    if (!validatePubkey(pubkey)) {
-      return false;
-    }
-    const key = getPubkeyKey(pubkey);
-    if (this.pubkeySet.has(key)) {
-      return false;
-    }
-    this.pubkeys.push(pubkey);
-    this.pubkeySet.add(key);
-    return true;
-  }
-  setPubkeys(newPubkeys) {
-    this.pubkeys = [];
-    this.pubkeySet.clear();
-    let added = 0;
-    for (const pubkey of newPubkeys) {
-      if (this.addPubkey(pubkey)) {
-        added++;
-      }
-    }
-  }
-  getPubkeys() {
-    return this.pubkeys;
-  }
-  clear() {
-    this.pubkeys = [];
-    this.pubkeySet.clear();
-  }
-}
-
-// src/index.ts
-var TAG8 = " | Pioneer-sdk | ";
-
 class SDK {
   status;
   username;
@@ -3855,7 +3858,7 @@ class SDK {
   charts;
   paths;
   pubkeys = [];
-  pubkeyManager = new PubkeyManager;
+  pubkeySet = new Set;
   wallets;
   balances;
   nodes;
@@ -3932,11 +3935,10 @@ class SDK {
     if (config.blockchains && config.blockchains.length !== this.blockchains.length) {
     }
     if (config.pubkeys && config.pubkeys.length > 0) {
-      this.pubkeyManager.setPubkeys(config.pubkeys);
-      this.pubkeys = this.pubkeyManager.getPubkeys();
+      this.setPubkeys(config.pubkeys);
     } else {
       this.pubkeys = [];
-      this.pubkeyManager.clear();
+      this.pubkeySet.clear();
     }
     this.balances = config.balances || [];
     this.nodes = config.nodes || [];
@@ -3952,7 +3954,7 @@ class SDK {
     this.outboundBlockchainContext = null;
     this.outboundPubkeyContext = null;
     this.wallets = [];
-    this.events = new import_events.EventEmitter;
+    this.events = new import_events.default;
     this.transactions = null;
     this.ethplorerApiKey = config.ethplorerApiKey;
     this.covalentApiKey = config.covalentApiKey;
@@ -3967,21 +3969,46 @@ class SDK {
     this.pairWallet = async (options) => {
       return Promise.resolve({});
     };
-    this.getPubkeyKey = getPubkeyKey;
-    this.deduplicatePubkeys = deduplicatePubkeys;
+    this.getPubkeyKey = (pubkey) => {
+      return `${pubkey.pubkey}_${pubkey.pathMaster}`;
+    };
+    this.deduplicatePubkeys = (pubkeys) => {
+      const seen = new Set;
+      const deduped = pubkeys.filter((pubkey) => {
+        const key = this.getPubkeyKey(pubkey);
+        if (seen.has(key)) {
+          return false;
+        }
+        seen.add(key);
+        return true;
+      });
+      return deduped;
+    };
     this.addPubkey = (pubkey) => {
-      const result = this.pubkeyManager.addPubkey(pubkey);
-      if (result) {
-        this.pubkeys = this.pubkeyManager.getPubkeys();
+      if (!pubkey.pubkey || !pubkey.pathMaster) {
+        return false;
+      }
+      const key = this.getPubkeyKey(pubkey);
+      if (this.pubkeySet.has(key)) {
+        return false;
       }
-      return result;
+      this.pubkeys.push(pubkey);
+      this.pubkeySet.add(key);
+      return true;
     };
     this.setPubkeys = (newPubkeys) => {
-      this.pubkeyManager.setPubkeys(newPubkeys);
-      this.pubkeys = this.pubkeyManager.getPubkeys();
+      const tag5 = `${TAG7} | setPubkeys | `;
+      this.pubkeys = [];
+      this.pubkeySet.clear();
+      let added = 0;
+      for (const pubkey of newPubkeys) {
+        if (this.addPubkey(pubkey)) {
+          added++;
+        }
+      }
     };
     this.getUnifiedPortfolio = async function() {
-      const tag5 = `${TAG8} | getUnifiedPortfolio | `;
+      const tag5 = `${TAG7} | getUnifiedPortfolio | `;
       try {
         const startTime = performance.now();
         try {
@@ -4013,9 +4040,8 @@ class SDK {
             this.events.emit("SET_BALANCES", this.balances);
           }
           if (portfolioData.pubkeys && portfolioData.pubkeys.length > 0) {
-            const convertedPubkeys = portfolioData.pubkeys;
-            this.pubkeyManager.setPubkeys(convertedPubkeys);
-            this.pubkeys = this.pubkeyManager.getPubkeys();
+            const convertedPubkeys = this.convertVaultPubkeysToPioneerFormat(portfolioData.pubkeys);
+            this.setPubkeys(convertedPubkeys);
             this.events.emit("SET_PUBKEYS", this.pubkeys);
           }
           if (portfolioData.devices && portfolioData.devices.length > 0) {
@@ -4065,7 +4091,7 @@ class SDK {
             this.events.emit("SET_DASHBOARD", this.dashboard);
           } else {
             console.warn("[CACHE VALIDATION] ❌ Cache data corrupted, building dashboard from cached balances");
-            const dashboardData = buildDashboardFromBalances(this.balances, this.blockchains, this.assetsMap);
+            const dashboardData = this.buildDashboardFromBalances();
             this.dashboard = dashboardData;
             this.events.emit("SET_DASHBOARD", this.dashboard);
           }
@@ -4090,7 +4116,7 @@ class SDK {
       }
     };
     this.init = async function(walletsVerbose, setup) {
-      const tag5 = `${TAG8} | init | `;
+      const tag5 = `${TAG7} | init | `;
       try {
         if (!this.username)
           throw Error("username required!");
@@ -4107,7 +4133,7 @@ class SDK {
         const pioneerConfig = {
           ...config
         };
-        const PioneerClient = new import_pioneer_client.Pioneer(this.spec, pioneerConfig);
+        const PioneerClient = new import_pioneer_client.default(this.spec, pioneerConfig);
         this.pioneer = await PioneerClient.init();
         if (!this.pioneer)
           throw Error("Failed to init pioneer server!");
@@ -4177,11 +4203,92 @@ class SDK {
         throw e;
       }
     };
-    this.buildDashboardFromBalances = () => {
-      return buildDashboardFromBalances(this.balances, this.blockchains, this.assetsMap);
+    this.buildDashboardFromBalances = function() {
+      const tag5 = `${TAG7} | buildDashboardFromBalances | `;
+      console.log(tag5, "[DASHBOARD] Building dashboard from cached balances...");
+      const dashboardData = {
+        networks: [],
+        totalValueUsd: 0,
+        networkPercentages: []
+      };
+      let totalPortfolioValue = 0;
+      const networksTemp = [];
+      console.log(tag5, "this.balances: ", this.balances);
+      for (const blockchain of this.blockchains) {
+        const filteredBalances = this.balances.filter((b2) => {
+          const networkId = import_pioneer_caip6.caipToNetworkId(b2.caip);
+          return networkId === blockchain || blockchain === "eip155:*" && networkId.startsWith("eip155:");
+        });
+        const balanceMap = new Map;
+        const isBitcoin = blockchain.includes("bip122:000000000019d6689c085ae165831e93");
+        if (isBitcoin) {
+          console.log(tag5, "Bitcoin network detected - checking for duplicate balances");
+          const bitcoinByValue = new Map;
+          filteredBalances.forEach((balance) => {
+            const valueKey = `${balance.balance}_${balance.valueUsd}`;
+            if (!bitcoinByValue.has(valueKey)) {
+              bitcoinByValue.set(valueKey, []);
+            }
+            bitcoinByValue.get(valueKey).push(balance);
+          });
+          for (const [valueKey, balances] of bitcoinByValue.entries()) {
+            if (balances.length === 3 && parseFloat(balances[0].valueUsd || "0") > 0) {
+              console.log(tag5, "BITCOIN API BUG DETECTED: All 3 address types have same balance, keeping only xpub");
+              const xpubBalance = balances.find((b2) => b2.pubkey?.startsWith("xpub")) || balances[0];
+              const key = `${xpubBalance.caip}_${xpubBalance.pubkey || "default"}`;
+              balanceMap.set(key, xpubBalance);
+            } else {
+              balances.forEach((balance) => {
+                const key = `${balance.caip}_${balance.pubkey || "default"}`;
+                balanceMap.set(key, balance);
+              });
+            }
+          }
+        } else {
+          filteredBalances.forEach((balance) => {
+            const key = `${balance.caip}_${balance.pubkey || "default"}`;
+            if (!balanceMap.has(key) || parseFloat(balance.valueUsd || "0") > parseFloat(balanceMap.get(key).valueUsd || "0")) {
+              balanceMap.set(key, balance);
+            }
+          });
+        }
+        const networkBalances = Array.from(balanceMap.values());
+        const networkTotal = networkBalances.reduce((sum, balance, idx) => {
+          const valueUsd = typeof balance.valueUsd === "string" ? parseFloat(balance.valueUsd) : balance.valueUsd || 0;
+          if (blockchain.includes("bip122:000000000019d6689c085ae165831e93")) {
+            console.log(tag5, `[BITCOIN DEBUG ${idx}] pubkey:`, balance.pubkey?.substring(0, 10) + "...", "| balance:", balance.balance, "| valueUsd:", balance.valueUsd, "→ parsed:", valueUsd, "| running sum:", sum + valueUsd);
+          }
+          return sum + valueUsd;
+        }, 0);
+        const nativeAssetCaip = import_pioneer_caip6.networkIdToCaip(blockchain);
+        const gasAsset = networkBalances.find((b2) => b2.caip === nativeAssetCaip);
+        const totalNativeBalance = networkBalances.filter((b2) => b2.caip === nativeAssetCaip).reduce((sum, balance) => {
+          const balanceNum = typeof balance.balance === "string" ? parseFloat(balance.balance) : balance.balance || 0;
+          return sum + balanceNum;
+        }, 0).toString();
+        const assetInfo = nativeAssetCaip ? this.assetsMap.get(nativeAssetCaip) : null;
+        networksTemp.push({
+          networkId: blockchain,
+          totalValueUsd: networkTotal,
+          gasAssetCaip: nativeAssetCaip || null,
+          gasAssetSymbol: gasAsset?.ticker || gasAsset?.symbol || assetInfo?.symbol || null,
+          icon: gasAsset?.icon || assetInfo?.icon || null,
+          color: gasAsset?.color || assetInfo?.color || null,
+          totalNativeBalance
+        });
+        totalPortfolioValue += networkTotal;
+      }
+      dashboardData.networks = networksTemp.sort((a, b2) => b2.totalValueUsd - a.totalValueUsd);
+      dashboardData.totalValueUsd = totalPortfolioValue;
+      dashboardData.networkPercentages = dashboardData.networks.map((network) => ({
+        networkId: network.networkId,
+        percentage: totalPortfolioValue > 0 ? Number((network.totalValueUsd / totalPortfolioValue * 100).toFixed(2)) : 0
+      })).filter((entry) => entry.percentage > 0);
+      console.log(`[FAST DASHBOARD] ✅ Built dashboard: ${dashboardData.networks.length} networks, $${totalPortfolioValue.toFixed(2)} total`);
+      return dashboardData;
     };
     this.syncMarket = async function() {
-      const tag5 = `${TAG8} | syncMarket | `;
+      const tag5 = `${TAG7} | syncMarket | `;
       try {
         const invalidBalances = this.balances.filter((b2) => !b2 || !b2.caip || typeof b2.caip !== "string" || !b2.caip.includes(":"));
         if (invalidBalances.length > 0) {
@@ -4232,7 +4339,7 @@ class SDK {
       }
     };
     this.sync = async function() {
-      const tag5 = `${TAG8} | sync | `;
+      const tag5 = `${TAG7} | sync | `;
       try {
         const matchesNetwork = (item, networkId) => {
           if (!item.networks || !Array.isArray(item.networks))
@@ -4287,7 +4394,7 @@ class SDK {
         console.log(tag5, "uniqueBlockchains: ", uniqueBlockchains);
         for (const blockchain of uniqueBlockchains) {
           const filteredBalances = this.balances.filter((b2) => {
-            const networkId = import_pioneer_caip7.caipToNetworkId(b2.caip);
+            const networkId = import_pioneer_caip6.caipToNetworkId(b2.caip);
             return networkId === blockchain || blockchain === "eip155:*" && networkId.startsWith("eip155:");
           });
           console.log(tag5, `Filtering for blockchain: ${blockchain}`);
@@ -4345,7 +4452,7 @@ class SDK {
             return sum + valueUsd;
           }, 0);
           console.log("Final networkTotal:", networkTotal);
-          const nativeAssetCaip = import_pioneer_caip7.networkIdToCaip(blockchain);
+          const nativeAssetCaip = import_pioneer_caip6.networkIdToCaip(blockchain);
           const gasAsset = networkBalances.find((b2) => b2.caip === nativeAssetCaip);
           const totalNativeBalance = networkBalances.filter((b2) => b2.caip === nativeAssetCaip).reduce((sum, balance) => {
             const balanceNum = typeof balance.balance === "string" ? parseFloat(balance.balance) : balance.balance || 0;
@@ -4385,7 +4492,7 @@ class SDK {
       }
     };
     this.buildTx = async function(sendPayload) {
-      let tag5 = TAG8 + " | buildTx | ";
+      let tag5 = TAG7 + " | buildTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4393,6 +4500,7 @@ class SDK {
           balances: this.balances,
           pioneer: this.pioneer,
           pubkeys: this.pubkeys,
+          pubkeyContext: this.pubkeyContext,
           nodes: this.nodes,
           keepKeySdk: this.keepKeySdk
         };
@@ -4406,13 +4514,13 @@ class SDK {
       }
     };
     this.buildDelegateTx = async function(caip, params) {
-      let tag5 = TAG8 + " | buildDelegateTx | ";
+      let tag5 = TAG7 + " | buildDelegateTx | ";
       try {
         const delegateParams = {
           ...params,
           type: "delegate"
         };
-        let unsignedTx = await createUnsignedStakingTx(caip, delegateParams, this.pubkeys, this.pioneer, this.keepKeySdk);
+        let unsignedTx = await createUnsignedStakingTx(caip, delegateParams, this.pubkeys, this.pioneer, this.pubkeyContext);
         console.log(tag5, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
@@ -4421,13 +4529,13 @@ class SDK {
       }
     };
     this.buildUndelegateTx = async function(caip, params) {
-      let tag5 = TAG8 + " | buildUndelegateTx | ";
+      let tag5 = TAG7 + " | buildUndelegateTx | ";
       try {
         const undelegateParams = {
           ...params,
           type: "undelegate"
         };
-        let unsignedTx = await createUnsignedStakingTx(caip, undelegateParams, this.pubkeys, this.pioneer, this.keepKeySdk);
+        let unsignedTx = await createUnsignedStakingTx(caip, undelegateParams, this.pubkeys, this.pioneer, this.pubkeyContext);
         console.log(tag5, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
@@ -4436,13 +4544,13 @@ class SDK {
       }
     };
     this.buildClaimRewardsTx = async function(caip, params) {
-      let tag5 = TAG8 + " | buildClaimRewardsTx | ";
+      let tag5 = TAG7 + " | buildClaimRewardsTx | ";
       try {
         const claimParams = {
           ...params,
           type: "claim_rewards"
         };
-        let unsignedTx = await createUnsignedStakingTx(caip, claimParams, this.pubkeys, this.pioneer, this.keepKeySdk);
+        let unsignedTx = await createUnsignedStakingTx(caip, claimParams, this.pubkeys, this.pioneer, this.pubkeyContext);
         console.log(tag5, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
@@ -4451,13 +4559,13 @@ class SDK {
       }
     };
     this.buildClaimAllRewardsTx = async function(caip, params) {
-      let tag5 = TAG8 + " | buildClaimAllRewardsTx | ";
+      let tag5 = TAG7 + " | buildClaimAllRewardsTx | ";
       try {
         const claimAllParams = {
           ...params,
           type: "claim_all_rewards"
         };
-        let unsignedTx = await createUnsignedStakingTx(caip, claimAllParams, this.pubkeys, this.pioneer, this.keepKeySdk);
+        let unsignedTx = await createUnsignedStakingTx(caip, claimAllParams, this.pubkeys, this.pioneer, this.pubkeyContext);
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -4465,7 +4573,7 @@ class SDK {
       }
     };
     this.signTx = async function(unsignedTx) {
-      let tag5 = TAG8 + " | signTx | ";
+      let tag5 = TAG7 + " | signTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4473,6 +4581,7 @@ class SDK {
           balances: this.balances,
           pioneer: this.pioneer,
           pubkeys: this.pubkeys,
+          pubkeyContext: this.pubkeyContext,
           nodes: this.nodes,
           keepKeySdk: this.keepKeySdk
         };
@@ -4485,7 +4594,7 @@ class SDK {
       }
     };
     this.broadcastTx = async function(caip, signedTx) {
-      let tag5 = TAG8 + " | broadcastTx | ";
+      let tag5 = TAG7 + " | broadcastTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4498,7 +4607,7 @@ class SDK {
         };
         let txManager = new TransactionManager(transactionDependencies, this.events);
         let payload = {
-          networkId: import_pioneer_caip7.caipToNetworkId(caip),
+          networkId: import_pioneer_caip6.caipToNetworkId(caip),
           serialized: signedTx
         };
         let txid = await txManager.broadcast(payload);
@@ -4509,7 +4618,7 @@ class SDK {
       }
     };
     this.swap = async function(swapPayload) {
-      let tag5 = `${TAG8} | swap | `;
+      let tag5 = `${TAG7} | swap | `;
       try {
         if (!swapPayload)
           throw Error("swapPayload required!");
@@ -4644,7 +4753,7 @@ class SDK {
       }
     };
     this.transfer = async function(sendPayload) {
-      let tag5 = `${TAG8} | transfer | `;
+      let tag5 = `${TAG7} | transfer | `;
       try {
         if (!sendPayload)
           throw Error("sendPayload required!");
@@ -4671,7 +4780,7 @@ class SDK {
         if (!signedTx)
           throw Error("Failed to sign transaction!");
         let payload = {
-          networkId: import_pioneer_caip7.caipToNetworkId(caip),
+          networkId: import_pioneer_caip6.caipToNetworkId(caip),
           serialized: signedTx
         };
         let txid = await txManager.broadcast(payload);
@@ -4700,7 +4809,7 @@ class SDK {
         while (!isConfirmed) {
           try {
             const response = await this.pioneer.LookupTx({
-              networkId: import_pioneer_caip7.caipToNetworkId(caip),
+              networkId: import_pioneer_caip6.caipToNetworkId(caip),
               txid
             });
             if (response?.data?.data) {
@@ -4739,7 +4848,7 @@ class SDK {
       }
     };
     this.setBlockchains = async function(blockchains) {
-      const tag5 = `${TAG8} | setBlockchains | `;
+      const tag5 = `${TAG7} | setBlockchains | `;
       try {
         if (!blockchains)
           throw Error("blockchains required!");
@@ -4755,7 +4864,7 @@ class SDK {
       }
     };
     this.addAsset = async function(caip, data) {
-      let tag5 = TAG8 + " | addAsset | ";
+      let tag5 = TAG7 + " | addAsset | ";
       try {
         let success = false;
         if (!caip)
@@ -4793,7 +4902,7 @@ class SDK {
       }
     };
     this.clearWalletState = async function() {
-      const tag5 = `${TAG8} | clearWalletState | `;
+      const tag5 = `${TAG7} | clearWalletState | `;
       try {
         this.context = null;
         this.paths = [];
@@ -4807,15 +4916,62 @@ class SDK {
         throw e;
       }
     };
+    this.addPath = async function(path) {
+      const tag5 = `${TAG7} | addPath | `;
+      try {
+        this.paths.push(path);
+        const pubkey = await getPubkey(path.networks[0], path, this.keepKeySdk, this.context);
+        this.addPubkey(pubkey);
+        await this.getBalancesForNetworks(path.networks);
+        this.buildDashboardFromBalances();
+        return { success: true, pubkey };
+      } catch (e) {
+        console.error(tag5, "Failed:", e);
+        throw e;
+      }
+    };
+    this.addPaths = async function(paths) {
+      const tag5 = `${TAG7} | addPaths | `;
+      try {
+        console.log(tag5, `Adding ${paths.length} paths in batch mode...`);
+        this.paths.push(...paths);
+        const newPubkeys = [];
+        for (const path of paths) {
+          try {
+            const pubkey = await getPubkey(path.networks[0], path, this.keepKeySdk, this.context);
+            this.addPubkey(pubkey);
+            newPubkeys.push(pubkey);
+          } catch (error) {
+            console.warn(tag5, `Failed to get pubkey for path ${path.note}:`, error.message);
+          }
+        }
+        console.log(tag5, `Successfully added ${newPubkeys.length} pubkeys`);
+        const networkSet = new Set;
+        for (const path of paths) {
+          if (path.networks && Array.isArray(path.networks)) {
+            path.networks.forEach((net) => networkSet.add(net));
+          }
+        }
+        const uniqueNetworks = [...networkSet];
+        console.log(tag5, `Fetching balances for ${uniqueNetworks.length} unique networks in single API call...`);
+        await this.getBalancesForNetworks(uniqueNetworks);
+        this.buildDashboardFromBalances();
+        console.log(tag5, `Batch add complete: ${paths.length} paths, ${newPubkeys.length} pubkeys, ${this.balances?.length || 0} balances`);
+        return { success: true, pubkeys: newPubkeys };
+      } catch (e) {
+        console.error(tag5, "Failed:", e);
+        throw e;
+      }
+    };
     this.getAssets = async function() {
       return this.getGasAssets();
     };
     this.getGasAssets = async function() {
-      const tag5 = `${TAG8} | getGasAssets | `;
+      const tag5 = `${TAG7} | getGasAssets | `;
       try {
         for (let i = 0;i < this.blockchains.length; i++) {
           let networkId = this.blockchains[i];
-          let caip = import_pioneer_caip7.networkIdToCaip(networkId);
+          let caip = import_pioneer_caip6.networkIdToCaip(networkId);
           let asset = await import_pioneer_discovery2.assetData[caip.toLowerCase()];
           if (asset) {
             asset.caip = caip.toLowerCase();
@@ -4854,7 +5010,7 @@ class SDK {
       }
     };
     this.getPubkeys = async function() {
-      const tag5 = `${TAG8} | getPubkeys | `;
+      const tag5 = `${TAG7} | getPubkeys | `;
       try {
         if (this.paths.length === 0)
           throw new Error("No paths found!");
@@ -4875,7 +5031,7 @@ class SDK {
       }
     };
     this.getBalancesForNetworks = async function(networkIds) {
-      const tag5 = `${TAG8} | getBalancesForNetworks | `;
+      const tag5 = `${TAG7} | getBalancesForNetworks | `;
       try {
         if (!this.pioneer) {
           console.error(tag5, "ERROR: Pioneer client not initialized! this.pioneer is:", this.pioneer);
@@ -4893,7 +5049,7 @@ class SDK {
               return network.startsWith("eip155:");
             return network === adjustedNetworkId;
           }));
-          const caipNative = await import_pioneer_caip7.networkIdToCaip(networkId);
+          const caipNative = await import_pioneer_caip6.networkIdToCaip(networkId);
           for (const pubkey of pubkeys) {
             assetQuery.push({ caip: caipNative, pubkey: pubkey.pubkey });
           }
@@ -4902,14 +5058,6 @@ class SDK {
         try {
           let marketInfo = await this.pioneer.GetPortfolioBalances(assetQuery);
           console.timeEnd("GetPortfolioBalances Response Time");
-          if (!marketInfo || !marketInfo.data) {
-            console.error(tag5, "Invalid response structure:", marketInfo);
-            throw new Error("GetPortfolioBalances returned invalid response: missing data field");
-          }
-          if (!Array.isArray(marketInfo.data)) {
-            console.error(tag5, "GetPortfolioBalances returned non-array data:", typeof marketInfo.data, marketInfo.data);
-            throw new Error(`GetPortfolioBalances returned invalid data type: expected array, got ${typeof marketInfo.data}`);
-          }
           let balances = marketInfo.data;
           const bitcoinBalances = balances.filter((b2) => b2.caip === "bip122:000000000019d6689c085ae165831e93/slip44:0");
           if (bitcoinBalances.length > 0) {
@@ -4919,7 +5067,7 @@ class SDK {
             if (!assetInfo)
               continue;
             Object.assign(balance, assetInfo, {
-              networkId: import_pioneer_caip7.caipToNetworkId(balance.caip),
+              networkId: import_pioneer_caip6.caipToNetworkId(balance.caip),
               icon: assetInfo.icon || "https://pioneers.dev/coins/etherum.png",
               identifier: `${balance.caip}:${balance.pubkey}`
             });
@@ -4938,7 +5086,7 @@ class SDK {
       }
     };
     this.getBalances = async function() {
-      const tag5 = `${TAG8} | getBalances | `;
+      const tag5 = `${TAG7} | getBalances | `;
       try {
         return await this.getBalancesForNetworks(this.blockchains);
       } catch (e) {
@@ -4947,10 +5095,10 @@ class SDK {
       }
     };
     this.getBalance = async function(networkId) {
-      const tag5 = `${TAG8} | getBalance | `;
+      const tag5 = `${TAG7} | getBalance | `;
       try {
         const results = await this.getBalancesForNetworks([networkId]);
-        const filtered = results.filter(async (b2) => b2.networkId === await import_pioneer_caip7.networkIdToCaip(networkId));
+        const filtered = results.filter(async (b2) => b2.networkId === await import_pioneer_caip6.networkIdToCaip(networkId));
         return filtered;
       } catch (e) {
         console.error(tag5, "Error: ", e);
@@ -4958,7 +5106,7 @@ class SDK {
       }
     };
     this.getFees = async function(networkId) {
-      const tag5 = `${TAG8} | getFees | `;
+      const tag5 = `${TAG7} | getFees | `;
       try {
         if (!this.pioneer) {
           throw new Error("Pioneer client not initialized. Call init() first.");
@@ -4973,7 +5121,7 @@ class SDK {
       return estimateTransactionFee(feeRate, unit, networkType, txSize);
     };
     this.getCharts = async function() {
-      const tag5 = `${TAG8} | getCharts | `;
+      const tag5 = `${TAG7} | getCharts | `;
       try {
         console.log(tag5, "Fetching charts");
         const newBalances = await getCharts(this.blockchains, this.pioneer, this.pubkeys, this.context);
@@ -4995,7 +5143,7 @@ class SDK {
       }
     };
     this.setContext = async (context) => {
-      const tag5 = `${TAG8} | setContext | `;
+      const tag5 = `${TAG7} | setContext | `;
       try {
         if (!context)
           throw Error("context required!");
@@ -5008,7 +5156,7 @@ class SDK {
       }
     };
     this.setContextType = async (contextType) => {
-      const tag5 = `${TAG8} | setContextType | `;
+      const tag5 = `${TAG7} | setContextType | `;
       try {
         if (!contextType)
           throw Error("contextType required!");
@@ -5021,7 +5169,7 @@ class SDK {
       }
     };
     this.refresh = async () => {
-      const tag5 = `${TAG8} | refresh | `;
+      const tag5 = `${TAG7} | refresh | `;
       try {
         await this.sync();
         return this.balances;
@@ -5031,7 +5179,7 @@ class SDK {
       }
     };
     this.setAssetContext = async function(asset) {
-      const tag5 = `${TAG8} | setAssetContext | `;
+      const tag5 = `${TAG7} | setAssetContext | `;
       try {
         if (!asset) {
           this.assetContext = null;
@@ -5040,7 +5188,7 @@ class SDK {
         if (!asset.caip)
           throw Error("Invalid Asset! missing caip!");
         if (!asset.networkId)
-          asset.networkId = import_pioneer_caip7.caipToNetworkId(asset.caip);
+          asset.networkId = import_pioneer_caip6.caipToNetworkId(asset.caip);
         if (!this.pubkeys || this.pubkeys.length === 0) {
           const errorMsg = `Cannot set asset context for ${asset.caip} - no pubkeys loaded. Please initialize wallet first.`;
           console.error(tag5, errorMsg);
@@ -5148,7 +5296,7 @@ class SDK {
           console.log(tag5, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
         }
         const assetBalances = this.balances.filter((b2) => b2.caip === asset.caip);
-        const assetPubkeys = this.pubkeys.filter((p2) => p2.networks && Array.isArray(p2.networks) && p2.networks.includes(import_pioneer_caip7.caipToNetworkId(asset.caip)) || import_pioneer_caip7.caipToNetworkId(asset.caip).includes("eip155") && p2.networks && Array.isArray(p2.networks) && p2.networks.some((n2) => n2.startsWith("eip155")));
+        const assetPubkeys = this.pubkeys.filter((p2) => p2.networks && Array.isArray(p2.networks) && p2.networks.includes(import_pioneer_caip6.caipToNetworkId(asset.caip)) || import_pioneer_caip6.caipToNetworkId(asset.caip).includes("eip155") && p2.networks && Array.isArray(p2.networks) && p2.networks.some((n2) => n2.startsWith("eip155")));
         const finalAssetContext = {
           ...assetInfo,
           ...asset,
@@ -5208,16 +5356,19 @@ class SDK {
           }
         }
         if (asset.caip) {
-          this.blockchainContext = import_pioneer_caip7.caipToNetworkId(asset.caip);
+          this.blockchainContext = import_pioneer_caip6.caipToNetworkId(asset.caip);
         } else if (asset.networkId) {
           this.blockchainContext = asset.networkId;
         }
         if (assetPubkeys && assetPubkeys.length > 0) {
-          this.pubkeyContext = assetPubkeys[0];
-          if (this.keepKeySdk) {
-            this.keepKeySdk.pubkeyContext = assetPubkeys[0];
+          const networkId = import_pioneer_caip6.caipToNetworkId(asset.caip || asset.networkId);
+          const currentContextValid = this.pubkeyContext?.networks?.includes(networkId);
+          if (!this.pubkeyContext || !currentContextValid) {
+            this.pubkeyContext = assetPubkeys[0];
+            console.log(tag5, "Auto-set pubkey context for network:", this.pubkeyContext.address || this.pubkeyContext.pubkey);
+          } else {
+            console.log(tag5, "Preserving existing pubkey context for network:", this.pubkeyContext.address || this.pubkeyContext.pubkey, `(addressNList: [${(this.pubkeyContext.addressNList || this.pubkeyContext.addressNListMaster).join(", ")}])`);
           }
-          console.log(tag5, "Auto-set pubkey context for network:", this.pubkeyContext.address || this.pubkeyContext.pubkey);
         }
         this.events.emit("SET_ASSET_CONTEXT", this.assetContext);
         return this.assetContext;
@@ -5227,7 +5378,7 @@ class SDK {
       }
     };
     this.setPubkeyContext = async function(pubkey) {
-      let tag5 = `${TAG8} | setPubkeyContext | `;
+      let tag5 = `${TAG7} | setPubkeyContext | `;
       try {
         if (!pubkey)
           throw Error("pubkey is required");
@@ -5238,10 +5389,7 @@ class SDK {
           console.warn(tag5, "Pubkey not found in current pubkeys array");
         }
         this.pubkeyContext = pubkey;
-        if (this.keepKeySdk) {
-          this.keepKeySdk.pubkeyContext = pubkey;
-        }
-        console.log(tag5, "Pubkey context set to:", pubkey.address || pubkey.pubkey, "note:", pubkey.note);
+        console.log(tag5, "Pubkey context set to:", pubkey.address || pubkey.pubkey, "note:", pubkey.note, "addressNList:", pubkey.addressNList || pubkey.addressNListMaster);
         return true;
       } catch (e) {
         console.error(tag5, "e: ", e);
@@ -5249,7 +5397,7 @@ class SDK {
       }
     };
     this.setOutboundAssetContext = async function(asset) {
-      const tag5 = `${TAG8} | setOutputAssetContext | `;
+      const tag5 = `${TAG7} | setOutputAssetContext | `;
       try {
         console.log(tag5, "0. asset: ", asset);
         if (!asset) {
@@ -5260,7 +5408,7 @@ class SDK {
         if (!asset.caip)
           throw Error("Invalid Asset! missing caip!");
         if (!asset.networkId)
-          asset.networkId = import_pioneer_caip7.caipToNetworkId(asset.caip);
+          asset.networkId = import_pioneer_caip6.caipToNetworkId(asset.caip);
         console.log(tag5, "networkId: ", asset.networkId);
         console.log(tag5, "this.pubkeys: ", this.pubkeys);
         const pubkey = this.pubkeys.find((p2) => {
@@ -5341,7 +5489,7 @@ class SDK {
         console.log(tag5, "CHECKPOINT 3");
         console.log(tag5, "outboundAssetContext: assetInfo: ", assetInfo);
         if (asset.caip) {
-          this.outboundBlockchainContext = import_pioneer_caip7.caipToNetworkId(asset.caip);
+          this.outboundBlockchainContext = import_pioneer_caip6.caipToNetworkId(asset.caip);
         } else if (asset.networkId) {
           this.outboundBlockchainContext = asset.networkId;
         }