@pioneer-platform/pioneer-sdk 8.11.10 → 8.11.14

package/dist/index.cjs

@@ -390,471 +390,10 @@ class Pioneer {
 
 // src/index.ts
 var import_pioneer_coins4 = require("@pioneer-platform/pioneer-coins");
-var import_pioneer_discovery2 = require("@pioneer-platform/pioneer-discovery");
+var import_pioneer_discovery = require("@pioneer-platform/pioneer-discovery");
 var import_pioneer_events = require("@pioneer-platform/pioneer-events");
 var import_events = __toESM(require("events"));
 
-// src/charts/utils.ts
-var import_pioneer_discovery = require("@pioneer-platform/pioneer-discovery");
-function hydrateAssetData(caip) {
-  return import_pioneer_discovery.assetData[caip] || import_pioneer_discovery.assetData[caip.toLowerCase()];
-}
-function checkDuplicateBalance(balances, caip, pubkey, validator) {
-  return balances.some((b) => b.caip === caip && b.pubkey === pubkey && (!validator || b.validator === validator));
-}
-function createBalanceIdentifier(caip, pubkey) {
-  return `${caip}:${pubkey}`;
-}
-
-// src/charts/custom-tokens.ts
-var tag = "| charts-custom-tokens |";
-async function fetchCustomTokens(params, balances) {
-  const { pioneer, pubkeys, blockchains, context } = params;
-  console.log(tag, "Fetching custom tokens...");
-  const evmPubkey = pubkeys.find((e) => e.networks && Array.isArray(e.networks) && e.networks.includes("eip155:*"));
-  const primaryAddress = evmPubkey?.address || evmPubkey?.master;
-  if (!primaryAddress) {
-    console.log(tag, "No EVM address found, skipping custom tokens");
-    return;
-  }
-  console.log(tag, "Using EVM address for custom tokens:", primaryAddress);
-  const supportedNetworks = blockchains.filter((net) => net.startsWith("eip155:"));
-  if (supportedNetworks.length === 0) {
-    console.log(tag, "No EVM networks for custom tokens");
-    return;
-  }
-  console.log(tag, `Checking custom tokens on ${supportedNetworks.length} networks`);
-  for (const networkId of supportedNetworks) {
-    try {
-      const response = await pioneer.GetCustomTokens({ networkId, userAddress: primaryAddress });
-      const customTokens = response?.data?.tokens || [];
-      console.log(tag, `Found ${customTokens.length} custom tokens on ${networkId}`);
-      for (const token of customTokens) {
-        const chartBalance = processCustomToken(token, primaryAddress, context, blockchains);
-        if (chartBalance && !checkDuplicateBalance(balances, chartBalance.caip, chartBalance.pubkey)) {
-          balances.push(chartBalance);
-          console.log(tag, `Added custom token: ${chartBalance.symbol} = ${chartBalance.balance}`);
-        }
-      }
-    } catch (error) {
-      console.error(tag, `Error fetching custom tokens for ${networkId}:`, error.message);
-    }
-  }
-  console.log(tag, `Custom tokens complete. Total balances: ${balances.length}`);
-}
-function processCustomToken(token, primaryAddress, context, blockchains) {
-  if (!token.assetCaip || !token.networkId) {
-    return null;
-  }
-  let extractedNetworkId = token.networkId;
-  if (token.assetCaip.includes("/denom:")) {
-    const parts = token.assetCaip.split("/denom:");
-    if (parts.length > 0) {
-      extractedNetworkId = parts[0];
-    }
-  } else if (token.networkId && token.networkId.includes("/")) {
-    extractedNetworkId = token.networkId.split("/")[0];
-  }
-  const isEip155 = extractedNetworkId.startsWith("eip155:");
-  if (!isEip155 && !blockchains.includes(extractedNetworkId)) {
-    return null;
-  }
-  const tokenAssetInfo = hydrateAssetData(token.assetCaip);
-  const tokenPubkey = token.pubkey || primaryAddress;
-  const chartBalance = {
-    context,
-    chart: "pioneer",
-    contextType: context.split(":")[0],
-    name: tokenAssetInfo?.name || token.token?.name || "Unknown Custom Token",
-    caip: token.assetCaip,
-    icon: tokenAssetInfo?.icon || token.token?.icon || "",
-    pubkey: tokenPubkey,
-    ticker: tokenAssetInfo?.symbol || token.token?.symbol || "UNK",
-    ref: `${context}${token.assetCaip}`,
-    identifier: createBalanceIdentifier(token.assetCaip, tokenPubkey),
-    networkId: extractedNetworkId,
-    symbol: tokenAssetInfo?.symbol || token.token?.symbol || "UNK",
-    type: tokenAssetInfo?.type || "erc20",
-    token: true,
-    decimal: tokenAssetInfo?.decimal || token.token?.decimal,
-    balance: token.token?.balance?.toString() || "0",
-    priceUsd: token.token?.price || 0,
-    valueUsd: token.token?.balanceUSD || 0,
-    updated: new Date().getTime()
-  };
-  return chartBalance;
-}
-
-// src/charts/evm.ts
-var tag2 = "| charts-evm |";
-async function getEvmCharts(params) {
-  const { blockchains, pioneer, pubkeys, context } = params;
-  const balances = [];
-  const evmPubkey = pubkeys.find((e) => e.networks && Array.isArray(e.networks) && e.networks.includes("eip155:*"));
-  const primaryAddress = evmPubkey?.address || evmPubkey?.master;
-  console.log(tag2, "Total pubkeys available:", pubkeys.length);
-  console.log(tag2, "Blockchains to process:", blockchains);
-  if (!primaryAddress) {
-    console.log(tag2, "No EVM address found, skipping portfolio lookup (Zapper only supports Ethereum)");
-    return balances;
-  }
-  console.log(tag2, "Using EVM address for portfolio:", primaryAddress);
-  await fetchStableCoins(pioneer, primaryAddress, blockchains, balances, context);
-  await fetchCustomTokens({ blockchains, pioneer, pubkeys, context }, balances);
-  try {
-    let portfolio = await pioneer.GetPortfolio({
-      networkId: "eip155:1",
-      address: primaryAddress
-    });
-    portfolio = portfolio.data?.data || portfolio.data;
-    if (!portfolio || !portfolio.balances) {
-      console.error(tag2, "No portfolio.balances found:", portfolio);
-      return balances;
-    }
-    console.log(tag2, `Portfolio returned ${portfolio.balances.length} balances`);
-    let processedCount = 0;
-    let skippedCount = 0;
-    for (const balance of portfolio.balances) {
-      const processedBalance = processPortfolioBalance(balance, primaryAddress, context, blockchains);
-      if (processedBalance) {
-        if (!checkDuplicateBalance(balances, processedBalance.caip, processedBalance.pubkey)) {
-          balances.push(processedBalance);
-          processedCount++;
-        }
-      } else {
-        skippedCount++;
-      }
-    }
-    console.log(tag2, `Processed ${processedCount} balances, skipped ${skippedCount}`);
-    if (portfolio.tokens && portfolio.tokens.length > 0) {
-      console.log(tag2, "Processing portfolio.tokens:", portfolio.tokens.length);
-      for (const token of portfolio.tokens) {
-        const processedToken = processPortfolioToken(token, primaryAddress, context, blockchains);
-        if (processedToken && !checkDuplicateBalance(balances, processedToken.caip, processedToken.pubkey)) {
-          balances.push(processedToken);
-        }
-      }
-    }
-  } catch (e) {
-    console.error(tag2, "Error fetching portfolio:", e);
-  }
-  return balances;
-}
-function processPortfolioBalance(balance, primaryAddress, context, blockchains) {
-  if (!balance.caip) {
-    console.error(tag2, "No caip found for:", balance);
-    return null;
-  }
-  const networkId = balance.caip.split("/")[0];
-  const isEip155 = networkId.startsWith("eip155:");
-  if (!isEip155 && !blockchains.includes(networkId)) {
-    return null;
-  }
-  const assetInfo = hydrateAssetData(balance.caip);
-  const balancePubkey = balance.pubkey || primaryAddress;
-  const balanceType = assetInfo?.type || balance.type || "native";
-  const isToken = balanceType !== "native" && balance.caip.includes("/erc20:");
-  let calculatedPrice = balance.priceUsd || balance.price || 0;
-  if ((!calculatedPrice || calculatedPrice === 0) && balance.valueUsd && balance.balance) {
-    const balanceNum = parseFloat(balance.balance.toString());
-    const valueNum = parseFloat(balance.valueUsd.toString());
-    if (balanceNum > 0 && valueNum > 0) {
-      calculatedPrice = valueNum / balanceNum;
-      console.log(tag2, `Calculated price from value/balance: ${calculatedPrice} for ${balance.caip}`);
-    }
-  }
-  const chartBalance = {
-    context,
-    chart: "pioneer",
-    contextType: "keepkey",
-    name: assetInfo?.name || balance.name || "Unknown",
-    caip: balance.caip,
-    icon: assetInfo?.icon || balance.icon || "",
-    pubkey: balancePubkey,
-    ticker: assetInfo?.symbol || balance.symbol || "UNK",
-    ref: `${context}${balance.caip}`,
-    identifier: createBalanceIdentifier(balance.caip, balancePubkey),
-    networkId,
-    chain: networkId,
-    symbol: assetInfo?.symbol || balance.symbol || "UNK",
-    type: balanceType,
-    token: isToken,
-    decimal: assetInfo?.decimal || balance.decimal,
-    balance: balance.balance.toString(),
-    price: calculatedPrice,
-    priceUsd: calculatedPrice,
-    valueUsd: balance.valueUsd.toString(),
-    updated: new Date().getTime()
-  };
-  if (balance.display) {
-    chartBalance.icon = ["multi", chartBalance.icon, balance.display.toString()].toString();
-  }
-  return chartBalance;
-}
-function processPortfolioToken(token, primaryAddress, context, blockchains) {
-  if (!token.assetCaip || !token.networkId) {
-    return null;
-  }
-  let extractedNetworkId = token.networkId;
-  if (token.assetCaip.includes("/denom:")) {
-    const parts = token.assetCaip.split("/denom:");
-    if (parts.length > 0) {
-      extractedNetworkId = parts[0];
-    }
-  } else if (token.networkId && token.networkId.includes("/")) {
-    extractedNetworkId = token.networkId.split("/")[0];
-  }
-  const isEip155 = extractedNetworkId.startsWith("eip155:");
-  if (!isEip155 && !blockchains.includes(extractedNetworkId)) {
-    return null;
-  }
-  const tokenAssetInfo = hydrateAssetData(token.assetCaip);
-  const tokenPubkey = token.pubkey || primaryAddress;
-  const chartBalance = {
-    context,
-    chart: "pioneer",
-    contextType: context.split(":")[0],
-    name: tokenAssetInfo?.name || token.token?.coingeckoId || token.token?.name || "Unknown",
-    caip: token.assetCaip,
-    icon: tokenAssetInfo?.icon || token.token?.icon || "",
-    pubkey: tokenPubkey,
-    ticker: tokenAssetInfo?.symbol || token.token?.symbol || "UNK",
-    ref: `${context}${token.assetCaip}`,
-    identifier: createBalanceIdentifier(token.assetCaip, tokenPubkey),
-    networkId: extractedNetworkId,
-    symbol: tokenAssetInfo?.symbol || token.token?.symbol || "UNK",
-    type: tokenAssetInfo?.type || "token",
-    token: true,
-    decimal: tokenAssetInfo?.decimal || token.token?.decimal,
-    balance: token.token?.balance?.toString() || "0",
-    priceUsd: token.token?.price || 0,
-    valueUsd: token.token?.balanceUSD || 0,
-    updated: new Date().getTime()
-  };
-  return chartBalance;
-}
-async function fetchStableCoins(pioneer, primaryAddress, blockchains, balances, context) {
-  console.log(tag2, "Fetching stable coins for redundancy...");
-  const supportedNetworks = ["eip155:1", "eip155:137", "eip155:8453", "eip155:56"];
-  const networksToCheck = blockchains.filter((net) => supportedNetworks.includes(net));
-  if (networksToCheck.length === 0) {
-    console.log(tag2, "No supported networks for stable coins");
-    return;
-  }
-  console.log(tag2, `Checking stable coins on ${networksToCheck.length} networks`);
-  for (const networkId of networksToCheck) {
-    try {
-      const response = await pioneer.GetStableCoins({ networkId, address: primaryAddress });
-      const stableCoins = response?.data?.tokens || [];
-      console.log(tag2, `Found ${stableCoins.length} stable coins on ${networkId}`);
-      for (const token of stableCoins) {
-        const chartBalance = processPortfolioToken(token, primaryAddress, context, blockchains);
-        if (chartBalance && !checkDuplicateBalance(balances, chartBalance.caip, chartBalance.pubkey)) {
-          balances.push(chartBalance);
-          console.log(tag2, `Added stable coin: ${chartBalance.symbol} = ${chartBalance.balance}`);
-        }
-      }
-    } catch (error) {
-      console.error(tag2, `Error fetching stable coins for ${networkId}:`, error.message);
-    }
-  }
-  console.log(tag2, `Stable coin redundancy complete. Total balances: ${balances.length}`);
-}
-
-// src/charts/maya.ts
-var tag3 = "| charts-maya |";
-async function getMayaCharts(params, existingBalances) {
-  const { blockchains, pioneer, pubkeys, context } = params;
-  const balances = [];
-  try {
-    const mayaPubkey = pubkeys.find((p) => p.networks && Array.isArray(p.networks) && p.networks.includes("cosmos:mayachain-mainnet-v1"));
-    if (!mayaPubkey || !mayaPubkey.address) {
-      console.log(tag3, "No MAYA pubkey found, skipping MAYA token fetch");
-      return balances;
-    }
-    if (!blockchains.includes("cosmos:mayachain-mainnet-v1")) {
-      console.log(tag3, "MAYA network not in blockchains list, skipping MAYA token fetch");
-      return balances;
-    }
-    const hasMayaToken = existingBalances.some((b) => b.caip === "cosmos:mayachain-mainnet-v1/denom:maya");
-    if (hasMayaToken) {
-      console.log(tag3, "MAYA token already exists in balances, skipping");
-      return balances;
-    }
-    console.log(tag3, "MAYA token not found in portfolio, fetching separately...");
-    console.log(tag3, "MAYA pubkey address:", mayaPubkey.address);
-    const mayaBalanceResponse = await pioneer.GetPortfolioBalances([
-      {
-        caip: "cosmos:mayachain-mainnet-v1/denom:maya",
-        pubkey: mayaPubkey.address
-      }
-    ]);
-    console.log(tag3, "MAYA balance response:", JSON.stringify(mayaBalanceResponse?.data, null, 2));
-    if (!mayaBalanceResponse?.data || mayaBalanceResponse.data.length === 0) {
-      console.log(tag3, "No MAYA token balance returned from GetPortfolioBalances API");
-      return balances;
-    }
-    console.log(tag3, "Found MAYA token balances:", mayaBalanceResponse.data.length);
-    for (const mayaBalance of mayaBalanceResponse.data) {
-      if (mayaBalance.caip !== "cosmos:mayachain-mainnet-v1/denom:maya") {
-        console.log(tag3, "Unexpected balance in MAYA response:", mayaBalance);
-        continue;
-      }
-      const mayaAssetInfo = hydrateAssetData(mayaBalance.caip);
-      const isToken = mayaBalance.caip.includes("/denom:") && !mayaBalance.caip.endsWith("/denom:cacao");
-      const mayaTokenBalance = {
-        context,
-        chart: "pioneer",
-        contextType: context.split(":")[0],
-        name: mayaAssetInfo?.name || "Maya Token",
-        caip: mayaBalance.caip,
-        icon: mayaAssetInfo?.icon || "https://pioneers.dev/coins/maya.png",
-        pubkey: mayaPubkey.address,
-        ticker: mayaAssetInfo?.symbol || "MAYA",
-        ref: `${context}${mayaBalance.caip}`,
-        identifier: createBalanceIdentifier(mayaBalance.caip, mayaPubkey.address),
-        networkId: "cosmos:mayachain-mainnet-v1",
-        symbol: mayaAssetInfo?.symbol || "MAYA",
-        type: mayaAssetInfo?.type || "token",
-        token: isToken,
-        decimal: mayaAssetInfo?.decimal,
-        balance: mayaBalance.balance?.toString() || "0",
-        priceUsd: parseFloat(mayaBalance.priceUsd) || 0,
-        valueUsd: parseFloat(mayaBalance.valueUsd) || 0,
-        updated: new Date().getTime()
-      };
-      console.log(tag3, "Adding MAYA token to balances:", mayaTokenBalance);
-      balances.push(mayaTokenBalance);
-    }
-  } catch (mayaError) {
-    console.error(tag3, "Error fetching MAYA token balance:", mayaError);
-  }
-  return balances;
-}
-
-// src/charts/cosmos-staking.ts
-var tag4 = "| charts-cosmos-staking |";
-async function getCosmosStakingCharts(params) {
-  const { blockchains, pioneer, pubkeys, context } = params;
-  const balances = [];
-  try {
-    console.log(tag4, "Adding Cosmos staking positions to charts...");
-    const cosmosPubkeys = pubkeys.filter((p) => p.networks && Array.isArray(p.networks) && p.networks.some((n) => n.includes("cosmos:cosmoshub") || n.includes("cosmos:osmosis")));
-    if (cosmosPubkeys.length === 0) {
-      console.log(tag4, "No cosmos pubkeys found for staking positions");
-      return balances;
-    }
-    console.log(tag4, "Found cosmos pubkeys for staking:", cosmosPubkeys.length);
-    for (const cosmosPubkey of cosmosPubkeys) {
-      if (!cosmosPubkey.address) {
-        continue;
-      }
-      const cosmosNetworks = cosmosPubkey.networks.filter((n) => n.includes("cosmos:cosmoshub") || n.includes("cosmos:osmosis"));
-      for (const networkId of cosmosNetworks) {
-        if (!blockchains.includes(networkId)) {
-          continue;
-        }
-        await fetchStakingPositionsForNetwork(networkId, cosmosPubkey.address, context, pioneer, balances);
-      }
-    }
-  } catch (e) {
-    console.error(tag4, "Error adding cosmos staking positions:", e);
-  }
-  return balances;
-}
-async function fetchStakingPositionsForNetwork(networkId, address, context, pioneer, balances) {
-  try {
-    console.log(tag4, `Fetching staking positions for ${address} on ${networkId}...`);
-    let network;
-    if (networkId === "cosmos:cosmoshub-4") {
-      network = "cosmos";
-    } else if (networkId === "cosmos:osmosis-1") {
-      network = "osmosis";
-    } else {
-      console.error(tag4, `Unsupported networkId for staking: ${networkId}`);
-      return;
-    }
-    const stakingResponse = await pioneer.GetStakingPositions({
-      network,
-      address
-    });
-    if (!stakingResponse?.data || !Array.isArray(stakingResponse.data)) {
-      console.log(tag4, `No staking positions found for ${address} on ${networkId}`);
-      return;
-    }
-    console.log(tag4, `Found ${stakingResponse.data.length} staking positions for ${networkId}`);
-    for (const position of stakingResponse.data) {
-      const processedPosition = processStakingPosition(position, address, context, networkId);
-      if (processedPosition && !checkDuplicateBalance(balances, processedPosition.caip, processedPosition.pubkey, processedPosition.validator)) {
-        balances.push(processedPosition);
-        console.log(tag4, `Added ${position.type} position:`, {
-          balance: processedPosition.balance,
-          ticker: processedPosition.ticker,
-          valueUsd: processedPosition.valueUsd,
-          validator: processedPosition.validator
-        });
-      }
-    }
-  } catch (stakingError) {
-    console.error(tag4, `Error fetching staking positions for ${address} on ${networkId}:`, stakingError);
-  }
-}
-function processStakingPosition(position, address, context, networkId) {
-  if (!position.balance || position.balance <= 0 || !position.caip) {
-    return null;
-  }
-  const stakingAssetInfo = hydrateAssetData(position.caip);
-  const stakingBalance = {
-    context,
-    chart: "staking",
-    contextType: context.split(":")[0],
-    name: stakingAssetInfo?.name || position.name || `${position.type} Position`,
-    caip: position.caip,
-    icon: stakingAssetInfo?.icon || position.icon || "",
-    pubkey: address,
-    ticker: stakingAssetInfo?.symbol || position.ticker || position.symbol || "UNK",
-    ref: `${context}${position.caip}`,
-    identifier: createBalanceIdentifier(position.caip, address),
-    networkId,
-    symbol: stakingAssetInfo?.symbol || position.symbol || position.ticker || "UNK",
-    type: stakingAssetInfo?.type || position.type || "staking",
-    token: false,
-    decimal: stakingAssetInfo?.decimal,
-    balance: position.balance.toString(),
-    priceUsd: position.priceUsd || 0,
-    valueUsd: position.valueUsd || position.balance * (position.priceUsd || 0),
-    status: position.status || "active",
-    validator: position.validatorAddress || position.validator || "",
-    updated: new Date().getTime()
-  };
-  return stakingBalance;
-}
-
-// src/charts/index.ts
-var tag5 = "| getCharts |";
-var getCharts = async (blockchains, pioneer, pubkeys, context) => {
-  try {
-    const balances = [];
-    console.log(tag5, "init");
-    const params = {
-      blockchains,
-      pioneer,
-      pubkeys,
-      context
-    };
-    const evmBalances = await getEvmCharts(params);
-    balances.push(...evmBalances);
-    const mayaBalances = await getMayaCharts(params, balances);
-    balances.push(...mayaBalances);
-    const stakingBalances = await getCosmosStakingCharts(params);
-    balances.push(...stakingBalances);
-    return balances;
-  } catch (error) {
-    console.error(tag5, "Error processing charts:", error);
-    throw error;
-  }
-};
-
 // src/getPubkey.ts
 var import_pioneer_caip = require("@pioneer-platform/pioneer-caip");
 var import_pioneer_coins = require("@pioneer-platform/pioneer-coins");
@@ -1419,7 +958,7 @@ async function fetchTokenPriceInUsd(pioneer, caip) {
   }
 }
 async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pubkeyContext, isMax, feeLevel = 5) {
-  const tag6 = TAG2 + " | createUnsignedEvmTx | ";
+  const tag = TAG2 + " | createUnsignedEvmTx | ";
   try {
     if (!pioneer)
       throw new Error("Failed to initialize Pioneer");
@@ -1440,11 +979,11 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
       throw new Error(`Pubkey context is for wrong network. Expected ${networkId}, got ${pubkeyContext.networks}`);
     }
     const address = pubkeyContext.address || pubkeyContext.pubkey;
-    console.log(tag6, "✅ Using FROM address from pubkeyContext:", address, "note:", pubkeyContext.note);
+    console.log(tag, "✅ 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 });
-    console.log(tag6, "Gas price data from API:", JSON.stringify(gasPriceData.data));
+    console.log(tag, "Gas price data from API:", JSON.stringify(gasPriceData.data));
     let gasPrice;
     const defaultGasPrices = {
       1: 30,
@@ -1460,75 +999,75 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
       let selectedGasPrice;
       if (feeLevel <= 2) {
         selectedGasPrice = gasPriceData.data.slow || gasPriceData.data.average || gasPriceData.data.fastest;
-        console.log(tag6, "Selecting SLOW gas price from API");
+        console.log(tag, "Selecting SLOW gas price from API");
       } else if (feeLevel >= 8) {
         selectedGasPrice = gasPriceData.data.fastest || gasPriceData.data.fast || gasPriceData.data.average;
-        console.log(tag6, "Selecting FAST gas price from API");
+        console.log(tag, "Selecting FAST gas price from API");
       } else {
         selectedGasPrice = gasPriceData.data.average || gasPriceData.data.fast || gasPriceData.data.fastest;
-        console.log(tag6, "Selecting AVERAGE gas price from API");
+        console.log(tag, "Selecting AVERAGE gas price from API");
       }
       let gasPriceNum;
       if (selectedGasPrice === undefined || selectedGasPrice === null) {
-        console.warn(tag6, "No valid gas price found in API response, using fallback:", fallbackGasGwei, "gwei");
+        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;
         if (isNaN(gasPriceNum) || !isFinite(gasPriceNum)) {
-          console.warn(tag6, "Invalid gas price (NaN or Infinite):", selectedGasPrice, "- using fallback:", fallbackGasGwei, "gwei");
+          console.warn(tag, "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(tag6, "Gas price from API too low:", gasPrice.toString(), "wei - using minimum:", MIN_GAS_PRICE_WEI.toString());
+        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 {
       let gasPriceNum;
       if (gasPriceData.data === undefined || gasPriceData.data === null) {
-        console.warn(tag6, "Gas price API returned null/undefined, using fallback:", fallbackGasGwei, "gwei");
+        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;
         if (isNaN(gasPriceNum) || !isFinite(gasPriceNum)) {
-          console.warn(tag6, "Invalid gas price (NaN or Infinite):", gasPriceData.data, "- using fallback:", fallbackGasGwei, "gwei");
+          console.warn(tag, "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(tag6, "Using SLOW gas price (80% of base)");
+        console.log(tag, "Using SLOW gas price (80% of base)");
       } else if (feeLevel >= 8) {
         gasPrice = baseGasPrice * BigInt(150) / BigInt(100);
-        console.log(tag6, "Using FAST gas price (150% of base)");
+        console.log(tag, "Using FAST gas price (150% of base)");
       } else {
         gasPrice = baseGasPrice;
-        console.log(tag6, "Using AVERAGE gas price (100% of base)");
+        console.log(tag, "Using AVERAGE gas price (100% of base)");
       }
       if (gasPrice < MIN_GAS_PRICE_WEI) {
-        console.warn(tag6, "Gas price too low:", gasPrice.toString(), "wei - using minimum:", MIN_GAS_PRICE_WEI.toString());
+        console.warn(tag, "Gas price too low:", gasPrice.toString(), "wei - using minimum:", MIN_GAS_PRICE_WEI.toString());
         gasPrice = MIN_GAS_PRICE_WEI;
       }
     }
-    console.log(tag6, "Final gasPrice:", gasPrice.toString(), "wei (", Number(gasPrice) / 1e9, "gwei)");
+    console.log(tag, "Final gasPrice:", gasPrice.toString(), "wei (", Number(gasPrice) / 1e9, "gwei)");
     let nonce;
     try {
       const nonceData = await pioneer.GetNonceByNetwork({ networkId, address });
       nonce = nonceData.data.nonce;
       if (nonce === undefined || nonce === null) {
-        console.log(tag6, "No nonce found for address (likely fresh address), defaulting to 0");
+        console.log(tag, "No nonce found for address (likely fresh address), defaulting to 0");
         nonce = 0;
       }
     } catch (nonceError) {
-      console.log(tag6, "Failed to fetch nonce (likely fresh address):", nonceError.message, "- defaulting to 0");
+      console.log(tag, "Failed to fetch nonce (likely fresh address):", nonceError.message, "- defaulting to 0");
       nonce = 0;
     }
     const balanceData = await pioneer.GetBalanceAddressByNetwork({ networkId, address });
     const balanceEth = parseFloat(balanceData.data.nativeBalance || balanceData.data.balance || "0");
     const balance = BigInt(Math.round(balanceEth * 1000000000000000000));
-    console.log(tag6, "Native ETH balance from API:", balanceData.data.nativeBalance || balanceData.data.balance, "ETH (", balance.toString(), "wei)");
+    console.log(tag, "Native ETH balance from API:", balanceData.data.nativeBalance || balanceData.data.balance, "ETH (", balance.toString(), "wei)");
     if (balance <= 0n)
       throw new Error("Wallet balance is zero");
     const assetType = classifyCaipEvm(caip);
@@ -1541,7 +1080,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
         let gasLimit;
         if (isThorchainOperation) {
           gasLimit = BigInt(120000);
-          console.log(tag6, "Using higher gas limit for THORChain swap:", gasLimit.toString());
+          console.log(tag, "Using higher gas limit for THORChain swap:", gasLimit.toString());
         } else {
           gasLimit = chainId === 1 ? BigInt(21000) : BigInt(25000);
         }
@@ -1557,7 +1096,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
           }
           const buffer = BigInt(100);
           amountWei = balance - gasFee - buffer;
-          console.log(tag6, "isMax calculation - balance:", balance.toString(), "gasFee:", gasFee.toString(), "buffer:", buffer.toString(), "amountWei:", amountWei.toString());
+          console.log(tag, "isMax calculation - balance:", balance.toString(), "gasFee:", gasFee.toString(), "buffer:", buffer.toString(), "amountWei:", amountWei.toString());
         } else {
           amountWei = BigInt(Math.round(amount * 1000000000000000000));
           if (amountWei + gasFee > balance) {
@@ -1567,14 +1106,14 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
         const isThorchainSwap = memo && (memo.startsWith("=") || memo.startsWith("SWAP") || memo.includes(":"));
         let txData = "0x";
         if (isThorchainSwap) {
-          console.log(tag6, "Detected THORChain swap, encoding deposit data for memo:", memo);
+          console.log(tag, "Detected THORChain swap, encoding deposit data for memo:", memo);
           let fixedMemo = memo;
           if (memo.startsWith("=:b:") || memo.startsWith("=:btc:")) {
             fixedMemo = memo.replace(/^=:(b|btc):/, "=:BTC.BTC:");
-            console.log(tag6, "Fixed Bitcoin swap memo from:", memo, "to:", fixedMemo);
+            console.log(tag, "Fixed Bitcoin swap memo from:", memo, "to:", fixedMemo);
           } else if (memo.startsWith("=:e:") || memo.startsWith("=:eth:")) {
             fixedMemo = memo.replace(/^=:(e|eth):/, "=:ETH.ETH:");
-            console.log(tag6, "Fixed Ethereum swap memo from:", memo, "to:", fixedMemo);
+            console.log(tag, "Fixed Ethereum swap memo from:", memo, "to:", fixedMemo);
           }
           if (fixedMemo.length > 250) {
             throw new Error(`Memo too long for THORChain: ${fixedMemo.length} bytes (max 250)`);
@@ -1590,14 +1129,14 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
                 if (ethInbound) {
                   vaultAddress = ethInbound.address;
                   routerAddress = ethInbound.router || to;
-                  console.log(tag6, "Using THORChain inbound addresses - vault:", vaultAddress, "router:", routerAddress);
+                  console.log(tag, "Using THORChain inbound addresses - vault:", vaultAddress, "router:", routerAddress);
                   to = routerAddress;
                 } else {
                   throw new Error("ETH inbound is halted or not found - cannot proceed with swap");
                 }
               }
             } catch (fetchError) {
-              console.error(tag6, "Failed to fetch inbound addresses:", fetchError);
+              console.error(tag, "Failed to fetch inbound addresses:", fetchError);
               throw new Error(`Cannot proceed with THORChain swap - failed to fetch inbound addresses: ${fetchError.message}`);
             }
             if (vaultAddress === "0x0000000000000000000000000000000000000000") {
@@ -1617,7 +1156,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
             const paddingLength = (32 - memoBytes.length % 32) % 32;
             const memoPadded = memoHex + "0".repeat(paddingLength * 2);
             txData = "0x" + functionSelector + vaultPadded + assetPadded + amountPadded + stringOffset + expiryPadded + stringLength + memoPadded;
-            console.log(tag6, "Encoded THORChain depositWithExpiry data:", {
+            console.log(tag, "Encoded THORChain depositWithExpiry data:", {
               functionSelector: "0x" + functionSelector,
               vault: vaultAddress,
               asset: assetAddress,
@@ -1627,9 +1166,9 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
               stringOffset: "0x" + stringOffset,
               fullData: txData
             });
-            console.log(tag6, "Native ETH swap - value will be set to:", amountWei.toString(), "wei");
+            console.log(tag, "Native ETH swap - value will be set to:", amountWei.toString(), "wei");
           } catch (error) {
-            console.error(tag6, "Error encoding THORChain deposit:", error);
+            console.error(tag, "Error encoding THORChain deposit:", error);
             throw new Error(`Failed to encode THORChain swap: ${error.message}`);
           }
         } else if (memo) {
@@ -1648,19 +1187,19 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
       }
       case "erc20": {
         const contractAddress = extractContractAddressFromCaip(caip);
-        console.log(tag6, "Fetching token decimals from contract:", contractAddress, "on network:", networkId);
+        console.log(tag, "Fetching token decimals from contract:", contractAddress, "on network:", networkId);
         let tokenDecimals;
         try {
-          console.log(tag6, "Fetching token decimals via pioneer-server API for", contractAddress, "on", networkId);
+          console.log(tag, "Fetching token decimals via pioneer-server API for", contractAddress, "on", networkId);
           const decimalsResponse = await pioneer.GetTokenDecimals({
             networkId,
             contractAddress
           });
           tokenDecimals = Number(decimalsResponse.data.decimals);
-          console.log(tag6, "✅ Fetched decimals from pioneer-server:", tokenDecimals);
+          console.log(tag, "✅ Fetched decimals from pioneer-server:", tokenDecimals);
         } catch (error) {
-          console.error(tag6, "Failed to fetch token decimals from pioneer-server:", error);
-          console.warn(tag6, "⚠️ FALLBACK: Using default 18 decimals - THIS MAY BE INCORRECT!");
+          console.error(tag, "Failed to fetch token decimals from pioneer-server:", error);
+          console.warn(tag, "⚠️ FALLBACK: Using default 18 decimals - THIS MAY BE INCORRECT!");
           tokenDecimals = 18;
         }
         const tokenMultiplier = 10n ** BigInt(tokenDecimals);
@@ -1681,7 +1220,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
           amountWei = tokenBalance;
         } else {
           amountWei = BigInt(Math.round(amount * Number(tokenMultiplier)));
-          console.log(tag6, "Token amount calculation:", {
+          console.log(tag, "Token amount calculation:", {
             inputAmount: amount,
             decimals: tokenDecimals,
             multiplier: tokenMultiplier,
@@ -1717,23 +1256,23 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
     }
     if (pubkeyContext.addressNListMaster) {
       unsignedTx.addressNList = pubkeyContext.addressNListMaster;
-      console.log(tag6, "✅ Using addressNListMaster from pubkey context:", unsignedTx.addressNList, "for address:", address);
+      console.log(tag, "✅ Using addressNListMaster from pubkey context:", unsignedTx.addressNList, "for address:", address);
     } else if (pubkeyContext.pathMaster) {
       unsignedTx.addressNList = import_pioneer_coins2.bip32ToAddressNList(pubkeyContext.pathMaster);
-      console.log(tag6, "✅ Converted pathMaster to addressNList:", pubkeyContext.pathMaster, "→", unsignedTx.addressNList);
+      console.log(tag, "✅ Converted pathMaster to addressNList:", pubkeyContext.pathMaster, "→", unsignedTx.addressNList);
     } else if (pubkeyContext.addressNList) {
       unsignedTx.addressNList = pubkeyContext.addressNList;
-      console.log(tag6, "✅ Using addressNList from pubkey context:", unsignedTx.addressNList);
+      console.log(tag, "✅ Using addressNList from pubkey context:", unsignedTx.addressNList);
     } else if (pubkeyContext.path) {
       unsignedTx.addressNList = import_pioneer_coins2.bip32ToAddressNList(pubkeyContext.path);
-      console.log(tag6, "⚠️ Using regular path (not master):", pubkeyContext.path, "→", unsignedTx.addressNList);
+      console.log(tag, "⚠️ Using regular path (not master):", pubkeyContext.path, "→", unsignedTx.addressNList);
     } else {
       unsignedTx.addressNList = [2147483648 + 44, 2147483648 + 60, 2147483648, 0, 0];
-      console.warn(tag6, "⚠️ No path info in pubkey context, using default account 0");
+      console.warn(tag, "⚠️ No path info in pubkey context, using default account 0");
     }
     return unsignedTx;
   } catch (error) {
-    console.error(tag6, "Error:", error.message);
+    console.error(tag, "Error:", error.message);
     throw error;
   }
 }
@@ -1742,7 +1281,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
 var import_pioneer_caip3 = require("@pioneer-platform/pioneer-caip");
 var TAG3 = " | createUnsignedUxtoTx | ";
 async function createUnsignedRippleTx(caip, to, amount, memo, pubkeys, pioneer, pubkeyContext, isMax) {
-  let tag6 = TAG3 + " | createUnsignedRippleTx | ";
+  let tag = TAG3 + " | createUnsignedRippleTx | ";
   try {
     if (!pioneer)
       throw new Error("Failed to init! pioneer");
@@ -1753,7 +1292,7 @@ async function createUnsignedRippleTx(caip, to, amount, memo, pubkeys, pioneer,
     if (!pubkeyContext.networks?.includes(networkId)) {
       throw new Error(`Pubkey context is for wrong network. Expected ${networkId}, got ${pubkeyContext.networks}`);
     }
-    console.log(tag6, `✅ Using pubkeyContext for network ${networkId}:`, {
+    console.log(tag, `✅ Using pubkeyContext for network ${networkId}:`, {
       address: pubkeyContext.address
     });
     const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
@@ -1821,7 +1360,7 @@ async function createUnsignedRippleTx(caip, to, amount, memo, pubkeys, pioneer,
     };
     return unsignedTx;
   } catch (error) {
-    console.error(tag6, "Error:", error);
+    console.error(tag, "Error:", error);
     throw error;
   }
 }
@@ -1961,7 +1500,7 @@ var thorchainDepositTemplate = (params) => ({
 // src/txbuilder/createUnsignedTendermintTx.ts
 var TAG4 = " | createUnsignedTendermintTx | ";
 async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pioneer, pubkeyContext, isMax, to) {
-  const tag6 = TAG4 + " | createUnsignedTendermintTx | ";
+  const tag = TAG4 + " | createUnsignedTendermintTx | ";
   try {
     if (!pioneer)
       throw new Error("Failed to init! pioneer");
@@ -1972,7 +1511,7 @@ async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pio
     if (!pubkeyContext.networks?.includes(networkId)) {
       throw new Error(`Pubkey context is for wrong network. Expected ${networkId}, got ${pubkeyContext.networks}`);
     }
-    console.log(tag6, `✅ Using pubkeyContext for network ${networkId}:`, {
+    console.log(tag, `✅ Using pubkeyContext for network ${networkId}:`, {
       address: pubkeyContext.address,
       addressNList: pubkeyContext.addressNList || pubkeyContext.addressNListMaster
     });
@@ -1995,11 +1534,11 @@ async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pio
     }
     const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
     let asset = caip.split(":")[1];
-    console.log(tag6, `\uD83D\uDD0D Fetching account info for address: ${fromAddress}`);
+    console.log(tag, `\uD83D\uDD0D Fetching account info for address: ${fromAddress}`);
     const accountInfo = (await pioneer.GetAccountInfo({ network: chain, address: fromAddress })).data;
-    console.log(tag6, "\uD83D\uDCCB accountInfo:", JSON.stringify(accountInfo, null, 2));
+    console.log(tag, "\uD83D\uDCCB accountInfo:", JSON.stringify(accountInfo, null, 2));
     let balanceInfo = await pioneer.GetPubkeyBalance({ asset: chain, pubkey: fromAddress });
-    console.log(tag6, `\uD83D\uDCB0 balanceInfo:`, balanceInfo);
+    console.log(tag, `\uD83D\uDCB0 balanceInfo:`, balanceInfo);
     let account_number, sequence;
     if (accountInfo.account) {
       account_number = accountInfo.account.account_number || "0";
@@ -2010,13 +1549,13 @@ async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pio
     } else {
       throw new Error(`Unexpected account info format for ${networkId}: ${JSON.stringify(accountInfo)}`);
     }
-    console.log(tag6, `\uD83D\uDCCA Extracted account_number: ${account_number}, sequence: ${sequence}`);
+    console.log(tag, `\uD83D\uDCCA Extracted account_number: ${account_number}, sequence: ${sequence}`);
     if (account_number === "0" || account_number === 0) {
-      console.log(tag6, `⚠️  WARNING: Account number is 0 from Pioneer API`);
-      console.log(tag6, `   This is likely due to stale Pioneer API cache`);
-      console.log(tag6, `   The mayachain-network module queries nodes directly but Pioneer API may be cached`);
-      console.log(tag6, `   Proceeding with account_number: 0 but transaction will likely fail`);
-      console.log(tag6, `   TODO: Fix Pioneer API to use fresh data from mayachain-network module`);
+      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,
@@ -2171,7 +1710,7 @@ async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pio
       }
     }
   } catch (error) {
-    console.error(tag6, "Error:", error);
+    console.error(tag, "Error:", error);
     throw error;
   }
 }
@@ -2200,7 +1739,7 @@ function getCoinTypeFromNetworkId(networkId) {
   return coinType;
 }
 async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pubkeyContext, isMax, feeLevel = 5, changeScriptType) {
-  let tag6 = " | createUnsignedUxtoTx | ";
+  let tag = " | createUnsignedUxtoTx | ";
   try {
     if (!pioneer)
       throw Error("Failed to init! pioneer");
@@ -2211,7 +1750,7 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
     if (!pubkeyContext.networks?.includes(networkId)) {
       throw new Error(`Pubkey context is for wrong network. Expected ${networkId}, got ${pubkeyContext.networks}`);
     }
-    console.log(tag6, `✅ Using pubkeyContext for network ${networkId}:`, {
+    console.log(tag, `✅ Using pubkeyContext for network ${networkId}:`, {
       address: pubkeyContext.address,
       scriptType: pubkeyContext.scriptType
     });
@@ -2222,15 +1761,15 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
     const isSegwit = segwitNetworks.includes(networkId);
     let chain = import_pioneer_caip5.NetworkIdToChain[networkId];
     const coinType = getCoinTypeFromNetworkId(networkId);
-    console.log(`${tag6}: Using SLIP-44 coin type ${coinType} for ${chain}`);
+    console.log(`${tag}: Using SLIP-44 coin type ${coinType} for ${chain}`);
     const utxos = [];
     for (const pubkey of relevantPubkeys) {
       try {
         let utxosResp = await pioneer.ListUnspent({ network: chain, xpub: pubkey.pubkey });
         utxosResp = utxosResp.data;
-        console.log(`${tag6}: ListUnspent response for ${pubkey.scriptType}:`, utxosResp?.length || 0, "UTXOs");
+        console.log(`${tag}: ListUnspent response for ${pubkey.scriptType}:`, utxosResp?.length || 0, "UTXOs");
         if (!utxosResp || !Array.isArray(utxosResp)) {
-          console.warn(`${tag6}: Invalid or empty UTXO response for ${pubkey.pubkey}`);
+          console.warn(`${tag}: Invalid or empty UTXO response for ${pubkey.pubkey}`);
           continue;
         }
         let scriptType = pubkey.scriptType;
@@ -2239,10 +1778,10 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
         }
         utxos.push(...utxosResp);
       } catch (error) {
-        console.error(`${tag6}: Failed to fetch UTXOs for ${pubkey.pubkey}:`, error);
+        console.error(`${tag}: Failed to fetch UTXOs for ${pubkey.pubkey}:`, error);
       }
     }
-    console.log(`${tag6}: Total UTXOs collected:`, utxos.length);
+    console.log(`${tag}: Total UTXOs collected:`, utxos.length);
     if (!utxos || utxos.length === 0)
       throw Error("No UTXOs found across all addresses");
     for (const utxo of utxos) {
@@ -2255,14 +1794,14 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
     }, {});
     const mostCommonInputType = Object.entries(scriptTypeCount).sort(([, a], [, b]) => b - a)[0]?.[0] || "p2pkh";
     const actualChangeScriptType = changeScriptType || mostCommonInputType || relevantPubkeys[0]?.scriptType || "p2pkh";
-    console.log(`${tag6}: Input script types:`, scriptTypeCount);
-    console.log(`${tag6}: Using change script type: ${actualChangeScriptType} (matches inputs: ${mostCommonInputType})`);
+    console.log(`${tag}: Input script types:`, scriptTypeCount);
+    console.log(`${tag}: 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(`${tag6}: Change xpub selected for ${actualChangeScriptType}:`, changeXpub?.substring(0, 10) + "...");
+    console.log(`${tag}: Change xpub selected for ${actualChangeScriptType}:`, changeXpub?.substring(0, 10) + "...");
     let changeAddressIndex = await pioneer.GetChangeAddress({
       network: chain,
       xpub: changeXpub
@@ -2282,7 +1821,7 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
         break;
     }
     const path = bipPath;
-    console.log(`${tag6}: Change address path: ${path} (coin type: ${coinType}, index: ${changeAddressIndex})`);
+    console.log(`${tag}: Change address path: ${path} (coin type: ${coinType}, index: ${changeAddressIndex})`);
     const changeAddress = {
       path,
       isChange: true,
@@ -2292,7 +1831,7 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
     };
     let feeRateFromNode;
     if (networkId === "bip122:00000000001a91e3dace36e2be3bf030") {
-      console.log(`${tag6}: Using hardcoded fees for DOGE (10 sat/byte)`);
+      console.log(`${tag}: Using hardcoded fees for DOGE (10 sat/byte)`);
       feeRateFromNode = {
         slow: 10,
         average: 10,
@@ -2305,19 +1844,19 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
       try {
         let feeResponse;
         if (pioneer.GetFeeRateByNetwork) {
-          console.log(`${tag6}: Trying GetFeeRateByNetwork for ${networkId}`);
+          console.log(`${tag}: Trying GetFeeRateByNetwork for ${networkId}`);
           feeResponse = await pioneer.GetFeeRateByNetwork({ networkId });
         } else {
-          console.log(`${tag6}: Using GetFeeRate for ${networkId}`);
+          console.log(`${tag}: Using GetFeeRate for ${networkId}`);
           feeResponse = await pioneer.GetFeeRate({ networkId });
         }
         feeRateFromNode = feeResponse.data;
-        console.log(`${tag6}: Got fee rates from API:`, JSON.stringify(feeRateFromNode, null, 2));
+        console.log(`${tag}: Got fee rates from API:`, JSON.stringify(feeRateFromNode, null, 2));
         const conversionThreshold = 500;
         const needsConversion = feeRateFromNode.slow && feeRateFromNode.slow > conversionThreshold || feeRateFromNode.average && feeRateFromNode.average > conversionThreshold || feeRateFromNode.fast && feeRateFromNode.fast > conversionThreshold || feeRateFromNode.fastest && feeRateFromNode.fastest > conversionThreshold;
         if (needsConversion) {
-          console.warn(`${tag6}: Detected wrong units - values appear to be in sat/kB instead of sat/byte`);
-          console.warn(`${tag6}: Original values:`, {
+          console.warn(`${tag}: Detected wrong units - values appear to be in sat/kB instead of sat/byte`);
+          console.warn(`${tag}: Original values:`, {
             slow: feeRateFromNode.slow,
             average: feeRateFromNode.average,
             fast: feeRateFromNode.fast,
@@ -2331,12 +1870,12 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
             feeRateFromNode.fast = feeRateFromNode.fast / 1000;
           if (feeRateFromNode.fastest)
             feeRateFromNode.fastest = feeRateFromNode.fastest / 1000;
-          console.warn(`${tag6}: Converted to sat/byte:`, feeRateFromNode);
+          console.warn(`${tag}: Converted to sat/byte:`, feeRateFromNode);
         }
         if (!feeRateFromNode || typeof feeRateFromNode !== "object") {
           throw new Error(`Invalid fee rate response from API: ${JSON.stringify(feeRateFromNode)}`);
         }
-        console.log(`${tag6}: Available fee rates:`, {
+        console.log(`${tag}: Available fee rates:`, {
           slow: feeRateFromNode.slow,
           average: feeRateFromNode.average,
           fast: feeRateFromNode.fast,
@@ -2346,33 +1885,33 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
           throw new Error(`No valid fee rates in API response: ${JSON.stringify(feeRateFromNode)}`);
         }
       } catch (error) {
-        console.error(`${tag6}: Failed to get fee rates from Pioneer API:`, error.message || error);
+        console.error(`${tag}: Failed to get fee rates from Pioneer API:`, error.message || error);
         throw new Error(`Unable to get fee rate for network ${networkId}: ${error.message || "API unavailable"}`);
       }
     }
     let effectiveFeeRate;
-    console.log(`${tag6}: Using fee level ${feeLevel}`);
+    console.log(`${tag}: Using fee level ${feeLevel}`);
     switch (feeLevel) {
       case 1:
       case 2:
         effectiveFeeRate = feeRateFromNode.slow || feeRateFromNode.average;
-        console.log(`${tag6}: Using SLOW fee rate: ${effectiveFeeRate} sat/vB`);
+        console.log(`${tag}: Using SLOW fee rate: ${effectiveFeeRate} sat/vB`);
         break;
       case 3:
       case 4:
         effectiveFeeRate = feeRateFromNode.average || feeRateFromNode.fast;
-        console.log(`${tag6}: Using AVERAGE fee rate: ${effectiveFeeRate} sat/vB`);
+        console.log(`${tag}: Using AVERAGE fee rate: ${effectiveFeeRate} sat/vB`);
         break;
       case 5:
         effectiveFeeRate = feeRateFromNode.fastest || feeRateFromNode.fast;
-        console.log(`${tag6}: Using FASTEST fee rate: ${effectiveFeeRate} sat/vB`);
+        console.log(`${tag}: Using FASTEST fee rate: ${effectiveFeeRate} sat/vB`);
         break;
       default:
         throw new Error(`Invalid fee level: ${feeLevel}. Must be 1-5`);
     }
     if (!effectiveFeeRate)
       throw new Error("Unable to get fee rate for network");
-    console.log(`${tag6}: Using fee rate from API:`, {
+    console.log(`${tag}: Using fee rate from API:`, {
       feeLevel,
       selectedRate: effectiveFeeRate,
       description: feeLevel <= 2 ? "slow" : feeLevel <= 4 ? "average" : "fast"
@@ -2382,22 +1921,22 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
     effectiveFeeRate = Math.ceil(effectiveFeeRate);
     const MIN_RELAY_FEE_RATE = 3;
     if (effectiveFeeRate < MIN_RELAY_FEE_RATE) {
-      console.log(`${tag6}: Fee rate ${effectiveFeeRate} is below minimum relay fee, increasing to ${MIN_RELAY_FEE_RATE} sat/vB`);
+      console.log(`${tag}: Fee rate ${effectiveFeeRate} is below minimum relay fee, increasing to ${MIN_RELAY_FEE_RATE} sat/vB`);
       effectiveFeeRate = MIN_RELAY_FEE_RATE;
     }
-    console.log(`${tag6}: Final fee rate to use (rounded, with minimums): ${effectiveFeeRate} sat/vB`);
+    console.log(`${tag}: Final fee rate to use (rounded, with minimums): ${effectiveFeeRate} sat/vB`);
     amount = parseInt(String(amount * 1e8));
     if (amount <= 0 && !isMax)
       throw Error("Invalid amount! 0");
     const totalBalance = utxos.reduce((sum, utxo) => sum + utxo.value, 0);
-    console.log(`${tag6}: Coin selection inputs:`, {
+    console.log(`${tag}: Coin selection inputs:`, {
       utxoCount: utxos.length,
       totalBalance: totalBalance / 1e8,
       requestedAmount: amount / 1e8,
       isMax,
       feeRate: effectiveFeeRate
     });
-    console.log(`${tag6}: UTXO details for coin selection:`, utxos.map((u) => ({
+    console.log(`${tag}: UTXO details for coin selection:`, utxos.map((u) => ({
       value: u.value,
       txid: u.txid?.substring(0, 10) + "...",
       vout: u.vout,
@@ -2411,8 +1950,8 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
     } else {
       result = import_coinselect.default(utxos, [{ address: to, value: amount }], effectiveFeeRate);
     }
-    console.log(tag6, "coinSelect result object:", result);
-    console.log(tag6, "coinSelect result.inputs:", result?.inputs);
+    console.log(tag, "coinSelect result object:", result);
+    console.log(tag, "coinSelect result.inputs:", result?.inputs);
     if (!result || !result.inputs) {
       const errorDetails = {
         utxoCount: utxos.length,
@@ -2421,7 +1960,7 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
         feeRate: effectiveFeeRate,
         insufficientFunds: totalBalance < amount
       };
-      console.error(`${tag6}: Coin selection failed:`, errorDetails);
+      console.error(`${tag}: Coin selection failed:`, errorDetails);
       if (utxos.length === 0) {
         throw Error("No UTXOs available for coin selection");
       } else if (totalBalance < amount) {
@@ -2437,7 +1976,7 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
       throw Error("Failed to create transaction: Missing outputs");
     if (fee === undefined)
       throw Error("Failed to calculate transaction fee");
-    console.log(`${tag6}: Transaction built with:`, {
+    console.log(`${tag}: Transaction built with:`, {
       feeLevel,
       effectiveFeeRate: `${effectiveFeeRate} sat/vB`,
       calculatedFee: `${fee} satoshis`,
@@ -2445,8 +1984,8 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
       outputCount: outputs.length
     });
     const uniqueInputSet = new Set;
-    console.log(tag6, "inputs:", inputs);
-    console.log(tag6, "inputs:", inputs[0]);
+    console.log(tag, "inputs:", inputs);
+    console.log(tag, "inputs:", inputs[0]);
     const preparedInputs = inputs.map(transformInput).filter(({ hash, index }) => uniqueInputSet.has(`${hash}:${index}`) ? false : uniqueInputSet.add(`${hash}:${index}`)).map(({ value, index, hash, txHex, path: path2, scriptType }) => ({
       addressNList: import_pioneer_coins3.bip32ToAddressNList(path2),
       scriptType,
@@ -2575,7 +2114,7 @@ class TransactionManager {
     throw new Error(`Unsupported CAIP: ${caipString}`);
   }
   async transfer({ caip, to, amount, memo, isMax = false, feeLevel = 5, changeScriptType }) {
-    let tag6 = TAG5 + " | transfer | ";
+    let tag = TAG5 + " | transfer | ";
     try {
       if (!this.pioneer)
         throw Error("Failed to init! pioneer");
@@ -2613,12 +2152,12 @@ class TransactionManager {
       }
       return unsignedTx;
     } catch (e) {
-      console.error(tag6, e);
+      console.error(tag, e);
       throw e;
     }
   }
   async sign({ caip, unsignedTx }) {
-    let tag6 = TAG5 + " | sign | ";
+    let tag = TAG5 + " | sign | ";
     try {
       if (!this.pioneer)
         throw Error("Failed to init! pioneer");
@@ -2704,20 +2243,20 @@ class TransactionManager {
             }
             case "cosmos:mayachain-mainnet-v1/slip44:931":
             case "cosmos:mayachain-mainnet-v1/denom:maya": {
-              console.log(tag6, "\uD83D\uDD0D ===== MAYACHAIN SIGNING AUDIT =====");
-              console.log(tag6, "\uD83D\uDCCB unsignedTx:", JSON.stringify(unsignedTx, null, 2));
-              console.log(tag6, "\uD83D\uDD11 unsignedTx.addressNList:", unsignedTx.addressNList);
-              console.log(tag6, "\uD83D\uDCCD unsignedTx.signerAddress:", unsignedTx.signerAddress);
-              console.log(tag6, "\uD83C\uDF10 pubkeyContext:", this.pubkeyContext);
-              console.log(tag6, "\uD83D\uDD10 pubkeyContext.addressNList:", this.pubkeyContext?.addressNList);
-              console.log(tag6, "\uD83D\uDD10 pubkeyContext.addressNListMaster:", this.pubkeyContext?.addressNListMaster);
-              console.log(tag6, "\uD83D\uDCEC pubkeyContext.address:", this.pubkeyContext?.address);
-              console.log(tag6, "=======================================");
+              console.log(tag, "\uD83D\uDD0D ===== MAYACHAIN SIGNING AUDIT =====");
+              console.log(tag, "\uD83D\uDCCB unsignedTx:", JSON.stringify(unsignedTx, null, 2));
+              console.log(tag, "\uD83D\uDD11 unsignedTx.addressNList:", unsignedTx.addressNList);
+              console.log(tag, "\uD83D\uDCCD unsignedTx.signerAddress:", unsignedTx.signerAddress);
+              console.log(tag, "\uD83C\uDF10 pubkeyContext:", this.pubkeyContext);
+              console.log(tag, "\uD83D\uDD10 pubkeyContext.addressNList:", this.pubkeyContext?.addressNList);
+              console.log(tag, "\uD83D\uDD10 pubkeyContext.addressNListMaster:", this.pubkeyContext?.addressNListMaster);
+              console.log(tag, "\uD83D\uDCEC pubkeyContext.address:", this.pubkeyContext?.address);
+              console.log(tag, "=======================================");
               if (unsignedTx.signDoc.msgs[0].type === "mayachain/MsgSend") {
                 const responseSign = await this.keepKeySdk.mayachain.mayachainSignAminoTransfer(unsignedTx);
                 signedTx = responseSign.serialized;
-                console.log(tag6, "✅ Signing completed");
-                console.log(tag6, "\uD83D\uDCE6 responseSign:", responseSign);
+                console.log(tag, "✅ Signing completed");
+                console.log(tag, "\uD83D\uDCE6 responseSign:", responseSign);
               } else if (unsignedTx.signDoc.msgs[0].type === "mayachain/MsgDeposit") {
                 const responseSign = await this.keepKeySdk.mayachain.mayachainSignAminoDeposit(unsignedTx);
                 signedTx = responseSign.serialized;
@@ -2739,11 +2278,11 @@ class TransactionManager {
             if (serialized.length > 140) {
               signedTx = serialized;
             } else {
-              console.error(tag6, "EIP155 signing returned incomplete transaction - only signature components");
+              console.error(tag, "EIP155 signing returned incomplete transaction - only signature components");
               throw new Error("KeepKey returned incomplete transaction - cannot reconstruct without r,s,v components");
             }
           } else {
-            console.error(tag6, "EIP155 signing failed - no valid signature in response:", responseSign);
+            console.error(tag, "EIP155 signing failed - no valid signature in response:", responseSign);
             throw new Error("Failed to sign transaction - no valid signature in response");
           }
           break;
@@ -2764,19 +2303,19 @@ class TransactionManager {
         }
       }
       if (!signedTx) {
-        console.error(tag6, "CRITICAL ERROR: signedTx is missing after signing process");
-        console.error(tag6, "CAIP:", caip);
-        console.error(tag6, "Type:", type);
+        console.error(tag, "CRITICAL ERROR: signedTx is missing after signing process");
+        console.error(tag, "CAIP:", caip);
+        console.error(tag, "Type:", type);
         throw Error("Failed to sign! missing signedTx");
       }
       return signedTx;
     } catch (e) {
-      console.error(tag6, e);
+      console.error(tag, e);
       throw e;
     }
   }
   async broadcast({ networkId, serialized }) {
-    let tag6 = TAG5 + " | broadcast | ";
+    let tag = TAG5 + " | broadcast | ";
     try {
       if (!this.pioneer)
         throw Error("Failed to init! pioneer");
@@ -2790,7 +2329,7 @@ class TransactionManager {
         return result.txid;
       }
     } catch (e) {
-      console.error(tag6, e);
+      console.error(tag, e);
       throw e;
     }
   }
@@ -2910,7 +2449,7 @@ var cosmosClaimAllRewardsTemplate = (params) => ({
 // src/txbuilder/createUnsignedStakingTx.ts
 var TAG6 = " | createUnsignedStakingTx | ";
 async function createUnsignedStakingTx(caip, params, pubkeys, pioneer, pubkeyContext) {
-  const tag6 = TAG6 + " | createUnsignedStakingTx | ";
+  const tag = TAG6 + " | createUnsignedStakingTx | ";
   try {
     if (!pioneer)
       throw new Error("Failed to init! pioneer");
@@ -2921,7 +2460,7 @@ async function createUnsignedStakingTx(caip, params, pubkeys, pioneer, pubkeyCon
     if (!pubkeyContext.networks?.includes(networkId)) {
       throw new Error(`Pubkey context is for wrong network. Expected ${networkId}, got ${pubkeyContext.networks}`);
     }
-    console.log(tag6, `✅ Using pubkeyContext for network ${networkId}:`, {
+    console.log(tag, `✅ Using pubkeyContext for network ${networkId}:`, {
       address: pubkeyContext.address
     });
     let chain;
@@ -2953,10 +2492,10 @@ async function createUnsignedStakingTx(caip, params, pubkeys, pioneer, pubkeyCon
       default:
         throw new Error(`Unsupported networkId for staking: ${networkId}`);
     }
-    console.log(tag6, `Building ${params.type} transaction for ${chain}`);
+    console.log(tag, `Building ${params.type} transaction for ${chain}`);
     const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
     const accountInfo = (await pioneer.GetAccountInfo({ network: chain, address: fromAddress })).data;
-    console.log(tag6, "accountInfo: ", accountInfo);
+    console.log(tag, "accountInfo: ", accountInfo);
     let account_number;
     let sequence;
     if (networkId === "cosmos:cosmoshub-4" || networkId === "cosmos:osmosis-1") {
@@ -3038,7 +2577,7 @@ async function createUnsignedStakingTx(caip, params, pubkeys, pioneer, pubkeyCon
         throw new Error(`Unsupported staking transaction type: ${params.type}`);
     }
   } catch (error) {
-    console.error(tag6, "Error:", error);
+    console.error(tag, "Error:", error);
     throw error;
   }
 }
@@ -3084,16 +2623,16 @@ function withTimeout(promise, timeoutMs) {
   ]);
 }
 async function getFees(pioneer, networkId) {
-  const tag6 = TAG7 + " | getFees | ";
+  const tag = TAG7 + " | getFees | ";
   try {
-    console.log(tag6, `Fetching fees for network: ${networkId}`);
+    console.log(tag, `Fetching fees for network: ${networkId}`);
     const networkType = getNetworkType(networkId);
     if (networkType === "COSMOS") {
-      console.log(tag6, "Using hardcoded fees for Cosmos network:", networkId);
+      console.log(tag, "Using hardcoded fees for Cosmos network:", networkId);
       return getCosmosFees(networkId);
     }
     if (networkId === "bip122:00000000001a91e3dace36e2be3bf030") {
-      console.log(tag6, "Using hardcoded fees for Dogecoin: 10 sat/byte");
+      console.log(tag, "Using hardcoded fees for Dogecoin: 10 sat/byte");
       return {
         slow: {
           label: "Slow",
@@ -3130,7 +2669,7 @@ async function getFees(pioneer, networkId) {
         const apiCall = pioneer.GetFeeRateByNetwork ? pioneer.GetFeeRateByNetwork({ networkId }) : pioneer.GetFeeRate({ networkId });
         feeResponse = await withTimeout(apiCall, 3000);
       } catch (timeoutError) {
-        console.warn(tag6, "Dash fee API timeout, using fallback fees");
+        console.warn(tag, "Dash fee API timeout, using fallback fees");
         return {
           slow: {
             label: "Economy",
@@ -3163,10 +2702,10 @@ async function getFees(pioneer, networkId) {
       }
     } else {
       if (networkType === "EVM") {
-        console.log(tag6, "Using GetGasPriceByNetwork for EVM network:", networkId);
+        console.log(tag, "Using GetGasPriceByNetwork for EVM network:", networkId);
         feeResponse = await (pioneer.GetGasPriceByNetwork ? pioneer.GetGasPriceByNetwork({ networkId }) : Promise.reject(new Error("GetGasPriceByNetwork not available")));
       } else {
-        console.log(tag6, "Using GetFeeRateByNetwork for UTXO network:", networkId);
+        console.log(tag, "Using GetFeeRateByNetwork for UTXO network:", networkId);
         feeResponse = await (pioneer.GetFeeRateByNetwork ? pioneer.GetFeeRateByNetwork({ networkId }) : pioneer.GetFeeRate({ networkId }));
       }
     }
@@ -3174,17 +2713,17 @@ async function getFees(pioneer, networkId) {
       throw new Error(`No fee data returned for ${networkId}`);
     }
     const feeData = feeResponse.data;
-    console.log(tag6, "Raw fee data:", feeData);
+    console.log(tag, "Raw fee data:", feeData);
     const networkName = getNetworkName(networkId);
     let normalizedFees = normalizeFeeData(feeData, networkType, networkName, networkId);
     normalizedFees = ensureFeeDifferentiation(normalizedFees, networkType);
     normalizedFees.networkId = networkId;
     normalizedFees.networkType = networkType;
     normalizedFees.raw = feeData;
-    console.log(tag6, "Normalized fees:", normalizedFees);
+    console.log(tag, "Normalized fees:", normalizedFees);
     return normalizedFees;
   } catch (error) {
-    console.error(tag6, "Failed to fetch fees:", error);
+    console.error(tag, "Failed to fetch fees:", error);
     return getFallbackFees(networkId);
   }
 }
@@ -3493,7 +3032,7 @@ function estimateTransactionFee(feeRate, unit, networkType, txSize) {
 
 // src/utils/kkapi-detection.ts
 async function detectKkApiAvailability(forceLocalhost) {
-  const tag6 = " | detectKkApiAvailability | ";
+  const tag = " | detectKkApiAvailability | ";
   try {
     const isTauri = typeof window !== "undefined" && "__TAURI__" in window;
     const isBrowser = typeof window !== "undefined";
@@ -3652,11 +3191,11 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
 // src/utils/sync-market.ts
 var TAG8 = " | sync-market | ";
 async function syncMarket(balances, pioneer) {
-  const tag6 = `${TAG8} | syncMarket | `;
+  const tag = `${TAG8} | syncMarket | `;
   try {
     const invalidBalances = balances.filter((b) => !b || !b.caip || typeof b.caip !== "string" || !b.caip.includes(":"));
     if (invalidBalances.length > 0) {
-      console.warn(tag6, `Found ${invalidBalances.length} balances with invalid CAIPs:`, invalidBalances.map((b) => ({
+      console.warn(tag, `Found ${invalidBalances.length} balances with invalid CAIPs:`, invalidBalances.map((b) => ({
         caip: b?.caip,
         type: typeof b?.caip,
         symbol: b?.symbol,
@@ -3671,7 +3210,7 @@ async function syncMarket(balances, pioneer) {
     console.log("GetMarketInfo: payload length: ", allCaips.length);
     const invalidEntries = allCaips.filter((caip) => typeof caip !== "string");
     if (invalidEntries.length > 0) {
-      console.error(tag6, "CRITICAL: Invalid entries detected in allCaips:", invalidEntries);
+      console.error(tag, "CRITICAL: Invalid entries detected in allCaips:", invalidEntries);
       throw new Error("Invalid CAIP entries detected - aborting market sync");
     }
     if (allCaips && allCaips.length > 0) {
@@ -3692,13 +3231,13 @@ async function syncMarket(balances, pioneer) {
           }
         }
       } catch (apiError) {
-        console.error(tag6, "API error fetching market info:", apiError);
-        console.warn(tag6, "Continuing without market prices");
+        console.error(tag, "API error fetching market info:", apiError);
+        console.warn(tag, "Continuing without market prices");
       }
     }
     return true;
   } catch (e) {
-    console.error(tag6, "e:", e);
+    console.error(tag, "e:", e);
     throw e;
   }
 }
@@ -3813,7 +3352,7 @@ class SDK {
     this.appIcon = config.appIcon || "https://pioneers.dev/coins/keepkey.png";
     this.spec = spec || config.spec || "https://api.keepkey.info/spec/swagger";
     this.wss = config.wss || "wss://pioneers.dev";
-    this.assets = import_pioneer_discovery2.assetData;
+    this.assets = import_pioneer_discovery.assetData;
     this.assetsMap = new Map;
     this.username = config.username;
     this.queryKey = config.queryKey;
@@ -3891,7 +3430,7 @@ class SDK {
       return true;
     };
     this.setPubkeys = (newPubkeys) => {
-      const tag6 = `${TAG9} | setPubkeys | `;
+      const tag = `${TAG9} | setPubkeys | `;
       this.pubkeys = [];
       this.pubkeySet.clear();
       let added = 0;
@@ -3908,7 +3447,7 @@ class SDK {
       this.pubkeySet.clear();
     }
     this.getUnifiedPortfolio = async function() {
-      const tag6 = `${TAG9} | getUnifiedPortfolio | `;
+      const tag = `${TAG9} | getUnifiedPortfolio | `;
       try {
         const startTime = performance.now();
         try {
@@ -3919,17 +3458,17 @@ class SDK {
             signal: AbortSignal.timeout(2000)
           });
           if (!portfolioResponse.ok) {
-            console.warn(tag6, "Portfolio endpoint returned", portfolioResponse.status);
+            console.warn(tag, "Portfolio endpoint returned", portfolioResponse.status);
             return null;
           }
           const portfolioData = await portfolioResponse.json();
           const loadTime = performance.now() - startTime;
           if (!portfolioData.success) {
-            console.warn(tag6, "Portfolio API returned success=false");
+            console.warn(tag, "Portfolio API returned success=false");
             return null;
           }
           if (portfolioData.totalValueUsd === 0 || !portfolioData.totalValueUsd) {
-            console.warn(tag6, "Portfolio value is $0.00 - may need device connection or sync");
+            console.warn(tag, "Portfolio value is $0.00 - may need device connection or sync");
             return null;
           }
           let allBalances = [];
@@ -4016,14 +3555,14 @@ class SDK {
           };
         } catch (fetchError) {
           if (fetchError.name === "AbortError") {
-            console.log(tag6, "Unified portfolio request timed out (this is normal if vault not running)");
+            console.log(tag, "Unified portfolio request timed out (this is normal if vault not running)");
           } else {
-            console.log(tag6, "Failed to fetch unified portfolio:", fetchError.message);
+            console.log(tag, "Failed to fetch unified portfolio:", fetchError.message);
           }
           return null;
         }
       } catch (e) {
-        console.error(tag6, "Error:", e);
+        console.error(tag, "Error:", e);
         return null;
       }
     };
@@ -4034,7 +3573,7 @@ class SDK {
       return this.syncState.isSynced;
     };
     this.init = async function(walletsVerbose, setup) {
-      const tag6 = `${TAG9} | init | `;
+      const tag = `${TAG9} | init | `;
       try {
         if (!this.username)
           throw Error("username required!");
@@ -4090,11 +3629,11 @@ class SDK {
           this.events.emit("message", request);
         });
         clientEvents.events.on("balance:update", (data) => {
-          const tag7 = TAG9 + " | balance:update | ";
+          const tag2 = TAG9 + " | balance:update | ";
           try {
             const payload = typeof data === "string" ? JSON.parse(data) : data;
             const balance = payload.balance;
-            console.log(tag7, "Received balance update:", balance.caip);
+            console.log(tag2, "Received balance update:", balance.caip);
             const exists = this.balances.find((b) => b.caip === balance.caip && b.pubkey === balance.pubkey);
             if (!exists) {
               this.balances.push(balance);
@@ -4104,27 +3643,27 @@ class SDK {
             }
             this.events.emit("BALANCE_UPDATE", balance);
           } catch (e) {
-            console.error(tag7, "Error processing balance update:", e);
+            console.error(tag2, "Error processing balance update:", e);
           }
         });
         clientEvents.events.on("sync:progress", (data) => {
-          const tag7 = TAG9 + " | sync:progress | ";
+          const tag2 = TAG9 + " | sync:progress | ";
           try {
             const payload = typeof data === "string" ? JSON.parse(data) : data;
-            console.log(tag7, `Sync progress: ${payload.percentage}%`);
+            console.log(tag2, `Sync progress: ${payload.percentage}%`);
             this.syncState.syncProgress = payload.percentage;
             this.syncState.syncedChains = payload.completed;
             this.syncState.totalChains = payload.total;
             this.events.emit("SYNC_PROGRESS", this.syncState);
           } catch (e) {
-            console.error(tag7, "Error processing sync progress:", e);
+            console.error(tag2, "Error processing sync progress:", e);
           }
         });
         clientEvents.events.on("sync:complete", (data) => {
-          const tag7 = TAG9 + " | sync:complete | ";
+          const tag2 = TAG9 + " | sync:complete | ";
           try {
             const payload = typeof data === "string" ? JSON.parse(data) : data;
-            console.log(tag7, `Sync complete: ${payload.balances} balances in ${payload.duration}ms`);
+            console.log(tag2, `Sync complete: ${payload.balances} balances in ${payload.duration}ms`);
             this.syncState.isSynced = true;
             this.syncState.isInitialSync = false;
             this.syncState.syncProgress = 100;
@@ -4133,7 +3672,7 @@ class SDK {
             this.events.emit("SYNC_COMPLETE", this.syncState);
             this.events.emit("SYNC_STATE_CHANGED", this.syncState);
           } catch (e) {
-            console.error(tag7, "Error processing sync complete:", e);
+            console.error(tag2, "Error processing sync complete:", e);
           }
         });
         this.events.emit("SET_STATUS", "init");
@@ -4165,7 +3704,7 @@ class SDK {
         }
         return this.pioneer;
       } catch (e) {
-        console.error(tag6, "e: ", e);
+        console.error(tag, "e: ", e);
         throw e;
       }
     };
@@ -4176,7 +3715,7 @@ class SDK {
       return syncMarket(this.balances, this.pioneer);
     };
     this.sync = async function() {
-      const tag6 = `${TAG9} | sync | `;
+      const tag = `${TAG9} | sync | `;
       try {
         const matchesNetwork = (item, networkId) => {
           if (!item.networks || !Array.isArray(item.networks))
@@ -4308,7 +3847,7 @@ class SDK {
         this.events.emit("SYNC_COMPLETE", this.syncState);
         return true;
       } catch (e) {
-        console.error(tag6, "Error in sync:", e);
+        console.error(tag, "Error in sync:", e);
         throw e;
       }
     };
@@ -4322,7 +3861,7 @@ class SDK {
       }
     };
     this.buildTx = async function(sendPayload) {
-      let tag6 = TAG9 + " | buildTx | ";
+      let tag = TAG9 + " | buildTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4336,7 +3875,7 @@ class SDK {
         };
         let txManager = new TransactionManager(transactionDependencies, this.events);
         let unsignedTx = await txManager.transfer(sendPayload);
-        console.log(tag6, "unsignedTx: ", unsignedTx);
+        console.log(tag, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -4344,14 +3883,14 @@ class SDK {
       }
     };
     this.buildDelegateTx = async function(caip, params) {
-      let tag6 = TAG9 + " | buildDelegateTx | ";
+      let tag = TAG9 + " | buildDelegateTx | ";
       try {
         const delegateParams = {
           ...params,
           type: "delegate"
         };
         let unsignedTx = await createUnsignedStakingTx(caip, delegateParams, this.pubkeys, this.pioneer, this.pubkeyContext);
-        console.log(tag6, "unsignedTx: ", unsignedTx);
+        console.log(tag, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -4359,14 +3898,14 @@ class SDK {
       }
     };
     this.buildUndelegateTx = async function(caip, params) {
-      let tag6 = TAG9 + " | buildUndelegateTx | ";
+      let tag = TAG9 + " | buildUndelegateTx | ";
       try {
         const undelegateParams = {
           ...params,
           type: "undelegate"
         };
         let unsignedTx = await createUnsignedStakingTx(caip, undelegateParams, this.pubkeys, this.pioneer, this.pubkeyContext);
-        console.log(tag6, "unsignedTx: ", unsignedTx);
+        console.log(tag, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -4374,14 +3913,14 @@ class SDK {
       }
     };
     this.buildClaimRewardsTx = async function(caip, params) {
-      let tag6 = TAG9 + " | buildClaimRewardsTx | ";
+      let tag = TAG9 + " | buildClaimRewardsTx | ";
       try {
         const claimParams = {
           ...params,
           type: "claim_rewards"
         };
         let unsignedTx = await createUnsignedStakingTx(caip, claimParams, this.pubkeys, this.pioneer, this.pubkeyContext);
-        console.log(tag6, "unsignedTx: ", unsignedTx);
+        console.log(tag, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -4389,7 +3928,7 @@ class SDK {
       }
     };
     this.buildClaimAllRewardsTx = async function(caip, params) {
-      let tag6 = TAG9 + " | buildClaimAllRewardsTx | ";
+      let tag = TAG9 + " | buildClaimAllRewardsTx | ";
       try {
         const claimAllParams = {
           ...params,
@@ -4403,7 +3942,7 @@ class SDK {
       }
     };
     this.signTx = async function(caip, unsignedTx) {
-      let tag6 = TAG9 + " | signTx | ";
+      let tag = TAG9 + " | signTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4424,7 +3963,7 @@ class SDK {
       }
     };
     this.broadcastTx = async function(caip, signedTx) {
-      let tag6 = TAG9 + " | broadcastTx | ";
+      let tag = TAG9 + " | broadcastTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4448,7 +3987,7 @@ class SDK {
       }
     };
     this.swap = async function(swapPayload) {
-      let tag6 = `${TAG9} | swap | `;
+      let tag = `${TAG9} | swap | `;
       try {
         if (!swapPayload)
           throw Error("swapPayload required!");
@@ -4497,15 +4036,15 @@ class SDK {
             throw new Error(`Cannot use max amount: no balance found for ${swapPayload.caipIn}`);
           }
           let totalBalance = 0;
-          console.log(tag6, `Found ${inputBalances.length} balance entries for ${swapPayload.caipIn}`);
+          console.log(tag, `Found ${inputBalances.length} balance entries for ${swapPayload.caipIn}`);
           for (const balanceEntry of inputBalances) {
             const balance = parseFloat(balanceEntry.balance) || 0;
             totalBalance += balance;
-            console.log(tag6, `  - ${balanceEntry.pubkey || balanceEntry.identifier}: ${balance}`);
+            console.log(tag, `  - ${balanceEntry.pubkey || balanceEntry.identifier}: ${balance}`);
           }
           this.assetContext.balance = totalBalance.toString();
           this.assetContext.valueUsd = (totalBalance * parseFloat(this.assetContext.priceUsd || "0")).toFixed(2);
-          console.log(tag6, `Updated assetContext balance to aggregated total: ${totalBalance}`);
+          console.log(tag, `Updated assetContext balance to aggregated total: ${totalBalance}`);
           const feeReserves = {
             "bip122:000000000019d6689c085ae165831e93/slip44:0": 0.00005,
             "eip155:1/slip44:60": 0.001,
@@ -4516,7 +4055,7 @@ class SDK {
           };
           const reserve = feeReserves[swapPayload.caipIn] || 0.0001;
           inputAmount = Math.max(0, totalBalance - reserve);
-          console.log(tag6, `Using max amount for swap: ${inputAmount} (total balance: ${totalBalance}, reserve: ${reserve})`);
+          console.log(tag, `Using max amount for swap: ${inputAmount} (total balance: ${totalBalance}, reserve: ${reserve})`);
         } else {
           inputAmount = typeof swapPayload.amount === "string" ? parseFloat(swapPayload.amount) : swapPayload.amount;
           if (isNaN(inputAmount) || inputAmount <= 0) {
@@ -4536,7 +4075,7 @@ class SDK {
           result = await this.pioneer.Quote(quote);
           result = result.data;
         } catch (e) {
-          console.error(tag6, "Failed to get quote: ", e);
+          console.error(tag, "Failed to get quote: ", e);
           throw Error("Quote API failed for path: " + quote.sellAsset + " -> " + quote.buyAsset + ". Error: " + e);
         }
         if (!result || result.length === 0)
@@ -4563,7 +4102,7 @@ class SDK {
           if (tx.type === "deposit") {
             unsignedTx = await createUnsignedTendermintTx(caip, tx.type, tx.txParams.amount, tx.txParams.memo, this.pubkeys, this.pioneer, this.pubkeyContext, false, undefined);
           } else if (tx.type === "EVM" || tx.type === "evm") {
-            console.log(tag6, "Using pre-built EVM transaction from integration");
+            console.log(tag, "Using pre-built EVM transaction from integration");
             unsignedTx = tx.txParams;
           } else {
             if (!tx.txParams.memo)
@@ -4582,12 +4121,12 @@ class SDK {
           return unsignedTx;
         }
       } catch (e) {
-        console.error(tag6, "Error: ", e);
+        console.error(tag, "Error: ", e);
         throw e;
       }
     };
     this.transfer = async function(sendPayload) {
-      let tag6 = `${TAG9} | transfer | `;
+      let tag = `${TAG9} | transfer | `;
       try {
         if (!sendPayload)
           throw Error("sendPayload required!");
@@ -4621,15 +4160,15 @@ class SDK {
         return { txid, events: this.events };
       } catch (error) {
         if (error instanceof Error) {
-          console.error(tag6, "An error occurred during the transfer process:", error.message);
+          console.error(tag, "An error occurred during the transfer process:", error.message);
         } else {
-          console.error(tag6, "An unknown error occurred during the transfer process");
+          console.error(tag, "An unknown error occurred during the transfer process");
         }
         throw error;
       }
     };
     this.followTransaction = async function(caip, txid) {
-      let tag6 = " | followTransaction | ";
+      let tag = " | followTransaction | ";
       try {
         const finalConfirmationBlocksByCaip = {
           dogecoin: 3,
@@ -4659,7 +4198,7 @@ class SDK {
               }
             }
           } catch (error) {
-            console.error(tag6, "Error:", error);
+            console.error(tag, "Error:", error);
           }
           if (!isConfirmed) {
             await new Promise((resolve) => setTimeout(resolve, 8000));
@@ -4677,18 +4216,18 @@ class SDK {
           requiredConfirmations
         };
       } catch (error) {
-        console.error(tag6, "Error:", error);
+        console.error(tag, "Error:", error);
         throw new Error("Failed to follow transaction");
       }
     };
     this.setBlockchains = async function(blockchains) {
-      const tag6 = `${TAG9} | setBlockchains | `;
+      const tag = `${TAG9} | setBlockchains | `;
       try {
         if (!blockchains)
           throw Error("blockchains required!");
         const uniqueBlockchains = [...new Set(blockchains)];
         if (blockchains.length !== uniqueBlockchains.length) {
-          console.warn(tag6, `Removed ${blockchains.length - uniqueBlockchains.length} duplicate blockchains`);
+          console.warn(tag, `Removed ${blockchains.length - uniqueBlockchains.length} duplicate blockchains`);
         }
         this.blockchains = uniqueBlockchains;
         this.events.emit("SET_BLOCKCHAINS", this.blockchains);
@@ -4698,12 +4237,12 @@ class SDK {
       }
     };
     this.addAsset = async function(caip, data) {
-      let tag6 = TAG9 + " | addAsset | ";
+      let tag = TAG9 + " | addAsset | ";
       try {
         let success = false;
         if (!caip)
           throw new Error("caip required!");
-        let dataLocal = import_pioneer_discovery2.assetData[caip];
+        let dataLocal = import_pioneer_discovery.assetData[caip];
         if (!dataLocal) {
           if (!data.networkId)
             throw new Error("networkId required! can not build asset");
@@ -4736,22 +4275,22 @@ class SDK {
       }
     };
     this.clearWalletState = async function() {
-      const tag6 = `${TAG9} | clearWalletState | `;
+      const tag = `${TAG9} | clearWalletState | `;
       try {
         this.context = null;
         this.paths = [];
         this.blockchains = [];
         this.pubkeys = [];
         this.pubkeySet.clear();
-        console.log(tag6, "Cleared wallet state including pubkeys and tracking set");
+        console.log(tag, "Cleared wallet state including pubkeys and tracking set");
         return true;
       } catch (e) {
-        console.error(tag6, "e: ", e);
+        console.error(tag, "e: ", e);
         throw e;
       }
     };
     this.addPath = async function(path) {
-      const tag6 = `${TAG9} | addPath | `;
+      const tag = `${TAG9} | addPath | `;
       try {
         this.paths.push(path);
         const pubkey = await getPubkey(path.networks[0], path, this.keepKeySdk, this.context);
@@ -4760,14 +4299,14 @@ class SDK {
         this.buildDashboardFromBalances();
         return { success: true, pubkey };
       } catch (e) {
-        console.error(tag6, "Failed:", e);
+        console.error(tag, "Failed:", e);
         throw e;
       }
     };
     this.addPaths = async function(paths) {
-      const tag6 = `${TAG9} | addPaths | `;
+      const tag = `${TAG9} | addPaths | `;
       try {
-        console.log(tag6, `Adding ${paths.length} paths in batch mode...`);
+        console.log(tag, `Adding ${paths.length} paths in batch mode...`);
         this.paths.push(...paths);
         const newPubkeys = [];
         for (const path of paths) {
@@ -4776,10 +4315,10 @@ class SDK {
             this.addPubkey(pubkey);
             newPubkeys.push(pubkey);
           } catch (error) {
-            console.warn(tag6, `Failed to get pubkey for path ${path.note}:`, error.message);
+            console.warn(tag, `Failed to get pubkey for path ${path.note}:`, error.message);
           }
         }
-        console.log(tag6, `Successfully added ${newPubkeys.length} pubkeys`);
+        console.log(tag, `Successfully added ${newPubkeys.length} pubkeys`);
         const networkSet = new Set;
         for (const path of paths) {
           if (path.networks && Array.isArray(path.networks)) {
@@ -4787,13 +4326,13 @@ class SDK {
           }
         }
         const uniqueNetworks = [...networkSet];
-        console.log(tag6, `Fetching balances for ${uniqueNetworks.length} unique networks in single API call...`);
+        console.log(tag, `Fetching balances for ${uniqueNetworks.length} unique networks in single API call...`);
         await this.getBalancesForNetworks(uniqueNetworks);
         this.buildDashboardFromBalances();
-        console.log(tag6, `Batch add complete: ${paths.length} paths, ${newPubkeys.length} pubkeys, ${this.balances?.length || 0} balances`);
+        console.log(tag, `Batch add complete: ${paths.length} paths, ${newPubkeys.length} pubkeys, ${this.balances?.length || 0} balances`);
         return { success: true, pubkeys: newPubkeys };
       } catch (e) {
-        console.error(tag6, "Failed:", e);
+        console.error(tag, "Failed:", e);
         throw e;
       }
     };
@@ -4801,12 +4340,12 @@ class SDK {
       return this.getGasAssets();
     };
     this.getGasAssets = async function() {
-      const tag6 = `${TAG9} | getGasAssets | `;
+      const tag = `${TAG9} | getGasAssets | `;
       try {
         for (let i = 0;i < this.blockchains.length; i++) {
           let networkId = this.blockchains[i];
           let caip = import_pioneer_caip8.networkIdToCaip(networkId);
-          let asset = await import_pioneer_discovery2.assetData[caip.toLowerCase()];
+          let asset = await import_pioneer_discovery.assetData[caip.toLowerCase()];
           if (asset) {
             asset.caip = caip.toLowerCase();
             asset.networkId = networkId;
@@ -4835,7 +4374,7 @@ class SDK {
             denom: "maya"
           };
           this.assetsMap.set(mayaTokenCaip, mayaToken);
-          console.log(tag6, "Added MAYA token to assetsMap");
+          console.log(tag, "Added MAYA token to assetsMap");
         }
         return this.assetsMap;
       } catch (e) {
@@ -4844,7 +4383,7 @@ class SDK {
       }
     };
     this.getPubkeys = async function() {
-      const tag6 = `${TAG9} | getPubkeys | `;
+      const tag = `${TAG9} | getPubkeys | `;
       try {
         if (this.paths.length === 0)
           throw new Error("No paths found!");
@@ -4856,21 +4395,57 @@ class SDK {
         const duplicatesRemoved = allPubkeys.length - this.pubkeys.length;
         if (duplicatesRemoved > 0) {
         }
+        const pubkeysWithoutNetworks = this.pubkeys.filter((pk) => !pk.networks || !Array.isArray(pk.networks) || pk.networks.length === 0);
+        if (pubkeysWithoutNetworks.length > 0) {
+          console.error(tag, "ERROR: Some pubkeys missing networks field!");
+          console.error(tag, "Affected pubkeys:", pubkeysWithoutNetworks.length);
+          pubkeysWithoutNetworks.forEach((pk) => {
+            console.error(tag, `  - ${pk.note || pk.pubkey}: networks=${pk.networks}`);
+          });
+          for (const pubkey of pubkeysWithoutNetworks) {
+            const matchingPath = this.paths.find((p) => JSON.stringify(p.addressNList) === JSON.stringify(pubkey.addressNList));
+            if (matchingPath && matchingPath.networks) {
+              console.warn(tag, `  ⚠️ Auto-fixing: Adding networks from path ${matchingPath.note}`);
+              pubkey.networks = matchingPath.networks;
+            }
+          }
+          const stillMissing = this.pubkeys.filter((pk) => !pk.networks || !Array.isArray(pk.networks) || pk.networks.length === 0);
+          if (stillMissing.length > 0) {
+            console.error(tag, `❌ CRITICAL: ${stillMissing.length} pubkeys still missing networks after auto-fix!`);
+            stillMissing.forEach((pk) => {
+              console.error(tag, `  - ${pk.note || pk.pubkey}`);
+            });
+          } else {
+            console.log(tag, `✅ Auto-fix successful: All pubkeys now have networks field`);
+          }
+        }
         this.events.emit("SET_PUBKEYS", this.pubkeys);
         return pubkeys;
       } catch (error) {
         console.error("Error in getPubkeys:", error);
-        console.error(tag6, "Error in getPubkeys:", error);
+        console.error(tag, "Error in getPubkeys:", error);
         throw error;
       }
     };
     this.getBalancesForNetworks = async function(networkIds) {
-      const tag6 = `${TAG9} | getBalancesForNetworks | `;
+      const tag = `${TAG9} | getBalancesForNetworks | `;
       try {
         if (!this.pioneer) {
-          console.error(tag6, "ERROR: Pioneer client not initialized! this.pioneer is:", this.pioneer);
+          console.error(tag, "ERROR: Pioneer client not initialized! this.pioneer is:", this.pioneer);
           throw new Error("Pioneer client not initialized. Call init() first.");
         }
+        console.log("\uD83D\uDD0D [DIAGNOSTIC] Input networks:", networkIds);
+        console.log("\uD83D\uDD0D [DIAGNOSTIC] Total pubkeys:", this.pubkeys.length);
+        const pubkeysWithNetworks = this.pubkeys.filter((p) => p.networks && Array.isArray(p.networks));
+        const pubkeysWithoutNetworks = this.pubkeys.filter((p) => !p.networks || !Array.isArray(p.networks));
+        console.log("\uD83D\uDD0D [DIAGNOSTIC] Pubkeys WITH networks:", pubkeysWithNetworks.length);
+        console.log("\uD83D\uDD0D [DIAGNOSTIC] Pubkeys WITHOUT networks:", pubkeysWithoutNetworks.length);
+        if (pubkeysWithoutNetworks.length > 0) {
+          console.warn("⚠️ [WARNING] Some pubkeys missing networks field:");
+          pubkeysWithoutNetworks.forEach((pk) => {
+            console.warn(`   - ${pk.note || pk.pubkey.slice(0, 10)}: networks=${pk.networks}`);
+          });
+        }
         const assetQuery = [];
         for (const networkId of networkIds) {
           let adjustedNetworkId = networkId;
@@ -4878,21 +4453,55 @@ class SDK {
             adjustedNetworkId = "eip155:*";
           }
           const isEip155 = adjustedNetworkId.includes("eip155");
-          const pubkeys = this.pubkeys.filter((pubkey) => pubkey.networks && Array.isArray(pubkey.networks) && pubkey.networks.some((network) => {
+          let pubkeys = this.pubkeys.filter((pubkey) => pubkey.networks && Array.isArray(pubkey.networks) && pubkey.networks.some((network) => {
             if (isEip155)
               return network.startsWith("eip155:");
             return network === adjustedNetworkId;
           }));
+          if (pubkeys.length === 0) {
+            console.warn(tag, `⚠️ No pubkeys found for ${networkId} with networks field`);
+            console.warn(tag, "Attempting fallback: finding pubkeys by path matching");
+            const pathsForNetwork = this.paths.filter((p) => p.networks?.includes(networkId) || networkId.startsWith("eip155:") && p.networks?.includes("eip155:*"));
+            for (const path of pathsForNetwork) {
+              const matchingPubkey = this.pubkeys.find((pk) => JSON.stringify(pk.addressNList) === JSON.stringify(path.addressNList));
+              if (matchingPubkey) {
+                console.warn(tag, `  ✓ Found pubkey via path matching: ${matchingPubkey.note || matchingPubkey.pubkey.slice(0, 10)}`);
+                pubkeys.push(matchingPubkey);
+              }
+            }
+            if (pubkeys.length > 0) {
+              console.warn(tag, `  ✅ Fallback successful: Found ${pubkeys.length} pubkeys for ${networkId}`);
+            } else {
+              console.error(tag, `  ❌ Fallback failed: No pubkeys found for ${networkId}`);
+            }
+          }
           const caipNative = await import_pioneer_caip8.networkIdToCaip(networkId);
           for (const pubkey of pubkeys) {
             assetQuery.push({ caip: caipNative, pubkey: pubkey.pubkey });
           }
         }
+        console.log("\uD83D\uDD0D [DIAGNOSTIC] Built assetQuery with", assetQuery.length, "entries");
+        console.log("\uD83D\uDD0D [DIAGNOSTIC] Sample queries:", assetQuery.slice(0, 5));
+        const caipCounts = new Map;
+        for (const query of assetQuery) {
+          caipCounts.set(query.caip, (caipCounts.get(query.caip) || 0) + 1);
+        }
+        console.log("\uD83D\uDD0D [DIAGNOSTIC] Queries by chain:");
+        caipCounts.forEach((count, caip) => {
+          console.log(`   - ${caip}: ${count} queries`);
+        });
+        console.log(`⏱️  [PERF] Starting GetPortfolioBalances API call...`);
+        const apiCallStart = performance.now();
         console.time("GetPortfolioBalances Response Time");
         try {
-          let marketInfo = await this.pioneer.GetPortfolioBalances(assetQuery);
+          let marketInfo = await this.pioneer.GetPortfolioBalances({ pubkeys: assetQuery });
+          const apiCallTime = performance.now() - apiCallStart;
           console.timeEnd("GetPortfolioBalances Response Time");
+          console.log(`⏱️  [PERF] API call completed in ${apiCallTime.toFixed(0)}ms`);
+          const enrichStart = performance.now();
           let balances = marketInfo.data;
+          console.log(`⏱️  [PERF] Received ${balances?.length || 0} balances from server`);
+          console.log(`⏱️  [PERF] Starting balance enrichment...`);
           for (let balance of balances) {
             const assetInfo = this.assetsMap.get(balance.caip.toLowerCase()) || this.assetsMap.get(balance.caip);
             if (!assetInfo)
@@ -4906,47 +4515,50 @@ class SDK {
               color
             });
           }
+          const enrichTime = performance.now() - enrichStart;
+          console.log(`⏱️  [PERF] Enrichment completed in ${enrichTime.toFixed(0)}ms`);
           this.balances = balances;
           this.events.emit("SET_BALANCES", this.balances);
+          console.log(`⏱️  [PERF] Total getBalancesForNetworks: ${(performance.now() - apiCallStart).toFixed(0)}ms`);
           return this.balances;
         } catch (apiError) {
-          console.error(tag6, "GetPortfolioBalances API call failed:", apiError);
+          console.error(tag, "GetPortfolioBalances API call failed:", apiError);
           throw new Error(`GetPortfolioBalances API call failed: ${apiError?.message || "Unknown error"}`);
         }
       } catch (e) {
-        console.error(tag6, "Error: ", e);
+        console.error(tag, "Error: ", e);
         throw e;
       }
     };
     this.getBalances = async function() {
-      const tag6 = `${TAG9} | getBalances | `;
+      const tag = `${TAG9} | getBalances | `;
       try {
         return await this.getBalancesForNetworks(this.blockchains);
       } catch (e) {
-        console.error(tag6, "Error in getBalances: ", e);
+        console.error(tag, "Error in getBalances: ", e);
         throw e;
       }
     };
     this.getBalance = async function(networkId) {
-      const tag6 = `${TAG9} | getBalance | `;
+      const tag = `${TAG9} | getBalance | `;
       try {
         const results = await this.getBalancesForNetworks([networkId]);
         const filtered = results.filter(async (b) => b.networkId === await import_pioneer_caip8.networkIdToCaip(networkId));
         return filtered;
       } catch (e) {
-        console.error(tag6, "Error: ", e);
+        console.error(tag, "Error: ", e);
         throw e;
       }
     };
     this.getFees = async function(networkId) {
-      const tag6 = `${TAG9} | getFees | `;
+      const tag = `${TAG9} | getFees | `;
       try {
         if (!this.pioneer) {
           throw new Error("Pioneer client not initialized. Call init() first.");
         }
         return await getFees(this.pioneer, networkId);
       } catch (e) {
-        console.error(tag6, "Error getting fees: ", e);
+        console.error(tag, "Error getting fees: ", e);
         throw e;
       }
     };
@@ -4954,29 +4566,55 @@ class SDK {
       return estimateTransactionFee(feeRate, unit, networkType, txSize);
     };
     this.getCharts = async function() {
-      const tag6 = `${TAG9} | getCharts | `;
+      const tag = `${TAG9} | getCharts | `;
       try {
-        console.log(tag6, "Fetching charts");
-        const newBalances = await getCharts(this.blockchains, this.pioneer, this.pubkeys, this.context);
-        console.log(tag6, "newBalances: ", newBalances);
+        console.log(tag, "Fetching charts from batch endpoint");
+        const pubkeysForBatch = [];
+        for (const pubkey of this.pubkeys) {
+          const address = pubkey.address || pubkey.master || pubkey.pubkey;
+          if (!address)
+            continue;
+          const supportedNetworks = pubkey.networks || [];
+          for (const blockchain of this.blockchains) {
+            const supportsNetwork = supportedNetworks.some((net) => net === blockchain || net.endsWith(":*") && blockchain.startsWith(net.replace(":*", ":")));
+            if (supportsNetwork) {
+              let caip;
+              if (blockchain.startsWith("eip155:")) {
+                caip = `${blockchain}/slip44:60`;
+              } else {
+                caip = `${blockchain}/slip44:0`;
+              }
+              pubkeysForBatch.push({
+                pubkey: address,
+                caip
+              });
+            }
+          }
+        }
+        console.log(tag, `Calling batch GetCharts with ${pubkeysForBatch.length} pubkeys`);
+        const chartsResponse = await this.pioneer.GetCharts({
+          pubkeys: pubkeysForBatch
+        });
+        const newBalances = chartsResponse?.data?.balances || [];
+        console.log(tag, `Received ${newBalances.length} balances from batch endpoint`);
         const uniqueBalances = new Map([...this.balances, ...newBalances].map((balance) => [
-          balance.identifier,
+          balance.identifier || `${balance.caip}:${balance.pubkey}`,
           {
             ...balance,
             type: balance.type || "balance"
           }
         ]));
-        console.log(tag6, "uniqueBalances: ", uniqueBalances);
+        console.log(tag, "uniqueBalances: ", uniqueBalances.size);
         this.balances = Array.from(uniqueBalances.values());
-        console.log(tag6, "Updated this.balances: ", this.balances);
+        console.log(tag, "Updated this.balances: ", this.balances.length);
         return this.balances;
       } catch (e) {
-        console.error(tag6, "Error in getCharts:", e);
+        console.error(tag, "Error in getCharts:", e);
         throw e;
       }
     };
     this.setContext = async (context) => {
-      const tag6 = `${TAG9} | setContext | `;
+      const tag = `${TAG9} | setContext | `;
       try {
         if (!context)
           throw Error("context required!");
@@ -4984,12 +4622,12 @@ class SDK {
         this.events.emit("SET_CONTEXT", context);
         return { success: true };
       } catch (e) {
-        console.error(tag6, "e: ", e);
+        console.error(tag, "e: ", e);
         return { success: false };
       }
     };
     this.setContextType = async (contextType) => {
-      const tag6 = `${TAG9} | setContextType | `;
+      const tag = `${TAG9} | setContextType | `;
       try {
         if (!contextType)
           throw Error("contextType required!");
@@ -4997,22 +4635,22 @@ class SDK {
         this.events.emit("SET_CONTEXT_TYPE", contextType);
         return { success: true };
       } catch (e) {
-        console.error(tag6, "e: ", e);
+        console.error(tag, "e: ", e);
         return { success: false };
       }
     };
     this.refresh = async () => {
-      const tag6 = `${TAG9} | refresh | `;
+      const tag = `${TAG9} | refresh | `;
       try {
         await this.sync();
         return this.balances;
       } catch (e) {
-        console.error(tag6, "e: ", e);
+        console.error(tag, "e: ", e);
         throw e;
       }
     };
     this.setAssetContext = async function(asset) {
-      const tag6 = `${TAG9} | setAssetContext | `;
+      const tag = `${TAG9} | setAssetContext | `;
       try {
         if (!asset) {
           this.assetContext = null;
@@ -5024,7 +4662,7 @@ class SDK {
           asset.networkId = import_pioneer_caip8.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(tag6, errorMsg);
+          console.error(tag, errorMsg);
           throw new Error(errorMsg);
         }
         const pubkeysForNetwork = this.pubkeys.filter((e) => {
@@ -5039,8 +4677,8 @@ class SDK {
         });
         if (pubkeysForNetwork.length === 0) {
           const errorMsg = `Cannot set asset context for ${asset.caip} - no address/xpub found for network ${asset.networkId}`;
-          console.error(tag6, errorMsg);
-          console.error(tag6, "Available networks in pubkeys:", [
+          console.error(tag, errorMsg);
+          console.error(tag, "Available networks in pubkeys:", [
             ...new Set(this.pubkeys.flatMap((p) => p.networks || []))
           ]);
           throw new Error(errorMsg);
@@ -5050,43 +4688,43 @@ class SDK {
           const xpubFound = pubkeysForNetwork.some((p) => p.type === "xpub" && p.pubkey);
           if (!xpubFound) {
             const errorMsg = `Cannot set asset context for UTXO chain ${asset.caip} - xpub required but not found`;
-            console.error(tag6, errorMsg);
+            console.error(tag, errorMsg);
             throw new Error(errorMsg);
           }
         }
         const hasValidAddress = pubkeysForNetwork.some((p) => p.address || p.master || p.pubkey);
         if (!hasValidAddress) {
           const errorMsg = `Cannot set asset context for ${asset.caip} - no valid address found in pubkeys`;
-          console.error(tag6, errorMsg);
+          console.error(tag, errorMsg);
           throw new Error(errorMsg);
         }
-        console.log(tag6, `✅ Validated: Found ${pubkeysForNetwork.length} addresses for ${asset.networkId}`);
+        console.log(tag, `✅ Validated: Found ${pubkeysForNetwork.length} addresses for ${asset.networkId}`);
         let freshPriceUsd = 0;
         try {
           if (!asset.caip || typeof asset.caip !== "string" || !asset.caip.includes(":")) {
-            console.warn(tag6, "Invalid or missing CAIP, skipping market price fetch:", asset.caip);
+            console.warn(tag, "Invalid or missing CAIP, skipping market price fetch:", asset.caip);
           } else {
-            console.log(tag6, "Fetching fresh market price for:", asset.caip);
+            console.log(tag, "Fetching fresh market price for:", asset.caip);
             const marketData = await this.pioneer.GetMarketInfo([asset.caip]);
-            console.log(tag6, "Market data response:", marketData);
+            console.log(tag, "Market data response:", marketData);
             if (marketData && marketData.data && marketData.data.length > 0) {
               freshPriceUsd = marketData.data[0];
-              console.log(tag6, "✅ Fresh market price:", freshPriceUsd);
+              console.log(tag, "✅ Fresh market price:", freshPriceUsd);
             } else {
-              console.warn(tag6, "No market data returned for:", asset.caip);
+              console.warn(tag, "No market data returned for:", asset.caip);
             }
           }
         } catch (marketError) {
-          console.error(tag6, "Error fetching market price:", marketError);
+          console.error(tag, "Error fetching market price:", marketError);
         }
         let assetInfo = this.assetsMap.get(asset.caip.toLowerCase());
-        console.log(tag6, "assetInfo: ", assetInfo);
-        let assetInfoDiscovery = import_pioneer_discovery2.assetData[asset.caip];
-        console.log(tag6, "assetInfoDiscovery: ", assetInfoDiscovery);
+        console.log(tag, "assetInfo: ", assetInfo);
+        let assetInfoDiscovery = import_pioneer_discovery.assetData[asset.caip];
+        console.log(tag, "assetInfoDiscovery: ", assetInfoDiscovery);
         if (assetInfoDiscovery)
           assetInfo = assetInfoDiscovery;
         if (!assetInfo) {
-          console.log(tag6, "Building placeholder asset!");
+          console.log(tag, "Building placeholder asset!");
           assetInfo = {
             caip: asset.caip.toLowerCase(),
             networkId: asset.networkId,
@@ -5103,30 +4741,30 @@ class SDK {
             const valueUsd = parseFloat(matchingBalances[0].valueUsd);
             if (balance > 0 && valueUsd > 0) {
               priceValue = valueUsd / balance;
-              console.log(tag6, "calculated priceUsd from valueUsd/balance:", priceValue);
+              console.log(tag, "calculated priceUsd from valueUsd/balance:", priceValue);
             }
           }
           if (priceValue && priceValue > 0) {
-            console.log(tag6, "detected priceUsd from balance:", priceValue);
+            console.log(tag, "detected priceUsd from balance:", priceValue);
             assetInfo.priceUsd = priceValue;
           }
         }
         if (freshPriceUsd && freshPriceUsd > 0) {
           assetInfo.priceUsd = freshPriceUsd;
-          console.log(tag6, "✅ Using fresh market price:", freshPriceUsd);
+          console.log(tag, "✅ Using fresh market price:", freshPriceUsd);
           let totalBalance = 0;
           let totalValueUsd = 0;
-          console.log(tag6, `Found ${matchingBalances.length} balance entries for ${asset.caip}`);
+          console.log(tag, `Found ${matchingBalances.length} balance entries for ${asset.caip}`);
           for (const balanceEntry of matchingBalances) {
             const balance = parseFloat(balanceEntry.balance) || 0;
             const valueUsd = parseFloat(balanceEntry.valueUsd) || 0;
             totalBalance += balance;
             totalValueUsd += valueUsd;
-            console.log(tag6, `  Balance entry: ${balance} (${valueUsd} USD)`);
+            console.log(tag, `  Balance entry: ${balance} (${valueUsd} USD)`);
           }
           assetInfo.balance = totalBalance.toString();
           assetInfo.valueUsd = totalValueUsd.toFixed(2);
-          console.log(tag6, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
+          console.log(tag, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
         }
         const assetBalances = this.balances.filter((b) => b.caip === asset.caip);
         const assetPubkeys = this.pubkeys.filter((p) => p.networks && Array.isArray(p.networks) && p.networks.includes(import_pioneer_caip8.caipToNetworkId(asset.caip)) || import_pioneer_caip8.caipToNetworkId(asset.caip).includes("eip155") && p.networks && Array.isArray(p.networks) && p.networks.some((n) => n.startsWith("eip155")));
@@ -5146,7 +4784,7 @@ class SDK {
             const balanceAmount = parseFloat(balance.balance || 0);
             balance.valueUsd = (balanceAmount * freshPriceUsd).toString();
           }
-          console.log(tag6, "Updated all balances with fresh price data");
+          console.log(tag, "Updated all balances with fresh price data");
         }
         this.assetContext = finalAssetContext;
         if (asset.isToken || asset.type === "token" || assetInfo.isToken || assetInfo.type === "token") {
@@ -5198,20 +4836,20 @@ class SDK {
           const currentContextValid = this.pubkeyContext?.networks?.includes(networkId);
           if (!this.pubkeyContext || !currentContextValid) {
             this.pubkeyContext = assetPubkeys[0];
-            console.log(tag6, "Auto-set pubkey context for network:", this.pubkeyContext.address || this.pubkeyContext.pubkey);
+            console.log(tag, "Auto-set pubkey context for network:", this.pubkeyContext.address || this.pubkeyContext.pubkey);
           } else {
-            console.log(tag6, "Preserving existing pubkey context for network:", this.pubkeyContext.address || this.pubkeyContext.pubkey, `(addressNList: [${(this.pubkeyContext.addressNList || this.pubkeyContext.addressNListMaster).join(", ")}])`);
+            console.log(tag, "Preserving existing pubkey context for network:", this.pubkeyContext.address || this.pubkeyContext.pubkey, `(addressNList: [${(this.pubkeyContext.addressNList || this.pubkeyContext.addressNListMaster).join(", ")}])`);
           }
         }
         this.events.emit("SET_ASSET_CONTEXT", this.assetContext);
         return this.assetContext;
       } catch (e) {
-        console.error(tag6, "e: ", e);
+        console.error(tag, "e: ", e);
         throw e;
       }
     };
     this.setPubkeyContext = async function(pubkey) {
-      let tag6 = `${TAG9} | setPubkeyContext | `;
+      let tag = `${TAG9} | setPubkeyContext | `;
       try {
         if (!pubkey)
           throw Error("pubkey is required");
@@ -5219,31 +4857,31 @@ class SDK {
           throw Error("invalid pubkey: missing pubkey or address");
         const exists = this.pubkeys.some((pk) => pk.pubkey === pubkey.pubkey || pk.address === pubkey.address || pk.pubkey === pubkey.address);
         if (!exists) {
-          console.warn(tag6, "Pubkey not found in current pubkeys array");
+          console.warn(tag, "Pubkey not found in current pubkeys array");
         }
         this.pubkeyContext = pubkey;
-        console.log(tag6, "Pubkey context set to:", pubkey.address || pubkey.pubkey, "note:", pubkey.note, "addressNList:", pubkey.addressNList || pubkey.addressNListMaster);
+        console.log(tag, "Pubkey context set to:", pubkey.address || pubkey.pubkey, "note:", pubkey.note, "addressNList:", pubkey.addressNList || pubkey.addressNListMaster);
         return true;
       } catch (e) {
-        console.error(tag6, "e: ", e);
+        console.error(tag, "e: ", e);
         throw e;
       }
     };
     this.setOutboundAssetContext = async function(asset) {
-      const tag6 = `${TAG9} | setOutputAssetContext | `;
+      const tag = `${TAG9} | setOutputAssetContext | `;
       try {
-        console.log(tag6, "0. asset: ", asset);
+        console.log(tag, "0. asset: ", asset);
         if (!asset) {
           this.outboundAssetContext = null;
           return;
         }
-        console.log(tag6, "1 asset: ", asset);
+        console.log(tag, "1 asset: ", asset);
         if (!asset.caip)
           throw Error("Invalid Asset! missing caip!");
         if (!asset.networkId)
           asset.networkId = import_pioneer_caip8.caipToNetworkId(asset.caip);
-        console.log(tag6, "networkId: ", asset.networkId);
-        console.log(tag6, "this.pubkeys: ", this.pubkeys);
+        console.log(tag, "networkId: ", asset.networkId);
+        console.log(tag, "this.pubkeys: ", this.pubkeys);
         const pubkey = this.pubkeys.find((p) => {
           if (!p.networks || !Array.isArray(p.networks))
             return false;
@@ -5258,23 +4896,23 @@ class SDK {
         let freshPriceUsd = 0;
         try {
           if (!asset.caip || typeof asset.caip !== "string" || !asset.caip.includes(":")) {
-            console.warn(tag6, "Invalid or missing CAIP, skipping market price fetch:", asset.caip);
+            console.warn(tag, "Invalid or missing CAIP, skipping market price fetch:", asset.caip);
           } else {
-            console.log(tag6, "Fetching fresh market price for:", asset.caip);
+            console.log(tag, "Fetching fresh market price for:", asset.caip);
             const marketData = await this.pioneer.GetMarketInfo([asset.caip]);
-            console.log(tag6, "Market data response:", marketData);
+            console.log(tag, "Market data response:", marketData);
             if (marketData && marketData.data && marketData.data.length > 0) {
               freshPriceUsd = marketData.data[0];
-              console.log(tag6, "✅ Fresh market price:", freshPriceUsd);
+              console.log(tag, "✅ Fresh market price:", freshPriceUsd);
             } else {
-              console.warn(tag6, "No market data returned for:", asset.caip);
+              console.warn(tag, "No market data returned for:", asset.caip);
             }
           }
         } catch (marketError) {
-          console.error(tag6, "Error fetching market price:", marketError);
+          console.error(tag, "Error fetching market price:", marketError);
         }
         let assetInfo = this.assetsMap.get(asset.caip.toLowerCase());
-        console.log(tag6, "assetInfo: ", assetInfo);
+        console.log(tag, "assetInfo: ", assetInfo);
         if (!assetInfo) {
           assetInfo = {
             caip: asset.caip.toLowerCase(),
@@ -5292,45 +4930,45 @@ class SDK {
             const valueUsd = parseFloat(matchingBalances[0].valueUsd);
             if (balance > 0 && valueUsd > 0) {
               priceValue = valueUsd / balance;
-              console.log(tag6, "calculated priceUsd from valueUsd/balance:", priceValue);
+              console.log(tag, "calculated priceUsd from valueUsd/balance:", priceValue);
             }
           }
           if (priceValue && priceValue > 0) {
-            console.log(tag6, "detected priceUsd from balance:", priceValue);
+            console.log(tag, "detected priceUsd from balance:", priceValue);
             assetInfo.priceUsd = priceValue;
           }
         }
         if (freshPriceUsd && freshPriceUsd > 0) {
           assetInfo.priceUsd = freshPriceUsd;
-          console.log(tag6, "✅ Using fresh market price:", freshPriceUsd);
+          console.log(tag, "✅ Using fresh market price:", freshPriceUsd);
           let totalBalance = 0;
           let totalValueUsd = 0;
-          console.log(tag6, `Found ${matchingBalances.length} balance entries for ${asset.caip}`);
+          console.log(tag, `Found ${matchingBalances.length} balance entries for ${asset.caip}`);
           for (const balanceEntry of matchingBalances) {
             const balance = parseFloat(balanceEntry.balance) || 0;
             const valueUsd = parseFloat(balanceEntry.valueUsd) || 0;
             totalBalance += balance;
             totalValueUsd += valueUsd;
-            console.log(tag6, `  Balance entry: ${balance} (${valueUsd} USD)`);
+            console.log(tag, `  Balance entry: ${balance} (${valueUsd} USD)`);
           }
           assetInfo.balance = totalBalance.toString();
           assetInfo.valueUsd = totalValueUsd.toFixed(2);
-          console.log(tag6, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
+          console.log(tag, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
         }
-        console.log(tag6, "CHECKPOINT 1");
+        console.log(tag, "CHECKPOINT 1");
         this.outboundAssetContext = { ...assetInfo, ...asset, ...pubkey };
-        console.log(tag6, "CHECKPOINT 3");
-        console.log(tag6, "outboundAssetContext: assetInfo: ", assetInfo);
+        console.log(tag, "CHECKPOINT 3");
+        console.log(tag, "outboundAssetContext: assetInfo: ", assetInfo);
         if (asset.caip) {
           this.outboundBlockchainContext = import_pioneer_caip8.caipToNetworkId(asset.caip);
         } else if (asset.networkId) {
           this.outboundBlockchainContext = asset.networkId;
         }
-        console.log(tag6, "CHECKPOINT 4");
+        console.log(tag, "CHECKPOINT 4");
         this.events.emit("SET_OUTBOUND_ASSET_CONTEXT", this.outboundAssetContext);
         return this.outboundAssetContext;
       } catch (e) {
-        console.error(tag6, "e: ", e);
+        console.error(tag, "e: ", e);
         throw e;
       }
     };