@pioneer-platform/pioneer-sdk 4.21.0 → 4.21.2

package/dist/index.cjs

@@ -260,7 +260,7 @@ var require_lib = __commonJS((exports2) => {
       this.spec = spec;
       this.queryKey = config.queryKey;
       this.pioneer = {};
-      this.timeout = config.queryKey || 45000;
+      this.timeout = config.timeout || 45000;
     }
     Pioneer2.prototype.init = function() {
       return __awaiter(this, undefined, undefined, function() {
@@ -665,21 +665,101 @@ 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, address: 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 tag = "| charts-evm |";
+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(tag, "Total pubkeys available:", pubkeys.length);
-  console.log(tag, "Blockchains to process:", blockchains);
+  console.log(tag2, "Total pubkeys available:", pubkeys.length);
+  console.log(tag2, "Blockchains to process:", blockchains);
   if (!primaryAddress) {
-    console.log(tag, "No EVM address found, skipping portfolio lookup (Zapper only supports Ethereum)");
+    console.log(tag2, "No EVM address found, skipping portfolio lookup (Zapper only supports Ethereum)");
     return balances;
   }
-  console.log(tag, "Using EVM address for portfolio:", primaryAddress);
+  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",
@@ -687,10 +767,10 @@ async function getEvmCharts(params) {
     });
     portfolio = portfolio.data?.data || portfolio.data;
     if (!portfolio || !portfolio.balances) {
-      console.error(tag, "No portfolio.balances found:", portfolio);
+      console.error(tag2, "No portfolio.balances found:", portfolio);
       return balances;
     }
-    console.log(tag, `Portfolio returned ${portfolio.balances.length} balances`);
+    console.log(tag2, `Portfolio returned ${portfolio.balances.length} balances`);
     let processedCount = 0;
     let skippedCount = 0;
     for (const balance of portfolio.balances) {
@@ -704,9 +784,9 @@ async function getEvmCharts(params) {
         skippedCount++;
       }
     }
-    console.log(tag, `Processed ${processedCount} balances, skipped ${skippedCount}`);
+    console.log(tag2, `Processed ${processedCount} balances, skipped ${skippedCount}`);
     if (portfolio.tokens && portfolio.tokens.length > 0) {
-      console.log(tag, "Processing portfolio.tokens:", portfolio.tokens.length);
+      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)) {
@@ -715,13 +795,13 @@ async function getEvmCharts(params) {
       }
     }
   } catch (e) {
-    console.error(tag, "Error fetching portfolio:", e);
+    console.error(tag2, "Error fetching portfolio:", e);
   }
   return balances;
 }
 function processPortfolioBalance(balance, primaryAddress, context, blockchains) {
   if (!balance.caip) {
-    console.error(tag, "No caip found for:", balance);
+    console.error(tag2, "No caip found for:", balance);
     return null;
   }
   const networkId = balance.caip.split("/")[0];
@@ -739,7 +819,7 @@ function processPortfolioBalance(balance, primaryAddress, context, blockchains)
     const valueNum = parseFloat(balance.valueUsd.toString());
     if (balanceNum > 0 && valueNum > 0) {
       calculatedPrice = valueNum / balanceNum;
-      console.log(tag, `Calculated price from value/balance: ${calculatedPrice} for ${balance.caip}`);
+      console.log(tag2, `Calculated price from value/balance: ${calculatedPrice} for ${balance.caip}`);
     }
   }
   const chartBalance = {
@@ -813,70 +893,70 @@ function processPortfolioToken(token, primaryAddress, context, blockchains) {
   return chartBalance;
 }
 async function fetchStableCoins(pioneer, primaryAddress, blockchains, balances, context) {
-  console.log(tag, "Fetching stable coins for redundancy...");
+  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(tag, "No supported networks for stable coins");
+    console.log(tag2, "No supported networks for stable coins");
     return;
   }
-  console.log(tag, `Checking stable coins on ${networksToCheck.length} networks`);
+  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(tag, `Found ${stableCoins.length} stable coins on ${networkId}`);
+      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(tag, `Added stable coin: ${chartBalance.symbol} = ${chartBalance.balance}`);
+          console.log(tag2, `Added stable coin: ${chartBalance.symbol} = ${chartBalance.balance}`);
         }
       }
     } catch (error) {
-      console.error(tag, `Error fetching stable coins for ${networkId}:`, error.message);
+      console.error(tag2, `Error fetching stable coins for ${networkId}:`, error.message);
     }
   }
-  console.log(tag, `Stable coin redundancy complete. Total balances: ${balances.length}`);
+  console.log(tag2, `Stable coin redundancy complete. Total balances: ${balances.length}`);
 }
 
 // src/charts/maya.ts
-var tag2 = "| charts-maya |";
+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(tag2, "No MAYA pubkey found, skipping MAYA token fetch");
+      console.log(tag3, "No MAYA pubkey found, skipping MAYA token fetch");
       return balances;
     }
     if (!blockchains.includes("cosmos:mayachain-mainnet-v1")) {
-      console.log(tag2, "MAYA network not in blockchains list, skipping MAYA token fetch");
+      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(tag2, "MAYA token already exists in balances, skipping");
+      console.log(tag3, "MAYA token already exists in balances, skipping");
       return balances;
     }
-    console.log(tag2, "MAYA token not found in portfolio, fetching separately...");
-    console.log(tag2, "MAYA pubkey address:", mayaPubkey.address);
+    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(tag2, "MAYA balance response:", JSON.stringify(mayaBalanceResponse?.data, null, 2));
+    console.log(tag3, "MAYA balance response:", JSON.stringify(mayaBalanceResponse?.data, null, 2));
     if (!mayaBalanceResponse?.data || mayaBalanceResponse.data.length === 0) {
-      console.log(tag2, "No MAYA token balance returned from GetPortfolioBalances API");
+      console.log(tag3, "No MAYA token balance returned from GetPortfolioBalances API");
       return balances;
     }
-    console.log(tag2, "Found MAYA token balances:", mayaBalanceResponse.data.length);
+    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(tag2, "Unexpected balance in MAYA response:", mayaBalance);
+        console.log(tag3, "Unexpected balance in MAYA response:", mayaBalance);
         continue;
       }
       const mayaAssetInfo = hydrateAssetData(mayaBalance.caip);
@@ -902,28 +982,28 @@ async function getMayaCharts(params, existingBalances) {
         valueUsd: parseFloat(mayaBalance.valueUsd) || 0,
         updated: new Date().getTime()
       };
-      console.log(tag2, "Adding MAYA token to balances:", mayaTokenBalance);
+      console.log(tag3, "Adding MAYA token to balances:", mayaTokenBalance);
       balances.push(mayaTokenBalance);
     }
   } catch (mayaError) {
-    console.error(tag2, "Error fetching MAYA token balance:", mayaError);
+    console.error(tag3, "Error fetching MAYA token balance:", mayaError);
   }
   return balances;
 }
 
 // src/charts/cosmos-staking.ts
-var tag3 = "| charts-cosmos-staking |";
+var tag4 = "| charts-cosmos-staking |";
 async function getCosmosStakingCharts(params) {
   const { blockchains, pioneer, pubkeys, context } = params;
   const balances = [];
   try {
-    console.log(tag3, "Adding Cosmos staking positions to charts...");
+    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(tag3, "No cosmos pubkeys found for staking positions");
+      console.log(tag4, "No cosmos pubkeys found for staking positions");
       return balances;
     }
-    console.log(tag3, "Found cosmos pubkeys for staking:", cosmosPubkeys.length);
+    console.log(tag4, "Found cosmos pubkeys for staking:", cosmosPubkeys.length);
     for (const cosmosPubkey of cosmosPubkeys) {
       if (!cosmosPubkey.address) {
         continue;
@@ -937,20 +1017,20 @@ async function getCosmosStakingCharts(params) {
       }
     }
   } catch (e) {
-    console.error(tag3, "Error adding cosmos staking positions:", e);
+    console.error(tag4, "Error adding cosmos staking positions:", e);
   }
   return balances;
 }
 async function fetchStakingPositionsForNetwork(networkId, address, context, pioneer, balances) {
   try {
-    console.log(tag3, `Fetching staking positions for ${address} on ${networkId}...`);
+    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(tag3, `Unsupported networkId for staking: ${networkId}`);
+      console.error(tag4, `Unsupported networkId for staking: ${networkId}`);
       return;
     }
     const stakingResponse = await pioneer.GetStakingPositions({
@@ -958,15 +1038,15 @@ async function fetchStakingPositionsForNetwork(networkId, address, context, pion
       address
     });
     if (!stakingResponse?.data || !Array.isArray(stakingResponse.data)) {
-      console.log(tag3, `No staking positions found for ${address} on ${networkId}`);
+      console.log(tag4, `No staking positions found for ${address} on ${networkId}`);
       return;
     }
-    console.log(tag3, `Found ${stakingResponse.data.length} staking positions for ${networkId}`);
+    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(tag3, `Added ${position.type} position:`, {
+        console.log(tag4, `Added ${position.type} position:`, {
           balance: processedPosition.balance,
           ticker: processedPosition.ticker,
           valueUsd: processedPosition.valueUsd,
@@ -975,7 +1055,7 @@ async function fetchStakingPositionsForNetwork(networkId, address, context, pion
       }
     }
   } catch (stakingError) {
-    console.error(tag3, `Error fetching staking positions for ${address} on ${networkId}:`, stakingError);
+    console.error(tag4, `Error fetching staking positions for ${address} on ${networkId}:`, stakingError);
   }
 }
 function processStakingPosition(position, address, context, networkId) {
@@ -1010,11 +1090,11 @@ function processStakingPosition(position, address, context, networkId) {
 }
 
 // src/charts/index.ts
-var tag4 = "| getCharts |";
+var tag5 = "| getCharts |";
 var getCharts = async (blockchains, pioneer, pubkeys, context) => {
   try {
     const balances = [];
-    console.log(tag4, "init");
+    console.log(tag5, "init");
     const params = {
       blockchains,
       pioneer,
@@ -1029,7 +1109,7 @@ var getCharts = async (blockchains, pioneer, pubkeys, context) => {
     balances.push(...stakingBalances);
     return balances;
   } catch (error) {
-    console.error(tag4, "Error processing charts:", error);
+    console.error(tag5, "Error processing charts:", error);
     throw error;
   }
 };
@@ -1807,7 +1887,7 @@ async function fetchTokenPriceInUsd(pioneer, caip) {
   }
 }
 async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pubkeyContext, isMax, feeLevel = 5) {
-  const tag5 = TAG + " | createUnsignedEvmTx | ";
+  const tag6 = TAG + " | createUnsignedEvmTx | ";
   try {
     if (!pioneer)
       throw new Error("Failed to initialize Pioneer");
@@ -1828,11 +1908,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(tag5, "✅ Using FROM address from pubkeyContext:", address, "note:", pubkeyContext.note);
+    console.log(tag6, "✅ 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(tag5, "Gas price data from API:", JSON.stringify(gasPriceData.data));
+    console.log(tag6, "Gas price data from API:", JSON.stringify(gasPriceData.data));
     let gasPrice;
     const defaultGasPrices = {
       1: 30,
@@ -1848,74 +1928,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(tag5, "Selecting SLOW gas price from API");
+        console.log(tag6, "Selecting SLOW gas price from API");
       } else if (feeLevel >= 8) {
         selectedGasPrice = gasPriceData.data.fastest || gasPriceData.data.fast || gasPriceData.data.average;
-        console.log(tag5, "Selecting FAST gas price from API");
+        console.log(tag6, "Selecting FAST gas price from API");
       } else {
         selectedGasPrice = gasPriceData.data.average || gasPriceData.data.fast || gasPriceData.data.fastest;
-        console.log(tag5, "Selecting AVERAGE gas price from API");
+        console.log(tag6, "Selecting AVERAGE gas price from API");
       }
       let gasPriceNum;
       if (selectedGasPrice === undefined || selectedGasPrice === null) {
-        console.warn(tag5, "No valid gas price found in API response, using fallback:", fallbackGasGwei, "gwei");
+        console.warn(tag6, "No valid gas price found in API response, using fallback:", fallbackGasGwei, "gwei");
         gasPriceNum = fallbackGasGwei;
       } else {
         gasPriceNum = typeof selectedGasPrice === "string" ? parseFloat(selectedGasPrice) : selectedGasPrice;
         if (isNaN(gasPriceNum) || !isFinite(gasPriceNum)) {
-          console.warn(tag5, "Invalid gas price (NaN or Infinite):", selectedGasPrice, "- using fallback:", fallbackGasGwei, "gwei");
+          console.warn(tag6, "Invalid gas price (NaN or Infinite):", selectedGasPrice, "- using fallback:", fallbackGasGwei, "gwei");
           gasPriceNum = fallbackGasGwei;
         }
       }
       gasPrice = BigInt(Math.round(gasPriceNum * 1e9));
       if (gasPrice < MIN_GAS_PRICE_WEI) {
-        console.warn(tag5, "Gas price from API too low:", gasPrice.toString(), "wei - using minimum:", MIN_GAS_PRICE_WEI.toString());
+        console.warn(tag6, "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(tag5, "Gas price API returned null/undefined, using fallback:", fallbackGasGwei, "gwei");
+        console.warn(tag6, "Gas price API returned null/undefined, using fallback:", fallbackGasGwei, "gwei");
         gasPriceNum = fallbackGasGwei;
       } else {
         gasPriceNum = typeof gasPriceData.data === "string" ? parseFloat(gasPriceData.data) : gasPriceData.data;
         if (isNaN(gasPriceNum) || !isFinite(gasPriceNum)) {
-          console.warn(tag5, "Invalid gas price (NaN or Infinite):", gasPriceData.data, "- using fallback:", fallbackGasGwei, "gwei");
+          console.warn(tag6, "Invalid gas price (NaN or Infinite):", gasPriceData.data, "- using fallback:", fallbackGasGwei, "gwei");
           gasPriceNum = fallbackGasGwei;
         }
       }
       const baseGasPrice = BigInt(Math.round(gasPriceNum * 1e9));
       if (feeLevel <= 2) {
         gasPrice = baseGasPrice * BigInt(80) / BigInt(100);
-        console.log(tag5, "Using SLOW gas price (80% of base)");
+        console.log(tag6, "Using SLOW gas price (80% of base)");
       } else if (feeLevel >= 8) {
         gasPrice = baseGasPrice * BigInt(150) / BigInt(100);
-        console.log(tag5, "Using FAST gas price (150% of base)");
+        console.log(tag6, "Using FAST gas price (150% of base)");
       } else {
         gasPrice = baseGasPrice;
-        console.log(tag5, "Using AVERAGE gas price (100% of base)");
+        console.log(tag6, "Using AVERAGE gas price (100% of base)");
       }
       if (gasPrice < MIN_GAS_PRICE_WEI) {
-        console.warn(tag5, "Gas price too low:", gasPrice.toString(), "wei - using minimum:", MIN_GAS_PRICE_WEI.toString());
+        console.warn(tag6, "Gas price too low:", gasPrice.toString(), "wei - using minimum:", MIN_GAS_PRICE_WEI.toString());
         gasPrice = MIN_GAS_PRICE_WEI;
       }
     }
-    console.log(tag5, "Final gasPrice:", gasPrice.toString(), "wei (", Number(gasPrice) / 1e9, "gwei)");
+    console.log(tag6, "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(tag5, "No nonce found for address (likely fresh address), defaulting to 0");
+        console.log(tag6, "No nonce found for address (likely fresh address), defaulting to 0");
         nonce = 0;
       }
     } catch (nonceError) {
-      console.log(tag5, "Failed to fetch nonce (likely fresh address):", nonceError.message, "- defaulting to 0");
+      console.log(tag6, "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.balance);
+    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)");
     if (balance <= 0n)
       throw new Error("Wallet balance is zero");
     const assetType = classifyCaipEvm(caip);
@@ -1928,7 +2009,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
         let gasLimit;
         if (isThorchainOperation) {
           gasLimit = BigInt(120000);
-          console.log(tag5, "Using higher gas limit for THORChain swap:", gasLimit.toString());
+          console.log(tag6, "Using higher gas limit for THORChain swap:", gasLimit.toString());
         } else {
           gasLimit = chainId === 1 ? BigInt(21000) : BigInt(25000);
         }
@@ -1944,7 +2025,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
           }
           const buffer = BigInt(100);
           amountWei = balance - gasFee - buffer;
-          console.log(tag5, "isMax calculation - balance:", balance.toString(), "gasFee:", gasFee.toString(), "buffer:", buffer.toString(), "amountWei:", amountWei.toString());
+          console.log(tag6, "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) {
@@ -1954,14 +2035,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(tag5, "Detected THORChain swap, encoding deposit data for memo:", memo);
+          console.log(tag6, "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(tag5, "Fixed Bitcoin swap memo from:", memo, "to:", fixedMemo);
+            console.log(tag6, "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(tag5, "Fixed Ethereum swap memo from:", memo, "to:", fixedMemo);
+            console.log(tag6, "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)`);
@@ -1977,14 +2058,14 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
                 if (ethInbound) {
                   vaultAddress = ethInbound.address;
                   routerAddress = ethInbound.router || to;
-                  console.log(tag5, "Using THORChain inbound addresses - vault:", vaultAddress, "router:", routerAddress);
+                  console.log(tag6, "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(tag5, "Failed to fetch inbound addresses:", fetchError);
+              console.error(tag6, "Failed to fetch inbound addresses:", fetchError);
               throw new Error(`Cannot proceed with THORChain swap - failed to fetch inbound addresses: ${fetchError.message}`);
             }
             if (vaultAddress === "0x0000000000000000000000000000000000000000") {
@@ -2004,7 +2085,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(tag5, "Encoded THORChain depositWithExpiry data:", {
+            console.log(tag6, "Encoded THORChain depositWithExpiry data:", {
               functionSelector: "0x" + functionSelector,
               vault: vaultAddress,
               asset: assetAddress,
@@ -2014,9 +2095,9 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
               stringOffset: "0x" + stringOffset,
               fullData: txData
             });
-            console.log(tag5, "Native ETH swap - value will be set to:", amountWei.toString(), "wei");
+            console.log(tag6, "Native ETH swap - value will be set to:", amountWei.toString(), "wei");
           } catch (error) {
-            console.error(tag5, "Error encoding THORChain deposit:", error);
+            console.error(tag6, "Error encoding THORChain deposit:", error);
             throw new Error(`Failed to encode THORChain swap: ${error.message}`);
           }
         } else if (memo) {
@@ -2035,19 +2116,19 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
       }
       case "erc20": {
         const contractAddress = extractContractAddressFromCaip(caip);
-        console.log(tag5, "Fetching token decimals from contract:", contractAddress, "on network:", networkId);
+        console.log(tag6, "Fetching token decimals from contract:", contractAddress, "on network:", networkId);
         let tokenDecimals;
         try {
-          console.log(tag5, "Fetching token decimals via pioneer-server API for", contractAddress, "on", networkId);
+          console.log(tag6, "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(tag5, "✅ Fetched decimals from pioneer-server:", tokenDecimals);
+          console.log(tag6, "✅ Fetched decimals from pioneer-server:", tokenDecimals);
         } catch (error) {
-          console.error(tag5, "Failed to fetch token decimals from pioneer-server:", error);
-          console.warn(tag5, "⚠️ FALLBACK: Using default 18 decimals - THIS MAY BE INCORRECT!");
+          console.error(tag6, "Failed to fetch token decimals from pioneer-server:", error);
+          console.warn(tag6, "⚠️ FALLBACK: Using default 18 decimals - THIS MAY BE INCORRECT!");
           tokenDecimals = 18;
         }
         const tokenMultiplier = 10n ** BigInt(tokenDecimals);
@@ -2068,14 +2149,16 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
           amountWei = tokenBalance;
         } else {
           amountWei = BigInt(Math.round(amount * Number(tokenMultiplier)));
-          console.log(tag5, "Token amount calculation:", {
+          console.log(tag6, "Token amount calculation:", {
             inputAmount: amount,
             decimals: tokenDecimals,
             multiplier: tokenMultiplier,
             resultWei: amountWei.toString()
           });
         }
-        if (gasFee > balance) {
+        const estimatedGasForCheck = BigInt(25000);
+        const estimatedGasFee = gasPrice * estimatedGasForCheck;
+        if (estimatedGasFee > balance) {
           throw new Error("Insufficient ETH balance to cover gas fees");
         }
         const data = encodeTransferData(to, amountWei);
@@ -2102,23 +2185,23 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
     }
     if (pubkeyContext.addressNListMaster) {
       unsignedTx.addressNList = pubkeyContext.addressNListMaster;
-      console.log(tag5, "✅ Using addressNListMaster from pubkey context:", unsignedTx.addressNList, "for address:", address);
+      console.log(tag6, "✅ Using addressNListMaster from pubkey context:", unsignedTx.addressNList, "for address:", address);
     } else if (pubkeyContext.pathMaster) {
       unsignedTx.addressNList = import_pioneer_coins2.bip32ToAddressNList(pubkeyContext.pathMaster);
-      console.log(tag5, "✅ Converted pathMaster to addressNList:", pubkeyContext.pathMaster, "→", unsignedTx.addressNList);
+      console.log(tag6, "✅ Converted pathMaster to addressNList:", pubkeyContext.pathMaster, "→", unsignedTx.addressNList);
     } else if (pubkeyContext.addressNList) {
       unsignedTx.addressNList = pubkeyContext.addressNList;
-      console.log(tag5, "✅ Using addressNList from pubkey context:", unsignedTx.addressNList);
+      console.log(tag6, "✅ Using addressNList from pubkey context:", unsignedTx.addressNList);
     } else if (pubkeyContext.path) {
       unsignedTx.addressNList = import_pioneer_coins2.bip32ToAddressNList(pubkeyContext.path);
-      console.log(tag5, "⚠️ Using regular path (not master):", pubkeyContext.path, "→", unsignedTx.addressNList);
+      console.log(tag6, "⚠️ Using regular path (not master):", pubkeyContext.path, "→", unsignedTx.addressNList);
     } else {
       unsignedTx.addressNList = [2147483648 + 44, 2147483648 + 60, 2147483648, 0, 0];
-      console.warn(tag5, "⚠️ No path info in pubkey context, using default account 0");
+      console.warn(tag6, "⚠️ No path info in pubkey context, using default account 0");
     }
     return unsignedTx;
   } catch (error) {
-    console.error(tag5, "Error:", error.message);
+    console.error(tag6, "Error:", error.message);
     throw error;
   }
 }
@@ -2127,7 +2210,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
 var import_pioneer_caip2 = require("@pioneer-platform/pioneer-caip");
 var TAG2 = " | createUnsignedUxtoTx | ";
 async function createUnsignedRippleTx(caip, to, amount, memo, pubkeys, pioneer, pubkeyContext, isMax) {
-  let tag5 = TAG2 + " | createUnsignedRippleTx | ";
+  let tag6 = TAG2 + " | createUnsignedRippleTx | ";
   try {
     if (!pioneer)
       throw new Error("Failed to init! pioneer");
@@ -2138,7 +2221,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(tag5, `✅ Using pubkeyContext for network ${networkId}:`, {
+    console.log(tag6, `✅ Using pubkeyContext for network ${networkId}:`, {
       address: pubkeyContext.address
     });
     const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
@@ -2206,7 +2289,7 @@ async function createUnsignedRippleTx(caip, to, amount, memo, pubkeys, pioneer,
     };
     return unsignedTx;
   } catch (error) {
-    console.error(tag5, "Error:", error);
+    console.error(tag6, "Error:", error);
     throw error;
   }
 }
@@ -2346,7 +2429,7 @@ var thorchainDepositTemplate = (params) => ({
 // src/txbuilder/createUnsignedTendermintTx.ts
 var TAG3 = " | createUnsignedTendermintTx | ";
 async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pioneer, pubkeyContext, isMax, to) {
-  const tag5 = TAG3 + " | createUnsignedTendermintTx | ";
+  const tag6 = TAG3 + " | createUnsignedTendermintTx | ";
   try {
     if (!pioneer)
       throw new Error("Failed to init! pioneer");
@@ -2357,7 +2440,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(tag5, `✅ Using pubkeyContext for network ${networkId}:`, {
+    console.log(tag6, `✅ Using pubkeyContext for network ${networkId}:`, {
       address: pubkeyContext.address,
       addressNList: pubkeyContext.addressNList || pubkeyContext.addressNListMaster
     });
@@ -2380,11 +2463,11 @@ async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pio
     }
     const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
     let asset = caip.split(":")[1];
-    console.log(tag5, `\uD83D\uDD0D Fetching account info for address: ${fromAddress}`);
+    console.log(tag6, `\uD83D\uDD0D Fetching account info for address: ${fromAddress}`);
     const accountInfo = (await pioneer.GetAccountInfo({ network: chain, address: fromAddress })).data;
-    console.log(tag5, "\uD83D\uDCCB accountInfo:", JSON.stringify(accountInfo, null, 2));
+    console.log(tag6, "\uD83D\uDCCB accountInfo:", JSON.stringify(accountInfo, null, 2));
     let balanceInfo = await pioneer.GetPubkeyBalance({ asset: chain, pubkey: fromAddress });
-    console.log(tag5, `\uD83D\uDCB0 balanceInfo:`, balanceInfo);
+    console.log(tag6, `\uD83D\uDCB0 balanceInfo:`, balanceInfo);
     let account_number, sequence;
     if (accountInfo.account) {
       account_number = accountInfo.account.account_number || "0";
@@ -2395,13 +2478,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(tag5, `\uD83D\uDCCA Extracted account_number: ${account_number}, sequence: ${sequence}`);
+    console.log(tag6, `\uD83D\uDCCA Extracted account_number: ${account_number}, sequence: ${sequence}`);
     if (account_number === "0" || account_number === 0) {
-      console.log(tag5, `⚠️  WARNING: Account number is 0 from Pioneer API`);
-      console.log(tag5, `   This is likely due to stale Pioneer API cache`);
-      console.log(tag5, `   The mayachain-network module queries nodes directly but Pioneer API may be cached`);
-      console.log(tag5, `   Proceeding with account_number: 0 but transaction will likely fail`);
-      console.log(tag5, `   TODO: Fix Pioneer API to use fresh data from mayachain-network module`);
+      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`);
     }
     const fees = {
       "cosmos:thorchain-mainnet-v1": 0.02,
@@ -2556,7 +2639,7 @@ async function createUnsignedTendermintTx(caip, type, amount, memo, pubkeys, pio
       }
     }
   } catch (error) {
-    console.error(tag5, "Error:", error);
+    console.error(tag6, "Error:", error);
     throw error;
   }
 }
@@ -2585,7 +2668,7 @@ function getCoinTypeFromNetworkId(networkId) {
   return coinType;
 }
 async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pubkeyContext, isMax, feeLevel = 5, changeScriptType) {
-  let tag5 = " | createUnsignedUxtoTx | ";
+  let tag6 = " | createUnsignedUxtoTx | ";
   try {
     if (!pioneer)
       throw Error("Failed to init! pioneer");
@@ -2596,7 +2679,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(tag5, `✅ Using pubkeyContext for network ${networkId}:`, {
+    console.log(tag6, `✅ Using pubkeyContext for network ${networkId}:`, {
       address: pubkeyContext.address,
       scriptType: pubkeyContext.scriptType
     });
@@ -2607,15 +2690,15 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
     const isSegwit = segwitNetworks.includes(networkId);
     let chain = import_pioneer_caip4.NetworkIdToChain[networkId];
     const coinType = getCoinTypeFromNetworkId(networkId);
-    console.log(`${tag5}: Using SLIP-44 coin type ${coinType} for ${chain}`);
+    console.log(`${tag6}: 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(`${tag5}: ListUnspent response for ${pubkey.scriptType}:`, utxosResp?.length || 0, "UTXOs");
+        console.log(`${tag6}: ListUnspent response for ${pubkey.scriptType}:`, utxosResp?.length || 0, "UTXOs");
         if (!utxosResp || !Array.isArray(utxosResp)) {
-          console.warn(`${tag5}: Invalid or empty UTXO response for ${pubkey.pubkey}`);
+          console.warn(`${tag6}: Invalid or empty UTXO response for ${pubkey.pubkey}`);
           continue;
         }
         let scriptType = pubkey.scriptType;
@@ -2624,10 +2707,10 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
         }
         utxos.push(...utxosResp);
       } catch (error) {
-        console.error(`${tag5}: Failed to fetch UTXOs for ${pubkey.pubkey}:`, error);
+        console.error(`${tag6}: Failed to fetch UTXOs for ${pubkey.pubkey}:`, error);
       }
     }
-    console.log(`${tag5}: Total UTXOs collected:`, utxos.length);
+    console.log(`${tag6}: Total UTXOs collected:`, utxos.length);
     if (!utxos || utxos.length === 0)
       throw Error("No UTXOs found across all addresses");
     for (const utxo of utxos) {
@@ -2640,14 +2723,14 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
     }, {});
     const mostCommonInputType = Object.entries(scriptTypeCount).sort(([, a], [, b2]) => b2 - a)[0]?.[0] || "p2pkh";
     const actualChangeScriptType = changeScriptType || mostCommonInputType || relevantPubkeys[0]?.scriptType || "p2pkh";
-    console.log(`${tag5}: Input script types:`, scriptTypeCount);
-    console.log(`${tag5}: Using change script type: ${actualChangeScriptType} (matches inputs: ${mostCommonInputType})`);
+    console.log(`${tag6}: Input script types:`, scriptTypeCount);
+    console.log(`${tag6}: Using change script type: ${actualChangeScriptType} (matches inputs: ${mostCommonInputType})`);
     const changeXpubInfo = relevantPubkeys.find((pk) => pk.scriptType === actualChangeScriptType);
     if (!changeXpubInfo) {
       throw new Error(`No ${actualChangeScriptType} xpub available for change address. ` + `Available types: ${relevantPubkeys.map((pk) => pk.scriptType).join(", ")}. ` + `Cannot create change output with mismatched script type.`);
     }
     const changeXpub = changeXpubInfo.pubkey;
-    console.log(`${tag5}: Change xpub selected for ${actualChangeScriptType}:`, changeXpub?.substring(0, 10) + "...");
+    console.log(`${tag6}: Change xpub selected for ${actualChangeScriptType}:`, changeXpub?.substring(0, 10) + "...");
     let changeAddressIndex = await pioneer.GetChangeAddress({
       network: chain,
       xpub: changeXpub
@@ -2667,7 +2750,7 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
         break;
     }
     const path = bipPath;
-    console.log(`${tag5}: Change address path: ${path} (coin type: ${coinType}, index: ${changeAddressIndex})`);
+    console.log(`${tag6}: Change address path: ${path} (coin type: ${coinType}, index: ${changeAddressIndex})`);
     const changeAddress = {
       path,
       isChange: true,
@@ -2677,7 +2760,7 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
     };
     let feeRateFromNode;
     if (networkId === "bip122:00000000001a91e3dace36e2be3bf030") {
-      console.log(`${tag5}: Using hardcoded fees for DOGE (10 sat/byte)`);
+      console.log(`${tag6}: Using hardcoded fees for DOGE (10 sat/byte)`);
       feeRateFromNode = {
         slow: 10,
         average: 10,
@@ -2690,19 +2773,19 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
       try {
         let feeResponse;
         if (pioneer.GetFeeRateByNetwork) {
-          console.log(`${tag5}: Trying GetFeeRateByNetwork for ${networkId}`);
+          console.log(`${tag6}: Trying GetFeeRateByNetwork for ${networkId}`);
           feeResponse = await pioneer.GetFeeRateByNetwork({ networkId });
         } else {
-          console.log(`${tag5}: Using GetFeeRate for ${networkId}`);
+          console.log(`${tag6}: Using GetFeeRate for ${networkId}`);
           feeResponse = await pioneer.GetFeeRate({ networkId });
         }
         feeRateFromNode = feeResponse.data;
-        console.log(`${tag5}: Got fee rates from API:`, JSON.stringify(feeRateFromNode, null, 2));
+        console.log(`${tag6}: 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(`${tag5}: Detected wrong units - values appear to be in sat/kB instead of sat/byte`);
-          console.warn(`${tag5}: Original values:`, {
+          console.warn(`${tag6}: Detected wrong units - values appear to be in sat/kB instead of sat/byte`);
+          console.warn(`${tag6}: Original values:`, {
             slow: feeRateFromNode.slow,
             average: feeRateFromNode.average,
             fast: feeRateFromNode.fast,
@@ -2716,12 +2799,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(`${tag5}: Converted to sat/byte:`, feeRateFromNode);
+          console.warn(`${tag6}: Converted to sat/byte:`, feeRateFromNode);
         }
         if (!feeRateFromNode || typeof feeRateFromNode !== "object") {
           throw new Error(`Invalid fee rate response from API: ${JSON.stringify(feeRateFromNode)}`);
         }
-        console.log(`${tag5}: Available fee rates:`, {
+        console.log(`${tag6}: Available fee rates:`, {
           slow: feeRateFromNode.slow,
           average: feeRateFromNode.average,
           fast: feeRateFromNode.fast,
@@ -2731,33 +2814,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(`${tag5}: Failed to get fee rates from Pioneer API:`, error.message || error);
+        console.error(`${tag6}: 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(`${tag5}: Using fee level ${feeLevel}`);
+    console.log(`${tag6}: Using fee level ${feeLevel}`);
     switch (feeLevel) {
       case 1:
       case 2:
         effectiveFeeRate = feeRateFromNode.slow || feeRateFromNode.average;
-        console.log(`${tag5}: Using SLOW fee rate: ${effectiveFeeRate} sat/vB`);
+        console.log(`${tag6}: Using SLOW fee rate: ${effectiveFeeRate} sat/vB`);
         break;
       case 3:
       case 4:
         effectiveFeeRate = feeRateFromNode.average || feeRateFromNode.fast;
-        console.log(`${tag5}: Using AVERAGE fee rate: ${effectiveFeeRate} sat/vB`);
+        console.log(`${tag6}: Using AVERAGE fee rate: ${effectiveFeeRate} sat/vB`);
         break;
       case 5:
         effectiveFeeRate = feeRateFromNode.fastest || feeRateFromNode.fast;
-        console.log(`${tag5}: Using FASTEST fee rate: ${effectiveFeeRate} sat/vB`);
+        console.log(`${tag6}: 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(`${tag5}: Using fee rate from API:`, {
+    console.log(`${tag6}: Using fee rate from API:`, {
       feeLevel,
       selectedRate: effectiveFeeRate,
       description: feeLevel <= 2 ? "slow" : feeLevel <= 4 ? "average" : "fast"
@@ -2767,22 +2850,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(`${tag5}: Fee rate ${effectiveFeeRate} is below minimum relay fee, increasing to ${MIN_RELAY_FEE_RATE} sat/vB`);
+      console.log(`${tag6}: Fee rate ${effectiveFeeRate} is below minimum relay fee, increasing to ${MIN_RELAY_FEE_RATE} sat/vB`);
       effectiveFeeRate = MIN_RELAY_FEE_RATE;
     }
-    console.log(`${tag5}: Final fee rate to use (rounded, with minimums): ${effectiveFeeRate} sat/vB`);
+    console.log(`${tag6}: 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(`${tag5}: Coin selection inputs:`, {
+    console.log(`${tag6}: Coin selection inputs:`, {
       utxoCount: utxos.length,
       totalBalance: totalBalance / 1e8,
       requestedAmount: amount / 1e8,
       isMax,
       feeRate: effectiveFeeRate
     });
-    console.log(`${tag5}: UTXO details for coin selection:`, utxos.map((u) => ({
+    console.log(`${tag6}: UTXO details for coin selection:`, utxos.map((u) => ({
       value: u.value,
       txid: u.txid?.substring(0, 10) + "...",
       vout: u.vout,
@@ -2796,8 +2879,8 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
     } else {
       result = import_coinselect.default(utxos, [{ address: to, value: amount }], effectiveFeeRate);
     }
-    console.log(tag5, "coinSelect result object:", result);
-    console.log(tag5, "coinSelect result.inputs:", result?.inputs);
+    console.log(tag6, "coinSelect result object:", result);
+    console.log(tag6, "coinSelect result.inputs:", result?.inputs);
     if (!result || !result.inputs) {
       const errorDetails = {
         utxoCount: utxos.length,
@@ -2806,7 +2889,7 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
         feeRate: effectiveFeeRate,
         insufficientFunds: totalBalance < amount
       };
-      console.error(`${tag5}: Coin selection failed:`, errorDetails);
+      console.error(`${tag6}: Coin selection failed:`, errorDetails);
       if (utxos.length === 0) {
         throw Error("No UTXOs available for coin selection");
       } else if (totalBalance < amount) {
@@ -2822,7 +2905,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(`${tag5}: Transaction built with:`, {
+    console.log(`${tag6}: Transaction built with:`, {
       feeLevel,
       effectiveFeeRate: `${effectiveFeeRate} sat/vB`,
       calculatedFee: `${fee} satoshis`,
@@ -2830,8 +2913,8 @@ async function createUnsignedUxtoTx(caip, to, amount, memo, pubkeys, pioneer, pu
       outputCount: outputs.length
     });
     const uniqueInputSet = new Set;
-    console.log(tag5, "inputs:", inputs);
-    console.log(tag5, "inputs:", inputs[0]);
+    console.log(tag6, "inputs:", inputs);
+    console.log(tag6, "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,
@@ -2939,7 +3022,7 @@ class TransactionManager {
     throw new Error(`Unsupported CAIP: ${caip}`);
   }
   async transfer({ caip, to, amount, memo, isMax = false, feeLevel = 5, changeScriptType }) {
-    let tag5 = TAG4 + " | transfer | ";
+    let tag6 = TAG4 + " | transfer | ";
     try {
       if (!this.pioneer)
         throw Error("Failed to init! pioneer");
@@ -2977,12 +3060,12 @@ class TransactionManager {
       }
       return unsignedTx;
     } catch (e) {
-      console.error(tag5, e);
+      console.error(tag6, e);
       throw e;
     }
   }
   async sign({ caip, unsignedTx }) {
-    let tag5 = TAG4 + " | sign | ";
+    let tag6 = TAG4 + " | sign | ";
     try {
       if (!this.pioneer)
         throw Error("Failed to init! pioneer");
@@ -3068,20 +3151,20 @@ class TransactionManager {
             }
             case "cosmos:mayachain-mainnet-v1/slip44:931":
             case "cosmos:mayachain-mainnet-v1/denom:maya": {
-              console.log(tag5, "\uD83D\uDD0D ===== MAYACHAIN SIGNING AUDIT =====");
-              console.log(tag5, "\uD83D\uDCCB unsignedTx:", JSON.stringify(unsignedTx, null, 2));
-              console.log(tag5, "\uD83D\uDD11 unsignedTx.addressNList:", unsignedTx.addressNList);
-              console.log(tag5, "\uD83D\uDCCD unsignedTx.signerAddress:", unsignedTx.signerAddress);
-              console.log(tag5, "\uD83C\uDF10 pubkeyContext:", this.pubkeyContext);
-              console.log(tag5, "\uD83D\uDD10 pubkeyContext.addressNList:", this.pubkeyContext?.addressNList);
-              console.log(tag5, "\uD83D\uDD10 pubkeyContext.addressNListMaster:", this.pubkeyContext?.addressNListMaster);
-              console.log(tag5, "\uD83D\uDCEC pubkeyContext.address:", this.pubkeyContext?.address);
-              console.log(tag5, "=======================================");
+              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, "=======================================");
               if (unsignedTx.signDoc.msgs[0].type === "mayachain/MsgSend") {
                 const responseSign = await this.keepKeySdk.mayachain.mayachainSignAminoTransfer(unsignedTx);
                 signedTx = responseSign.serialized;
-                console.log(tag5, "✅ Signing completed");
-                console.log(tag5, "\uD83D\uDCE6 responseSign:", responseSign);
+                console.log(tag6, "✅ Signing completed");
+                console.log(tag6, "\uD83D\uDCE6 responseSign:", responseSign);
               } else if (unsignedTx.signDoc.msgs[0].type === "mayachain/MsgDeposit") {
                 const responseSign = await this.keepKeySdk.mayachain.mayachainSignAminoDeposit(unsignedTx);
                 signedTx = responseSign.serialized;
@@ -3103,11 +3186,11 @@ class TransactionManager {
             if (serialized.length > 140) {
               signedTx = serialized;
             } else {
-              console.error(tag5, "EIP155 signing returned incomplete transaction - only signature components");
+              console.error(tag6, "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(tag5, "EIP155 signing failed - no valid signature in response:", responseSign);
+            console.error(tag6, "EIP155 signing failed - no valid signature in response:", responseSign);
             throw new Error("Failed to sign transaction - no valid signature in response");
           }
           break;
@@ -3128,19 +3211,19 @@ class TransactionManager {
         }
       }
       if (!signedTx) {
-        console.error(tag5, "CRITICAL ERROR: signedTx is missing after signing process");
-        console.error(tag5, "CAIP:", caip);
-        console.error(tag5, "Type:", type);
+        console.error(tag6, "CRITICAL ERROR: signedTx is missing after signing process");
+        console.error(tag6, "CAIP:", caip);
+        console.error(tag6, "Type:", type);
         throw Error("Failed to sign! missing signedTx");
       }
       return signedTx;
     } catch (e) {
-      console.error(tag5, e);
+      console.error(tag6, e);
       throw e;
     }
   }
   async broadcast({ networkId, serialized }) {
-    let tag5 = TAG4 + " | broadcast | ";
+    let tag6 = TAG4 + " | broadcast | ";
     try {
       if (!this.pioneer)
         throw Error("Failed to init! pioneer");
@@ -3154,7 +3237,7 @@ class TransactionManager {
         return result.txid;
       }
     } catch (e) {
-      console.error(tag5, e);
+      console.error(tag6, e);
       throw e;
     }
   }
@@ -3274,7 +3357,7 @@ var cosmosClaimAllRewardsTemplate = (params) => ({
 // src/txbuilder/createUnsignedStakingTx.ts
 var TAG5 = " | createUnsignedStakingTx | ";
 async function createUnsignedStakingTx(caip, params, pubkeys, pioneer, pubkeyContext) {
-  const tag5 = TAG5 + " | createUnsignedStakingTx | ";
+  const tag6 = TAG5 + " | createUnsignedStakingTx | ";
   try {
     if (!pioneer)
       throw new Error("Failed to init! pioneer");
@@ -3285,7 +3368,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(tag5, `✅ Using pubkeyContext for network ${networkId}:`, {
+    console.log(tag6, `✅ Using pubkeyContext for network ${networkId}:`, {
       address: pubkeyContext.address
     });
     let chain;
@@ -3317,10 +3400,10 @@ async function createUnsignedStakingTx(caip, params, pubkeys, pioneer, pubkeyCon
       default:
         throw new Error(`Unsupported networkId for staking: ${networkId}`);
     }
-    console.log(tag5, `Building ${params.type} transaction for ${chain}`);
+    console.log(tag6, `Building ${params.type} transaction for ${chain}`);
     const fromAddress = pubkeyContext.address || pubkeyContext.pubkey;
     const accountInfo = (await pioneer.GetAccountInfo({ network: chain, address: fromAddress })).data;
-    console.log(tag5, "accountInfo: ", accountInfo);
+    console.log(tag6, "accountInfo: ", accountInfo);
     let account_number;
     let sequence;
     if (networkId === "cosmos:cosmoshub-4" || networkId === "cosmos:osmosis-1") {
@@ -3402,7 +3485,7 @@ async function createUnsignedStakingTx(caip, params, pubkeys, pioneer, pubkeyCon
         throw new Error(`Unsupported staking transaction type: ${params.type}`);
     }
   } catch (error) {
-    console.error(tag5, "Error:", error);
+    console.error(tag6, "Error:", error);
     throw error;
   }
 }
@@ -3448,16 +3531,16 @@ function withTimeout(promise, timeoutMs) {
   ]);
 }
 async function getFees(pioneer, networkId) {
-  const tag5 = TAG6 + " | getFees | ";
+  const tag6 = TAG6 + " | getFees | ";
   try {
-    console.log(tag5, `Fetching fees for network: ${networkId}`);
+    console.log(tag6, `Fetching fees for network: ${networkId}`);
     const networkType = getNetworkType(networkId);
     if (networkType === "COSMOS") {
-      console.log(tag5, "Using hardcoded fees for Cosmos network:", networkId);
+      console.log(tag6, "Using hardcoded fees for Cosmos network:", networkId);
       return getCosmosFees(networkId);
     }
     if (networkId === "bip122:00000000001a91e3dace36e2be3bf030") {
-      console.log(tag5, "Using hardcoded fees for Dogecoin: 10 sat/byte");
+      console.log(tag6, "Using hardcoded fees for Dogecoin: 10 sat/byte");
       return {
         slow: {
           label: "Slow",
@@ -3494,7 +3577,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(tag5, "Dash fee API timeout, using fallback fees");
+        console.warn(tag6, "Dash fee API timeout, using fallback fees");
         return {
           slow: {
             label: "Economy",
@@ -3532,17 +3615,17 @@ async function getFees(pioneer, networkId) {
       throw new Error(`No fee data returned for ${networkId}`);
     }
     const feeData = feeResponse.data;
-    console.log(tag5, "Raw fee data:", feeData);
+    console.log(tag6, "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(tag5, "Normalized fees:", normalizedFees);
+    console.log(tag6, "Normalized fees:", normalizedFees);
     return normalizedFees;
   } catch (error) {
-    console.error(tag5, "Failed to fetch fees:", error);
+    console.error(tag6, "Failed to fetch fees:", error);
     return getFallbackFees(networkId);
   }
 }
@@ -3851,7 +3934,7 @@ function estimateTransactionFee(feeRate, unit, networkType, txSize) {
 
 // src/utils/kkapi-detection.ts
 async function detectKkApiAvailability(forceLocalhost) {
-  const tag5 = " | detectKkApiAvailability | ";
+  const tag6 = " | detectKkApiAvailability | ";
   try {
     const isTauri = typeof window !== "undefined" && "__TAURI__" in window;
     const isBrowser = typeof window !== "undefined";
@@ -3979,11 +4062,17 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
       return sum + balanceNum;
     }, 0).toString();
     const assetInfo = nativeAssetCaip ? assetsMap.get(nativeAssetCaip) : null;
+    console.log(TAG7, `[DEBUG] Network: ${blockchain}`);
+    console.log(TAG7, `[DEBUG] nativeAssetCaip: ${nativeAssetCaip}`);
+    console.log(TAG7, `[DEBUG] assetInfo:`, assetInfo);
+    console.log(TAG7, `[DEBUG] gasAsset:`, gasAsset);
+    console.log(TAG7, `[DEBUG] Resolved name: ${gasAsset?.name || assetInfo?.name || "NO NAME"}`);
     networksTemp.push({
       networkId: blockchain,
       totalValueUsd: networkTotal,
       gasAssetCaip: nativeAssetCaip || null,
       gasAssetSymbol: gasAsset?.ticker || gasAsset?.symbol || assetInfo?.symbol || null,
+      gasAssetName: gasAsset?.name || assetInfo?.name || null,
       icon: gasAsset?.icon || assetInfo?.icon || null,
       color: gasAsset?.color || assetInfo?.color || null,
       totalNativeBalance
@@ -4003,11 +4092,11 @@ function buildDashboardFromBalances(balances, blockchains, assetsMap) {
 // src/utils/sync-market.ts
 var TAG8 = " | sync-market | ";
 async function syncMarket(balances, pioneer) {
-  const tag5 = `${TAG8} | syncMarket | `;
+  const tag6 = `${TAG8} | syncMarket | `;
   try {
     const invalidBalances = balances.filter((b2) => !b2 || !b2.caip || typeof b2.caip !== "string" || !b2.caip.includes(":"));
     if (invalidBalances.length > 0) {
-      console.warn(tag5, `Found ${invalidBalances.length} balances with invalid CAIPs:`, invalidBalances.map((b2) => ({
+      console.warn(tag6, `Found ${invalidBalances.length} balances with invalid CAIPs:`, invalidBalances.map((b2) => ({
         caip: b2?.caip,
         type: typeof b2?.caip,
         symbol: b2?.symbol,
@@ -4022,7 +4111,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(tag5, "CRITICAL: Invalid entries detected in allCaips:", invalidEntries);
+      console.error(tag6, "CRITICAL: Invalid entries detected in allCaips:", invalidEntries);
       throw new Error("Invalid CAIP entries detected - aborting market sync");
     }
     if (allCaips && allCaips.length > 0) {
@@ -4043,13 +4132,13 @@ async function syncMarket(balances, pioneer) {
           }
         }
       } catch (apiError) {
-        console.error(tag5, "API error fetching market info:", apiError);
-        console.warn(tag5, "Continuing without market prices");
+        console.error(tag6, "API error fetching market info:", apiError);
+        console.warn(tag6, "Continuing without market prices");
       }
     }
     return true;
   } catch (e) {
-    console.error(tag5, "e:", e);
+    console.error(tag6, "e:", e);
     throw e;
   }
 }
@@ -4219,7 +4308,7 @@ class SDK {
       return true;
     };
     this.setPubkeys = (newPubkeys) => {
-      const tag5 = `${TAG9} | setPubkeys | `;
+      const tag6 = `${TAG9} | setPubkeys | `;
       this.pubkeys = [];
       this.pubkeySet.clear();
       let added = 0;
@@ -4230,7 +4319,7 @@ class SDK {
       }
     };
     this.getUnifiedPortfolio = async function() {
-      const tag5 = `${TAG9} | getUnifiedPortfolio | `;
+      const tag6 = `${TAG9} | getUnifiedPortfolio | `;
       try {
         const startTime = performance.now();
         try {
@@ -4241,17 +4330,17 @@ class SDK {
             signal: AbortSignal.timeout(2000)
           });
           if (!portfolioResponse.ok) {
-            console.warn(tag5, "Portfolio endpoint returned", portfolioResponse.status);
+            console.warn(tag6, "Portfolio endpoint returned", portfolioResponse.status);
             return null;
           }
           const portfolioData = await portfolioResponse.json();
           const loadTime = performance.now() - startTime;
           if (!portfolioData.success) {
-            console.warn(tag5, "Portfolio API returned success=false");
+            console.warn(tag6, "Portfolio API returned success=false");
             return null;
           }
           if (portfolioData.totalValueUsd === 0 || !portfolioData.totalValueUsd) {
-            console.warn(tag5, "Portfolio value is $0.00 - may need device connection or sync");
+            console.warn(tag6, "Portfolio value is $0.00 - may need device connection or sync");
             return null;
           }
           let allBalances = [];
@@ -4326,19 +4415,19 @@ class SDK {
           };
         } catch (fetchError) {
           if (fetchError.name === "AbortError") {
-            console.log(tag5, "Unified portfolio request timed out (this is normal if vault not running)");
+            console.log(tag6, "Unified portfolio request timed out (this is normal if vault not running)");
           } else {
-            console.log(tag5, "Failed to fetch unified portfolio:", fetchError.message);
+            console.log(tag6, "Failed to fetch unified portfolio:", fetchError.message);
           }
           return null;
         }
       } catch (e) {
-        console.error(tag5, "Error:", e);
+        console.error(tag6, "Error:", e);
         return null;
       }
     };
     this.init = async function(walletsVerbose, setup) {
-      const tag5 = `${TAG9} | init | `;
+      const tag6 = `${TAG9} | init | `;
       try {
         if (!this.username)
           throw Error("username required!");
@@ -4421,7 +4510,7 @@ class SDK {
         }
         return this.pioneer;
       } catch (e) {
-        console.error(tag5, "e: ", e);
+        console.error(tag6, "e: ", e);
         throw e;
       }
     };
@@ -4432,7 +4521,7 @@ class SDK {
       return syncMarket(this.balances, this.pioneer);
     };
     this.sync = async function() {
-      const tag5 = `${TAG9} | sync | `;
+      const tag6 = `${TAG9} | sync | `;
       try {
         const matchesNetwork = (item, networkId) => {
           if (!item.networks || !Array.isArray(item.networks))
@@ -4484,16 +4573,16 @@ class SDK {
         let totalPortfolioValue = 0;
         const networksTemp = [];
         const uniqueBlockchains = [...new Set(this.blockchains)];
-        console.log(tag5, "uniqueBlockchains: ", uniqueBlockchains);
+        console.log(tag6, "uniqueBlockchains: ", uniqueBlockchains);
         for (const blockchain of uniqueBlockchains) {
           const filteredBalances = this.balances.filter((b2) => {
             const networkId = import_pioneer_caip7.caipToNetworkId(b2.caip);
             return networkId === blockchain || blockchain === "eip155:*" && networkId.startsWith("eip155:");
           });
-          console.log(tag5, `Filtering for blockchain: ${blockchain}`);
-          console.log(tag5, `Found ${filteredBalances.length} balances before deduplication`);
+          console.log(tag6, `Filtering for blockchain: ${blockchain}`);
+          console.log(tag6, `Found ${filteredBalances.length} balances before deduplication`);
           filteredBalances.forEach((balance, idx) => {
-            console.log(tag5, `Balance[${idx}]:`, {
+            console.log(tag6, `Balance[${idx}]:`, {
               caip: balance.caip,
               pubkey: balance.pubkey,
               balance: balance.balance,
@@ -4503,7 +4592,7 @@ class SDK {
           const balanceMap = new Map;
           const isBitcoin = blockchain.includes("bip122:000000000019d6689c085ae165831e93");
           if (isBitcoin) {
-            console.log(tag5, "Bitcoin network detected - checking for duplicate balances");
+            console.log(tag6, "Bitcoin network detected - checking for duplicate balances");
             const bitcoinByValue = new Map;
             filteredBalances.forEach((balance) => {
               const valueKey = `${balance.balance}_${balance.valueUsd}`;
@@ -4514,7 +4603,7 @@ class SDK {
             });
             for (const [valueKey, balances] of bitcoinByValue.entries()) {
               if (balances.length === 3 && parseFloat(balances[0].valueUsd || "0") > 0) {
-                console.log(tag5, "BITCOIN API BUG DETECTED: All 3 address types have same balance, keeping only xpub");
+                console.log(tag6, "BITCOIN API BUG DETECTED: All 3 address types have same balance, keeping only xpub");
                 const xpubBalance = balances.find((b2) => b2.pubkey?.startsWith("xpub")) || balances[0];
                 const key = `${xpubBalance.caip}_${xpubBalance.pubkey || "default"}`;
                 balanceMap.set(key, xpubBalance);
@@ -4534,13 +4623,13 @@ class SDK {
             });
           }
           const networkBalances = Array.from(balanceMap.values());
-          console.log(tag5, "networkBalances (deduplicated): ", networkBalances);
-          console.log(tag5, "networkBalances count: ", networkBalances.length);
+          console.log(tag6, "networkBalances (deduplicated): ", networkBalances);
+          console.log(tag6, "networkBalances count: ", networkBalances.length);
           const networkTotal = networkBalances.reduce((sum, balance, idx) => {
             const valueUsd = typeof balance.valueUsd === "string" ? parseFloat(balance.valueUsd) : balance.valueUsd || 0;
-            console.log(tag5, `[${idx}] valueUsd:`, balance.valueUsd, "→ parsed:", valueUsd, "| running sum:", sum + valueUsd);
+            console.log(tag6, `[${idx}] valueUsd:`, balance.valueUsd, "→ parsed:", valueUsd, "| running sum:", sum + valueUsd);
             if (blockchain.includes("bip122:000000000019d6689c085ae165831e93")) {
-              console.log(tag5, `[BITCOIN DEBUG ${idx}] pubkey:`, balance.pubkey?.substring(0, 10) + "...", "| balance:", balance.balance, "| valueUsd:", balance.valueUsd, "→ parsed:", valueUsd);
+              console.log(tag6, `[BITCOIN DEBUG ${idx}] pubkey:`, balance.pubkey?.substring(0, 10) + "...", "| balance:", balance.balance, "| valueUsd:", balance.valueUsd, "→ parsed:", valueUsd);
             }
             return sum + valueUsd;
           }, 0);
@@ -4571,7 +4660,7 @@ class SDK {
         this.dashboard = dashboardData;
         return true;
       } catch (e) {
-        console.error(tag5, "Error in sync:", e);
+        console.error(tag6, "Error in sync:", e);
         throw e;
       }
     };
@@ -4585,7 +4674,7 @@ class SDK {
       }
     };
     this.buildTx = async function(sendPayload) {
-      let tag5 = TAG9 + " | buildTx | ";
+      let tag6 = TAG9 + " | buildTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4599,7 +4688,7 @@ class SDK {
         };
         let txManager = new TransactionManager(transactionDependencies, this.events);
         let unsignedTx = await txManager.transfer(sendPayload);
-        console.log(tag5, "unsignedTx: ", unsignedTx);
+        console.log(tag6, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -4607,14 +4696,14 @@ class SDK {
       }
     };
     this.buildDelegateTx = async function(caip, params) {
-      let tag5 = TAG9 + " | buildDelegateTx | ";
+      let tag6 = TAG9 + " | buildDelegateTx | ";
       try {
         const delegateParams = {
           ...params,
           type: "delegate"
         };
         let unsignedTx = await createUnsignedStakingTx(caip, delegateParams, this.pubkeys, this.pioneer, this.pubkeyContext);
-        console.log(tag5, "unsignedTx: ", unsignedTx);
+        console.log(tag6, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -4622,14 +4711,14 @@ class SDK {
       }
     };
     this.buildUndelegateTx = async function(caip, params) {
-      let tag5 = TAG9 + " | buildUndelegateTx | ";
+      let tag6 = TAG9 + " | buildUndelegateTx | ";
       try {
         const undelegateParams = {
           ...params,
           type: "undelegate"
         };
         let unsignedTx = await createUnsignedStakingTx(caip, undelegateParams, this.pubkeys, this.pioneer, this.pubkeyContext);
-        console.log(tag5, "unsignedTx: ", unsignedTx);
+        console.log(tag6, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -4637,14 +4726,14 @@ class SDK {
       }
     };
     this.buildClaimRewardsTx = async function(caip, params) {
-      let tag5 = TAG9 + " | buildClaimRewardsTx | ";
+      let tag6 = TAG9 + " | buildClaimRewardsTx | ";
       try {
         const claimParams = {
           ...params,
           type: "claim_rewards"
         };
         let unsignedTx = await createUnsignedStakingTx(caip, claimParams, this.pubkeys, this.pioneer, this.pubkeyContext);
-        console.log(tag5, "unsignedTx: ", unsignedTx);
+        console.log(tag6, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -4652,7 +4741,7 @@ class SDK {
       }
     };
     this.buildClaimAllRewardsTx = async function(caip, params) {
-      let tag5 = TAG9 + " | buildClaimAllRewardsTx | ";
+      let tag6 = TAG9 + " | buildClaimAllRewardsTx | ";
       try {
         const claimAllParams = {
           ...params,
@@ -4665,8 +4754,8 @@ class SDK {
         throw e;
       }
     };
-    this.signTx = async function(unsignedTx) {
-      let tag5 = TAG9 + " | signTx | ";
+    this.signTx = async function(caip, unsignedTx) {
+      let tag6 = TAG9 + " | signTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4679,7 +4768,7 @@ class SDK {
           keepKeySdk: this.keepKeySdk
         };
         let txManager = new TransactionManager(transactionDependencies, this.events);
-        let signedTx = await txManager.sign(unsignedTx);
+        let signedTx = await txManager.sign({ caip, unsignedTx });
         return signedTx;
       } catch (e) {
         console.error(e);
@@ -4687,7 +4776,7 @@ class SDK {
       }
     };
     this.broadcastTx = async function(caip, signedTx) {
-      let tag5 = TAG9 + " | broadcastTx | ";
+      let tag6 = TAG9 + " | broadcastTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4711,7 +4800,7 @@ class SDK {
       }
     };
     this.swap = async function(swapPayload) {
-      let tag5 = `${TAG9} | swap | `;
+      let tag6 = `${TAG9} | swap | `;
       try {
         if (!swapPayload)
           throw Error("swapPayload required!");
@@ -4760,15 +4849,15 @@ class SDK {
             throw new Error(`Cannot use max amount: no balance found for ${swapPayload.caipIn}`);
           }
           let totalBalance = 0;
-          console.log(tag5, `Found ${inputBalances.length} balance entries for ${swapPayload.caipIn}`);
+          console.log(tag6, `Found ${inputBalances.length} balance entries for ${swapPayload.caipIn}`);
           for (const balanceEntry of inputBalances) {
             const balance = parseFloat(balanceEntry.balance) || 0;
             totalBalance += balance;
-            console.log(tag5, `  - ${balanceEntry.pubkey || balanceEntry.identifier}: ${balance}`);
+            console.log(tag6, `  - ${balanceEntry.pubkey || balanceEntry.identifier}: ${balance}`);
           }
           this.assetContext.balance = totalBalance.toString();
           this.assetContext.valueUsd = (totalBalance * parseFloat(this.assetContext.priceUsd || "0")).toFixed(2);
-          console.log(tag5, `Updated assetContext balance to aggregated total: ${totalBalance}`);
+          console.log(tag6, `Updated assetContext balance to aggregated total: ${totalBalance}`);
           const feeReserves = {
             "bip122:000000000019d6689c085ae165831e93/slip44:0": 0.00005,
             "eip155:1/slip44:60": 0.001,
@@ -4779,7 +4868,7 @@ class SDK {
           };
           const reserve = feeReserves[swapPayload.caipIn] || 0.0001;
           inputAmount = Math.max(0, totalBalance - reserve);
-          console.log(tag5, `Using max amount for swap: ${inputAmount} (total balance: ${totalBalance}, reserve: ${reserve})`);
+          console.log(tag6, `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) {
@@ -4787,23 +4876,23 @@ class SDK {
           }
         }
         let quote = {
-          affiliate: "0x658DE0443259a1027caA976ef9a42E6982037A03",
-          sellAsset: this.assetContext,
+          sellAsset: this.assetContext.caip,
           sellAmount: inputAmount.toPrecision(8),
-          buyAsset: this.outboundAssetContext,
+          buyAsset: this.outboundAssetContext.caip,
           recipientAddress,
           senderAddress,
-          slippage: "3"
+          slippage: swapPayload.slippagePercentage || 3
         };
         let result;
         try {
           result = await this.pioneer.Quote(quote);
           result = result.data;
         } catch (e) {
-          console.error(tag5, "Failed to get quote: ", e);
+          console.error(tag6, "Failed to get quote: ", e);
+          throw Error("Quote API failed for path: " + quote.sellAsset + " -> " + quote.buyAsset + ". Error: " + e);
         }
-        if (result.length === 0)
-          throw Error("No quotes available! path: " + quote.sellAsset.caip + " -> " + quote.buyAsset.caip);
+        if (!result || result.length === 0)
+          throw Error("No quotes available! path: " + quote.sellAsset + " -> " + quote.buyAsset);
         let selected = result[0];
         let txs = selected.quote.txs;
         if (!txs)
@@ -4816,6 +4905,7 @@ class SDK {
             balances: this.balances,
             pioneer: this.pioneer,
             pubkeys: this.pubkeys,
+            pubkeyContext: this.pubkeyContext,
             nodes: this.nodes,
             keepKeySdk: this.keepKeySdk
           };
@@ -4823,7 +4913,10 @@ class SDK {
           let caip = swapPayload.caipIn;
           let unsignedTx;
           if (tx.type === "deposit") {
-            unsignedTx = await createUnsignedTendermintTx(caip, tx.type, tx.txParams.amount, tx.txParams.memo, this.pubkeys, this.pioneer, this.keepKeySdk, false, undefined);
+            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");
+            unsignedTx = tx.txParams;
           } else {
             if (!tx.txParams.memo)
               throw Error("memo required on swaps!");
@@ -4841,12 +4934,12 @@ class SDK {
           return unsignedTx;
         }
       } catch (e) {
-        console.error(tag5, "Error: ", e);
+        console.error(tag6, "Error: ", e);
         throw e;
       }
     };
     this.transfer = async function(sendPayload) {
-      let tag5 = `${TAG9} | transfer | `;
+      let tag6 = `${TAG9} | transfer | `;
       try {
         if (!sendPayload)
           throw Error("sendPayload required!");
@@ -4880,15 +4973,15 @@ class SDK {
         return { txid, events: this.events };
       } catch (error) {
         if (error instanceof Error) {
-          console.error(tag5, "An error occurred during the transfer process:", error.message);
+          console.error(tag6, "An error occurred during the transfer process:", error.message);
         } else {
-          console.error(tag5, "An unknown error occurred during the transfer process");
+          console.error(tag6, "An unknown error occurred during the transfer process");
         }
         throw error;
       }
     };
     this.followTransaction = async function(caip, txid) {
-      let tag5 = " | followTransaction | ";
+      let tag6 = " | followTransaction | ";
       try {
         const finalConfirmationBlocksByCaip = {
           dogecoin: 3,
@@ -4918,7 +5011,7 @@ class SDK {
               }
             }
           } catch (error) {
-            console.error(tag5, "Error:", error);
+            console.error(tag6, "Error:", error);
           }
           if (!isConfirmed) {
             await new Promise((resolve) => setTimeout(resolve, 8000));
@@ -4936,18 +5029,18 @@ class SDK {
           requiredConfirmations
         };
       } catch (error) {
-        console.error(tag5, "Error:", error);
+        console.error(tag6, "Error:", error);
         throw new Error("Failed to follow transaction");
       }
     };
     this.setBlockchains = async function(blockchains) {
-      const tag5 = `${TAG9} | setBlockchains | `;
+      const tag6 = `${TAG9} | setBlockchains | `;
       try {
         if (!blockchains)
           throw Error("blockchains required!");
         const uniqueBlockchains = [...new Set(blockchains)];
         if (blockchains.length !== uniqueBlockchains.length) {
-          console.warn(tag5, `Removed ${blockchains.length - uniqueBlockchains.length} duplicate blockchains`);
+          console.warn(tag6, `Removed ${blockchains.length - uniqueBlockchains.length} duplicate blockchains`);
         }
         this.blockchains = uniqueBlockchains;
         this.events.emit("SET_BLOCKCHAINS", this.blockchains);
@@ -4957,7 +5050,7 @@ class SDK {
       }
     };
     this.addAsset = async function(caip, data) {
-      let tag5 = TAG9 + " | addAsset | ";
+      let tag6 = TAG9 + " | addAsset | ";
       try {
         let success = false;
         if (!caip)
@@ -4995,22 +5088,22 @@ class SDK {
       }
     };
     this.clearWalletState = async function() {
-      const tag5 = `${TAG9} | clearWalletState | `;
+      const tag6 = `${TAG9} | clearWalletState | `;
       try {
         this.context = null;
         this.paths = [];
         this.blockchains = [];
         this.pubkeys = [];
         this.pubkeySet.clear();
-        console.log(tag5, "Cleared wallet state including pubkeys and tracking set");
+        console.log(tag6, "Cleared wallet state including pubkeys and tracking set");
         return true;
       } catch (e) {
-        console.error(tag5, "e: ", e);
+        console.error(tag6, "e: ", e);
         throw e;
       }
     };
     this.addPath = async function(path) {
-      const tag5 = `${TAG9} | addPath | `;
+      const tag6 = `${TAG9} | addPath | `;
       try {
         this.paths.push(path);
         const pubkey = await getPubkey(path.networks[0], path, this.keepKeySdk, this.context);
@@ -5019,14 +5112,14 @@ class SDK {
         this.buildDashboardFromBalances();
         return { success: true, pubkey };
       } catch (e) {
-        console.error(tag5, "Failed:", e);
+        console.error(tag6, "Failed:", e);
         throw e;
       }
     };
     this.addPaths = async function(paths) {
-      const tag5 = `${TAG9} | addPaths | `;
+      const tag6 = `${TAG9} | addPaths | `;
       try {
-        console.log(tag5, `Adding ${paths.length} paths in batch mode...`);
+        console.log(tag6, `Adding ${paths.length} paths in batch mode...`);
         this.paths.push(...paths);
         const newPubkeys = [];
         for (const path of paths) {
@@ -5035,10 +5128,10 @@ class SDK {
             this.addPubkey(pubkey);
             newPubkeys.push(pubkey);
           } catch (error) {
-            console.warn(tag5, `Failed to get pubkey for path ${path.note}:`, error.message);
+            console.warn(tag6, `Failed to get pubkey for path ${path.note}:`, error.message);
           }
         }
-        console.log(tag5, `Successfully added ${newPubkeys.length} pubkeys`);
+        console.log(tag6, `Successfully added ${newPubkeys.length} pubkeys`);
         const networkSet = new Set;
         for (const path of paths) {
           if (path.networks && Array.isArray(path.networks)) {
@@ -5046,13 +5139,13 @@ class SDK {
           }
         }
         const uniqueNetworks = [...networkSet];
-        console.log(tag5, `Fetching balances for ${uniqueNetworks.length} unique networks in single API call...`);
+        console.log(tag6, `Fetching balances for ${uniqueNetworks.length} unique networks in single API call...`);
         await this.getBalancesForNetworks(uniqueNetworks);
         this.buildDashboardFromBalances();
-        console.log(tag5, `Batch add complete: ${paths.length} paths, ${newPubkeys.length} pubkeys, ${this.balances?.length || 0} balances`);
+        console.log(tag6, `Batch add complete: ${paths.length} paths, ${newPubkeys.length} pubkeys, ${this.balances?.length || 0} balances`);
         return { success: true, pubkeys: newPubkeys };
       } catch (e) {
-        console.error(tag5, "Failed:", e);
+        console.error(tag6, "Failed:", e);
         throw e;
       }
     };
@@ -5060,7 +5153,7 @@ class SDK {
       return this.getGasAssets();
     };
     this.getGasAssets = async function() {
-      const tag5 = `${TAG9} | getGasAssets | `;
+      const tag6 = `${TAG9} | getGasAssets | `;
       try {
         for (let i = 0;i < this.blockchains.length; i++) {
           let networkId = this.blockchains[i];
@@ -5094,7 +5187,7 @@ class SDK {
             denom: "maya"
           };
           this.assetsMap.set(mayaTokenCaip, mayaToken);
-          console.log(tag5, "Added MAYA token to assetsMap");
+          console.log(tag6, "Added MAYA token to assetsMap");
         }
         return this.assetsMap;
       } catch (e) {
@@ -5103,7 +5196,7 @@ class SDK {
       }
     };
     this.getPubkeys = async function() {
-      const tag5 = `${TAG9} | getPubkeys | `;
+      const tag6 = `${TAG9} | getPubkeys | `;
       try {
         if (this.paths.length === 0)
           throw new Error("No paths found!");
@@ -5119,15 +5212,15 @@ class SDK {
         return pubkeys;
       } catch (error) {
         console.error("Error in getPubkeys:", error);
-        console.error(tag5, "Error in getPubkeys:", error);
+        console.error(tag6, "Error in getPubkeys:", error);
         throw error;
       }
     };
     this.getBalancesForNetworks = async function(networkIds) {
-      const tag5 = `${TAG9} | getBalancesForNetworks | `;
+      const tag6 = `${TAG9} | getBalancesForNetworks | `;
       try {
         if (!this.pioneer) {
-          console.error(tag5, "ERROR: Pioneer client not initialized! this.pioneer is:", this.pioneer);
+          console.error(tag6, "ERROR: Pioneer client not initialized! this.pioneer is:", this.pioneer);
           throw new Error("Pioneer client not initialized. Call init() first.");
         }
         const assetQuery = [];
@@ -5165,48 +5258,48 @@ class SDK {
               identifier: `${balance.caip}:${balance.pubkey}`
             });
           }
-          console.log(tag5, "balances: ", balances);
+          console.log(tag6, "balances: ", balances);
           this.balances = balances;
           this.events.emit("SET_BALANCES", this.balances);
           return this.balances;
         } catch (apiError) {
-          console.error(tag5, "GetPortfolioBalances API call failed:", apiError);
+          console.error(tag6, "GetPortfolioBalances API call failed:", apiError);
           throw new Error(`GetPortfolioBalances API call failed: ${apiError?.message || "Unknown error"}`);
         }
       } catch (e) {
-        console.error(tag5, "Error: ", e);
+        console.error(tag6, "Error: ", e);
         throw e;
       }
     };
     this.getBalances = async function() {
-      const tag5 = `${TAG9} | getBalances | `;
+      const tag6 = `${TAG9} | getBalances | `;
       try {
         return await this.getBalancesForNetworks(this.blockchains);
       } catch (e) {
-        console.error(tag5, "Error in getBalances: ", e);
+        console.error(tag6, "Error in getBalances: ", e);
         throw e;
       }
     };
     this.getBalance = async function(networkId) {
-      const tag5 = `${TAG9} | getBalance | `;
+      const tag6 = `${TAG9} | getBalance | `;
       try {
         const results = await this.getBalancesForNetworks([networkId]);
         const filtered = results.filter(async (b2) => b2.networkId === await import_pioneer_caip7.networkIdToCaip(networkId));
         return filtered;
       } catch (e) {
-        console.error(tag5, "Error: ", e);
+        console.error(tag6, "Error: ", e);
         throw e;
       }
     };
     this.getFees = async function(networkId) {
-      const tag5 = `${TAG9} | getFees | `;
+      const tag6 = `${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(tag5, "Error getting fees: ", e);
+        console.error(tag6, "Error getting fees: ", e);
         throw e;
       }
     };
@@ -5214,11 +5307,11 @@ class SDK {
       return estimateTransactionFee(feeRate, unit, networkType, txSize);
     };
     this.getCharts = async function() {
-      const tag5 = `${TAG9} | getCharts | `;
+      const tag6 = `${TAG9} | getCharts | `;
       try {
-        console.log(tag5, "Fetching charts");
+        console.log(tag6, "Fetching charts");
         const newBalances = await getCharts(this.blockchains, this.pioneer, this.pubkeys, this.context);
-        console.log(tag5, "newBalances: ", newBalances);
+        console.log(tag6, "newBalances: ", newBalances);
         const uniqueBalances = new Map([...this.balances, ...newBalances].map((balance) => [
           balance.identifier,
           {
@@ -5226,17 +5319,17 @@ class SDK {
             type: balance.type || "balance"
           }
         ]));
-        console.log(tag5, "uniqueBalances: ", uniqueBalances);
+        console.log(tag6, "uniqueBalances: ", uniqueBalances);
         this.balances = Array.from(uniqueBalances.values());
-        console.log(tag5, "Updated this.balances: ", this.balances);
+        console.log(tag6, "Updated this.balances: ", this.balances);
         return this.balances;
       } catch (e) {
-        console.error(tag5, "Error in getCharts:", e);
+        console.error(tag6, "Error in getCharts:", e);
         throw e;
       }
     };
     this.setContext = async (context) => {
-      const tag5 = `${TAG9} | setContext | `;
+      const tag6 = `${TAG9} | setContext | `;
       try {
         if (!context)
           throw Error("context required!");
@@ -5244,12 +5337,12 @@ class SDK {
         this.events.emit("SET_CONTEXT", context);
         return { success: true };
       } catch (e) {
-        console.error(tag5, "e: ", e);
+        console.error(tag6, "e: ", e);
         return { success: false };
       }
     };
     this.setContextType = async (contextType) => {
-      const tag5 = `${TAG9} | setContextType | `;
+      const tag6 = `${TAG9} | setContextType | `;
       try {
         if (!contextType)
           throw Error("contextType required!");
@@ -5257,22 +5350,22 @@ class SDK {
         this.events.emit("SET_CONTEXT_TYPE", contextType);
         return { success: true };
       } catch (e) {
-        console.error(tag5, "e: ", e);
+        console.error(tag6, "e: ", e);
         return { success: false };
       }
     };
     this.refresh = async () => {
-      const tag5 = `${TAG9} | refresh | `;
+      const tag6 = `${TAG9} | refresh | `;
       try {
         await this.sync();
         return this.balances;
       } catch (e) {
-        console.error(tag5, "e: ", e);
+        console.error(tag6, "e: ", e);
         throw e;
       }
     };
     this.setAssetContext = async function(asset) {
-      const tag5 = `${TAG9} | setAssetContext | `;
+      const tag6 = `${TAG9} | setAssetContext | `;
       try {
         if (!asset) {
           this.assetContext = null;
@@ -5284,7 +5377,7 @@ class SDK {
           asset.networkId = import_pioneer_caip7.caipToNetworkId(asset.caip);
         if (!this.pubkeys || this.pubkeys.length === 0) {
           const errorMsg = `Cannot set asset context for ${asset.caip} - no pubkeys loaded. Please initialize wallet first.`;
-          console.error(tag5, errorMsg);
+          console.error(tag6, errorMsg);
           throw new Error(errorMsg);
         }
         const pubkeysForNetwork = this.pubkeys.filter((e) => {
@@ -5299,8 +5392,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(tag5, errorMsg);
-          console.error(tag5, "Available networks in pubkeys:", [
+          console.error(tag6, errorMsg);
+          console.error(tag6, "Available networks in pubkeys:", [
             ...new Set(this.pubkeys.flatMap((p2) => p2.networks || []))
           ]);
           throw new Error(errorMsg);
@@ -5310,43 +5403,43 @@ class SDK {
           const xpubFound = pubkeysForNetwork.some((p2) => p2.type === "xpub" && p2.pubkey);
           if (!xpubFound) {
             const errorMsg = `Cannot set asset context for UTXO chain ${asset.caip} - xpub required but not found`;
-            console.error(tag5, errorMsg);
+            console.error(tag6, errorMsg);
             throw new Error(errorMsg);
           }
         }
         const hasValidAddress = pubkeysForNetwork.some((p2) => p2.address || p2.master || p2.pubkey);
         if (!hasValidAddress) {
           const errorMsg = `Cannot set asset context for ${asset.caip} - no valid address found in pubkeys`;
-          console.error(tag5, errorMsg);
+          console.error(tag6, errorMsg);
           throw new Error(errorMsg);
         }
-        console.log(tag5, `✅ Validated: Found ${pubkeysForNetwork.length} addresses for ${asset.networkId}`);
+        console.log(tag6, `✅ Validated: Found ${pubkeysForNetwork.length} addresses for ${asset.networkId}`);
         let freshPriceUsd = 0;
         try {
           if (!asset.caip || typeof asset.caip !== "string" || !asset.caip.includes(":")) {
-            console.warn(tag5, "Invalid or missing CAIP, skipping market price fetch:", asset.caip);
+            console.warn(tag6, "Invalid or missing CAIP, skipping market price fetch:", asset.caip);
           } else {
-            console.log(tag5, "Fetching fresh market price for:", asset.caip);
+            console.log(tag6, "Fetching fresh market price for:", asset.caip);
             const marketData = await this.pioneer.GetMarketInfo([asset.caip]);
-            console.log(tag5, "Market data response:", marketData);
+            console.log(tag6, "Market data response:", marketData);
             if (marketData && marketData.data && marketData.data.length > 0) {
               freshPriceUsd = marketData.data[0];
-              console.log(tag5, "✅ Fresh market price:", freshPriceUsd);
+              console.log(tag6, "✅ Fresh market price:", freshPriceUsd);
             } else {
-              console.warn(tag5, "No market data returned for:", asset.caip);
+              console.warn(tag6, "No market data returned for:", asset.caip);
             }
           }
         } catch (marketError) {
-          console.error(tag5, "Error fetching market price:", marketError);
+          console.error(tag6, "Error fetching market price:", marketError);
         }
         let assetInfo = this.assetsMap.get(asset.caip.toLowerCase());
-        console.log(tag5, "assetInfo: ", assetInfo);
+        console.log(tag6, "assetInfo: ", assetInfo);
         let assetInfoDiscovery = import_pioneer_discovery2.assetData[asset.caip];
-        console.log(tag5, "assetInfoDiscovery: ", assetInfoDiscovery);
+        console.log(tag6, "assetInfoDiscovery: ", assetInfoDiscovery);
         if (assetInfoDiscovery)
           assetInfo = assetInfoDiscovery;
         if (!assetInfo) {
-          console.log(tag5, "Building placeholder asset!");
+          console.log(tag6, "Building placeholder asset!");
           assetInfo = {
             caip: asset.caip.toLowerCase(),
             networkId: asset.networkId,
@@ -5363,30 +5456,30 @@ class SDK {
             const valueUsd = parseFloat(matchingBalances[0].valueUsd);
             if (balance > 0 && valueUsd > 0) {
               priceValue = valueUsd / balance;
-              console.log(tag5, "calculated priceUsd from valueUsd/balance:", priceValue);
+              console.log(tag6, "calculated priceUsd from valueUsd/balance:", priceValue);
             }
           }
           if (priceValue && priceValue > 0) {
-            console.log(tag5, "detected priceUsd from balance:", priceValue);
+            console.log(tag6, "detected priceUsd from balance:", priceValue);
             assetInfo.priceUsd = priceValue;
           }
         }
         if (freshPriceUsd && freshPriceUsd > 0) {
           assetInfo.priceUsd = freshPriceUsd;
-          console.log(tag5, "✅ Using fresh market price:", freshPriceUsd);
+          console.log(tag6, "✅ Using fresh market price:", freshPriceUsd);
           let totalBalance = 0;
           let totalValueUsd = 0;
-          console.log(tag5, `Found ${matchingBalances.length} balance entries for ${asset.caip}`);
+          console.log(tag6, `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(tag5, `  Balance entry: ${balance} (${valueUsd} USD)`);
+            console.log(tag6, `  Balance entry: ${balance} (${valueUsd} USD)`);
           }
           assetInfo.balance = totalBalance.toString();
           assetInfo.valueUsd = totalValueUsd.toFixed(2);
-          console.log(tag5, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
+          console.log(tag6, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
         }
         const assetBalances = this.balances.filter((b2) => b2.caip === asset.caip);
         const assetPubkeys = this.pubkeys.filter((p2) => p2.networks && Array.isArray(p2.networks) && p2.networks.includes(import_pioneer_caip7.caipToNetworkId(asset.caip)) || import_pioneer_caip7.caipToNetworkId(asset.caip).includes("eip155") && p2.networks && Array.isArray(p2.networks) && p2.networks.some((n2) => n2.startsWith("eip155")));
@@ -5406,7 +5499,7 @@ class SDK {
             const balanceAmount = parseFloat(balance.balance || 0);
             balance.valueUsd = (balanceAmount * freshPriceUsd).toString();
           }
-          console.log(tag5, "Updated all balances with fresh price data");
+          console.log(tag6, "Updated all balances with fresh price data");
         }
         this.assetContext = finalAssetContext;
         if (asset.isToken || asset.type === "token" || assetInfo.isToken || assetInfo.type === "token") {
@@ -5458,20 +5551,20 @@ class SDK {
           const currentContextValid = this.pubkeyContext?.networks?.includes(networkId);
           if (!this.pubkeyContext || !currentContextValid) {
             this.pubkeyContext = assetPubkeys[0];
-            console.log(tag5, "Auto-set pubkey context for network:", this.pubkeyContext.address || this.pubkeyContext.pubkey);
+            console.log(tag6, "Auto-set pubkey context for network:", this.pubkeyContext.address || this.pubkeyContext.pubkey);
           } else {
-            console.log(tag5, "Preserving existing pubkey context for network:", this.pubkeyContext.address || this.pubkeyContext.pubkey, `(addressNList: [${(this.pubkeyContext.addressNList || this.pubkeyContext.addressNListMaster).join(", ")}])`);
+            console.log(tag6, "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(tag5, "e: ", e);
+        console.error(tag6, "e: ", e);
         throw e;
       }
     };
     this.setPubkeyContext = async function(pubkey) {
-      let tag5 = `${TAG9} | setPubkeyContext | `;
+      let tag6 = `${TAG9} | setPubkeyContext | `;
       try {
         if (!pubkey)
           throw Error("pubkey is required");
@@ -5479,31 +5572,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(tag5, "Pubkey not found in current pubkeys array");
+          console.warn(tag6, "Pubkey not found in current pubkeys array");
         }
         this.pubkeyContext = pubkey;
-        console.log(tag5, "Pubkey context set to:", pubkey.address || pubkey.pubkey, "note:", pubkey.note, "addressNList:", pubkey.addressNList || pubkey.addressNListMaster);
+        console.log(tag6, "Pubkey context set to:", pubkey.address || pubkey.pubkey, "note:", pubkey.note, "addressNList:", pubkey.addressNList || pubkey.addressNListMaster);
         return true;
       } catch (e) {
-        console.error(tag5, "e: ", e);
+        console.error(tag6, "e: ", e);
         throw e;
       }
     };
     this.setOutboundAssetContext = async function(asset) {
-      const tag5 = `${TAG9} | setOutputAssetContext | `;
+      const tag6 = `${TAG9} | setOutputAssetContext | `;
       try {
-        console.log(tag5, "0. asset: ", asset);
+        console.log(tag6, "0. asset: ", asset);
         if (!asset) {
           this.outboundAssetContext = null;
           return;
         }
-        console.log(tag5, "1 asset: ", asset);
+        console.log(tag6, "1 asset: ", asset);
         if (!asset.caip)
           throw Error("Invalid Asset! missing caip!");
         if (!asset.networkId)
           asset.networkId = import_pioneer_caip7.caipToNetworkId(asset.caip);
-        console.log(tag5, "networkId: ", asset.networkId);
-        console.log(tag5, "this.pubkeys: ", this.pubkeys);
+        console.log(tag6, "networkId: ", asset.networkId);
+        console.log(tag6, "this.pubkeys: ", this.pubkeys);
         const pubkey = this.pubkeys.find((p2) => {
           if (!p2.networks || !Array.isArray(p2.networks))
             return false;
@@ -5518,23 +5611,23 @@ class SDK {
         let freshPriceUsd = 0;
         try {
           if (!asset.caip || typeof asset.caip !== "string" || !asset.caip.includes(":")) {
-            console.warn(tag5, "Invalid or missing CAIP, skipping market price fetch:", asset.caip);
+            console.warn(tag6, "Invalid or missing CAIP, skipping market price fetch:", asset.caip);
           } else {
-            console.log(tag5, "Fetching fresh market price for:", asset.caip);
+            console.log(tag6, "Fetching fresh market price for:", asset.caip);
             const marketData = await this.pioneer.GetMarketInfo([asset.caip]);
-            console.log(tag5, "Market data response:", marketData);
+            console.log(tag6, "Market data response:", marketData);
             if (marketData && marketData.data && marketData.data.length > 0) {
               freshPriceUsd = marketData.data[0];
-              console.log(tag5, "✅ Fresh market price:", freshPriceUsd);
+              console.log(tag6, "✅ Fresh market price:", freshPriceUsd);
             } else {
-              console.warn(tag5, "No market data returned for:", asset.caip);
+              console.warn(tag6, "No market data returned for:", asset.caip);
             }
           }
         } catch (marketError) {
-          console.error(tag5, "Error fetching market price:", marketError);
+          console.error(tag6, "Error fetching market price:", marketError);
         }
         let assetInfo = this.assetsMap.get(asset.caip.toLowerCase());
-        console.log(tag5, "assetInfo: ", assetInfo);
+        console.log(tag6, "assetInfo: ", assetInfo);
         if (!assetInfo) {
           assetInfo = {
             caip: asset.caip.toLowerCase(),
@@ -5552,45 +5645,45 @@ class SDK {
             const valueUsd = parseFloat(matchingBalances[0].valueUsd);
             if (balance > 0 && valueUsd > 0) {
               priceValue = valueUsd / balance;
-              console.log(tag5, "calculated priceUsd from valueUsd/balance:", priceValue);
+              console.log(tag6, "calculated priceUsd from valueUsd/balance:", priceValue);
             }
           }
           if (priceValue && priceValue > 0) {
-            console.log(tag5, "detected priceUsd from balance:", priceValue);
+            console.log(tag6, "detected priceUsd from balance:", priceValue);
             assetInfo.priceUsd = priceValue;
           }
         }
         if (freshPriceUsd && freshPriceUsd > 0) {
           assetInfo.priceUsd = freshPriceUsd;
-          console.log(tag5, "✅ Using fresh market price:", freshPriceUsd);
+          console.log(tag6, "✅ Using fresh market price:", freshPriceUsd);
           let totalBalance = 0;
           let totalValueUsd = 0;
-          console.log(tag5, `Found ${matchingBalances.length} balance entries for ${asset.caip}`);
+          console.log(tag6, `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(tag5, `  Balance entry: ${balance} (${valueUsd} USD)`);
+            console.log(tag6, `  Balance entry: ${balance} (${valueUsd} USD)`);
           }
           assetInfo.balance = totalBalance.toString();
           assetInfo.valueUsd = totalValueUsd.toFixed(2);
-          console.log(tag5, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
+          console.log(tag6, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
         }
-        console.log(tag5, "CHECKPOINT 1");
+        console.log(tag6, "CHECKPOINT 1");
         this.outboundAssetContext = { ...assetInfo, ...asset, ...pubkey };
-        console.log(tag5, "CHECKPOINT 3");
-        console.log(tag5, "outboundAssetContext: assetInfo: ", assetInfo);
+        console.log(tag6, "CHECKPOINT 3");
+        console.log(tag6, "outboundAssetContext: assetInfo: ", assetInfo);
         if (asset.caip) {
           this.outboundBlockchainContext = import_pioneer_caip7.caipToNetworkId(asset.caip);
         } else if (asset.networkId) {
           this.outboundBlockchainContext = asset.networkId;
         }
-        console.log(tag5, "CHECKPOINT 4");
+        console.log(tag6, "CHECKPOINT 4");
         this.events.emit("SET_OUTBOUND_ASSET_CONTEXT", this.outboundAssetContext);
         return this.outboundAssetContext;
       } catch (e) {
-        console.error(tag5, "e: ", e);
+        console.error(tag6, "e: ", e);
         throw e;
       }
     };