@pioneer-platform/pioneer-sdk 8.15.14 → 8.15.16

package/dist/index.cjs

@@ -41,6 +41,117 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// ../../support/loggerdog/lib/index.js
+var require_lib = __commonJS((exports2, module2) => {
+  var __spreadArray = exports2 && exports2.__spreadArray || function(to, from, pack) {
+    if (pack || arguments.length === 2)
+      for (var i = 0, l = from.length, ar;i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar)
+            ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+    return to.concat(ar || Array.prototype.slice.call(from));
+  };
+  var LOG_LEVELS = {
+    TEST: { val: 0, label: "TEST", color: "color: cyan" },
+    EMERG: { val: 0, label: "EMERG", color: "color: magenta" },
+    ALERT: { val: 1, label: "ALERT", color: "color: magenta" },
+    CRIT: { val: 2, label: "CRIT", color: "color: red" },
+    ERROR: { val: 3, label: "ERROR", color: "color: red" },
+    WARN: { val: 4, label: "WARN", color: "color: orange" },
+    NOTICE: { val: 5, label: "NOTICE", color: "color: yellow" },
+    VERBOSE: { val: 6, label: "VERBOSE", color: "color: cyan" },
+    INFO: { val: 6, label: "INFO", color: "color: cyan" },
+    DEBUG: { val: 7, label: "DEBUG", color: "color: green" },
+    DEBUGV: { val: 8, label: "DEBUG", color: "color: green" },
+    DEBUGVV: { val: 9, label: "DEBUG", color: "color: green" }
+  };
+  var DEFAULT_LOG_LEVEL = typeof process !== "undefined" ? process.env["DEFAULT_LOG_LEVEL"] || "INFO" : "INFO";
+  function _extractContext(stack, depth) {
+    try {
+      var arr = stack.split(`
+`);
+      var chunks = arr[depth].split("/");
+      var business = chunks[chunks.length - 1];
+      var matches = business.match(/^([^:]+):(\d+):(\d+)/i) || "";
+      var filename = matches[1];
+      var line = matches[2];
+      var pos = matches[3];
+      return { filename, line, pos };
+    } catch (ex) {
+      return { filename: "unknown" };
+    }
+  }
+  function _getContextString() {
+    var stack = new Error().stack || "";
+    var _a = _extractContext(stack, 3), filename = _a.filename, line = _a.line, pos = _a.pos;
+    return "[".concat(filename, ":").concat(line, ":").concat(pos, "]");
+  }
+  var Logger = function() {
+    function Logger2() {
+      var stack = new Error().stack || "";
+      var ctx = _extractContext(stack, 3);
+      this._tag = ctx.filename || "";
+      for (var lvl in LOG_LEVELS) {
+        this[lvl.toLowerCase()] = this._log.bind(this, lvl);
+      }
+      this._setLogLevel();
+    }
+    Logger2.prototype._setLogLevel = function() {
+      var tag = this._tag.split(".")[0];
+      tag = tag.toUpperCase().replace("-", "_");
+      var level = typeof process !== "undefined" ? process.env["LOG_LEVEL_" + tag] || null : null;
+      if (level && LOG_LEVELS[level] !== undefined) {
+        this._level = LOG_LEVELS[level].val;
+      } else {
+        this._level = LOG_LEVELS[DEFAULT_LOG_LEVEL].val;
+      }
+    };
+    Logger2.prototype._log = function(level) {
+      var args = [];
+      for (var _i = 1;_i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+      }
+      if (this._level >= LOG_LEVELS[level].val) {
+        var dt = new Date().toISOString().replace("T", " ");
+        var ctx = _getContextString();
+        var label = LOG_LEVELS[level].label;
+        var color = LOG_LEVELS[level].color;
+        var message = undefined;
+        if (typeof process !== "undefined" && process.env["STRUCTURED_LOGGING"]) {
+          message = {};
+          var tag = args[0];
+          var param = args[1];
+          var value = args[2];
+          if (typeof args === "object") {
+            message.loggerdog = true;
+            message.label = label;
+            message.param = param;
+            message.value = value;
+            message.ctx = ctx;
+            message.dt = dt;
+            message.tag = tag.toString();
+            message.raw = args.toString();
+          } else {
+            message.raw = args;
+          }
+          console.log("%c " + dt, color, label, ctx, message);
+        } else {
+          console.log.apply(console, __spreadArray(["%c " + dt, color, label, ctx], args, false));
+        }
+      }
+    };
+    return Logger2;
+  }();
+  var getLogger = function() {
+    return new Logger;
+  };
+  exports2.default = getLogger;
+  module2.exports = getLogger;
+});
+
 // ../../../node_modules/coinselect/utils.js
 var require_utils = __commonJS((exports2, module2) => {
   var TX_EMPTY_SIZE = 4 + 1 + 1 + 4;
@@ -798,7 +909,7 @@ var import_pioneer_caip8 = require("@pioneer-platform/pioneer-caip");
 
 // ../pioneer-client/lib/index.js
 var import_swagger_client = __toESM(require("swagger-client"));
-var import_loggerdog = __toESM(require("@pioneer-platform/loggerdog"));
+var import_loggerdog = __toESM(require_lib());
 var log = typeof window === "undefined" ? import_loggerdog.default() : {
   debug: (...args) => console.debug(...args),
   info: (...args) => console.info(...args),
@@ -944,11 +1055,30 @@ class Pioneer {
 }
 
 // src/index.ts
-var import_pioneer_coins4 = require("@pioneer-platform/pioneer-coins");
+var import_pioneer_coins6 = require("@pioneer-platform/pioneer-coins");
 var import_pioneer_discovery2 = require("@pioneer-platform/pioneer-discovery");
 var import_pioneer_events = require("@pioneer-platform/pioneer-events");
 var import_events = __toESM(require("events"));
 
+// src/utils/logger.ts
+var DEBUG = process.env.DEBUG === "true" || typeof window !== "undefined" && window.DEBUG;
+var logger = {
+  info: (tag, ...args) => {
+    console.log(`[INFO] ${tag}`, ...args);
+  },
+  debug: (tag, ...args) => {
+    if (DEBUG) {
+      console.log(`[DEBUG] ${tag}`, ...args);
+    }
+  },
+  warn: (tag, ...args) => {
+    console.warn(`[WARN] ${tag}`, ...args);
+  },
+  error: (tag, ...args) => {
+    console.error(`[ERROR] ${tag}`, ...args);
+  }
+};
+
 // src/getPubkey.ts
 var import_pioneer_caip = require("@pioneer-platform/pioneer-caip");
 var import_pioneer_coins = require("@pioneer-platform/pioneer-coins");
@@ -3983,25 +4113,400 @@ async function syncMarket(balances, pioneer) {
   }
 }
 
-// src/index.ts
-var TAG9 = " | Pioneer-sdk | ";
-var ASSET_COLORS = {
-  "bip122:000000000019d6689c085ae165831e93/slip44:0": "#FF9800",
-  "eip155:1/slip44:60": "#627EEA",
-  "eip155:137/slip44:60": "#8247E5",
-  "eip155:8453/slip44:60": "#0052FF",
-  "eip155:56/slip44:60": "#F3BA2F",
-  "bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2": "#BFBBBB",
-  "bip122:00000000001a91e3dace36e2be3bf030/slip44:3": "#C2A633",
-  "bip122:000000000000000000651ef99cb9fcbe/slip44:145": "#8DC351",
-  "bip122:000007d91d1254d60e2dd1ae58038307/slip44:5": "#008CE7",
-  "bip122:4da631f2ac1bed857bd968c67c913978/slip44:20": "#006AD2",
-  "cosmos:cosmoshub-4/slip44:118": "#2E3148",
-  "cosmos:osmosis-1/slip44:118": "#9B1FD7",
-  "ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144": "#23292F",
-  "cosmos:mayachain-mainnet-v1/slip44:931": "#00D4AA",
-  "cosmos:thorchain-mainnet-v1/slip44:931": "#00CCFF"
+// src/utils/pubkey-management.ts
+function getPubkeyKey(pubkey) {
+  return `${pubkey.pubkey}_${pubkey.pathMaster}`;
+}
+function deduplicatePubkeys(pubkeys) {
+  const seen = new Set;
+  return pubkeys.filter((pubkey) => {
+    const key = getPubkeyKey(pubkey);
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
+function validatePubkey(pubkey) {
+  return !!(pubkey.pubkey && pubkey.pathMaster);
+}
+function findPubkeysForNetwork(pubkeys, networkId) {
+  return pubkeys.filter((p) => {
+    if (!p.networks || !Array.isArray(p.networks))
+      return false;
+    if (p.networks.includes(networkId))
+      return true;
+    if (networkId.startsWith("eip155:") && p.networks.includes("eip155:*")) {
+      return true;
+    }
+    return false;
+  });
+}
+function findPubkeyForNetwork(pubkeys, networkId) {
+  return pubkeys.find((p) => {
+    if (!p.networks || !Array.isArray(p.networks))
+      return false;
+    if (p.networks.includes(networkId))
+      return true;
+    if (networkId.startsWith("eip155:") && p.networks.includes("eip155:*"))
+      return true;
+    return false;
+  });
+}
+function validatePubkeysForNetwork(pubkeys, networkId, caip) {
+  if (!pubkeys || pubkeys.length === 0) {
+    throw new Error(`Cannot set asset context for ${caip} - no pubkeys loaded. Please initialize wallet first.`);
+  }
+  const pubkeysForNetwork = findPubkeysForNetwork(pubkeys, networkId);
+  if (pubkeysForNetwork.length === 0) {
+    const availableNetworks = [...new Set(pubkeys.flatMap((p) => p.networks || []))];
+    throw new Error(`Cannot set asset context for ${caip} - no address/xpub found for network ${networkId}. Available networks: ${availableNetworks.join(", ")}`);
+  }
+  const isUtxoChain = networkId.startsWith("bip122:");
+  if (isUtxoChain) {
+    const xpubFound = pubkeysForNetwork.some((p) => p.type === "xpub" && p.pubkey);
+    if (!xpubFound) {
+      throw new Error(`Cannot set asset context for UTXO chain ${caip} - xpub required but not found`);
+    }
+  }
+  const hasValidAddress = pubkeysForNetwork.some((p) => p.address || p.master || p.pubkey);
+  if (!hasValidAddress) {
+    throw new Error(`Cannot set asset context for ${caip} - no valid address found in pubkeys`);
+  }
+}
+function filterPubkeysForAsset(pubkeys, caip, caipToNetworkId7) {
+  const networkId = caipToNetworkId7(caip);
+  return pubkeys.filter((p) => {
+    if (!p.networks || !Array.isArray(p.networks))
+      return false;
+    if (p.networks.includes(networkId))
+      return true;
+    if (networkId.includes("eip155") && p.networks.some((n) => n.startsWith("eip155"))) {
+      return true;
+    }
+    return false;
+  });
+}
+
+// src/utils/portfolio-helpers.ts
+var TAG9 = " | portfolio-helpers | ";
+function isCacheDataValid(portfolioData) {
+  if (!portfolioData.networks || !Array.isArray(portfolioData.networks)) {
+    console.warn("[CACHE VALIDATION] Networks is not an array");
+    return false;
+  }
+  if (portfolioData.networks.length > 50) {
+    console.error(`[CACHE VALIDATION] CORRUPTED: ${portfolioData.networks.length} networks (should be < 50)`);
+    return false;
+  }
+  const validNetworks = portfolioData.networks.filter((n) => n.networkId && n.totalValueUsd !== undefined && n.gasAssetSymbol);
+  if (validNetworks.length === 0 && portfolioData.networks.length > 0) {
+    console.error("[CACHE VALIDATION] CORRUPTED: No networks have required fields");
+    return false;
+  }
+  console.log(`[CACHE VALIDATION] Found ${portfolioData.networks.length} networks, ${validNetworks.length} valid`);
+  return true;
+}
+async function fetchMarketPrice(pioneer, caip) {
+  const tag = TAG9 + " | fetchMarketPrice | ";
+  try {
+    if (!caip || typeof caip !== "string" || !caip.includes(":")) {
+      logger.warn(tag, "Invalid or missing CAIP, skipping market price fetch:", caip);
+      return 0;
+    }
+    logger.debug(tag, "Fetching fresh market price for:", caip);
+    const marketData = await pioneer.GetMarketInfo([caip]);
+    logger.debug(tag, "Market data response:", marketData);
+    if (marketData && marketData.data && marketData.data.length > 0) {
+      const price = marketData.data[0];
+      logger.debug(tag, "✅ Fresh market price:", price);
+      return price;
+    } else {
+      logger.warn(tag, "No market data returned for:", caip);
+      return 0;
+    }
+  } catch (marketError) {
+    logger.error(tag, "Error fetching market price:", marketError);
+    return 0;
+  }
+}
+function extractPriceFromBalances(balances) {
+  const tag = TAG9 + " | extractPriceFromBalances | ";
+  if (balances.length === 0)
+    return 0;
+  let priceValue = balances[0].priceUsd || balances[0].price;
+  if ((!priceValue || priceValue === 0) && balances[0].valueUsd && balances[0].balance) {
+    const balance = parseFloat(balances[0].balance);
+    const valueUsd = parseFloat(balances[0].valueUsd);
+    if (balance > 0 && valueUsd > 0) {
+      priceValue = valueUsd / balance;
+      logger.debug(tag, "Calculated priceUsd from valueUsd/balance:", priceValue);
+    }
+  }
+  return priceValue || 0;
+}
+function aggregateBalances(balances, caip) {
+  const tag = TAG9 + " | aggregateBalances | ";
+  let totalBalance = 0;
+  let totalValueUsd = 0;
+  logger.debug(tag, `Aggregating ${balances.length} balance entries for ${caip}`);
+  for (const balanceEntry of balances) {
+    const balance = parseFloat(balanceEntry.balance) || 0;
+    const valueUsd = parseFloat(balanceEntry.valueUsd) || 0;
+    totalBalance += balance;
+    totalValueUsd += valueUsd;
+    logger.debug(tag, `  Balance entry: ${balance} (${valueUsd} USD)`);
+  }
+  logger.debug(tag, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
+  return { totalBalance, totalValueUsd };
+}
+function updateBalancesWithPrice(balances, freshPriceUsd) {
+  const tag = TAG9 + " | updateBalancesWithPrice | ";
+  for (const balance of balances) {
+    balance.price = freshPriceUsd;
+    balance.priceUsd = freshPriceUsd;
+    const balanceAmount = parseFloat(balance.balance || 0);
+    balance.valueUsd = (balanceAmount * freshPriceUsd).toString();
+  }
+  logger.debug(tag, "Updated all balances with fresh price data");
+}
+function buildDashboardFromPortfolioData(portfolioData) {
+  const cacheAge = portfolioData.lastUpdated ? Math.floor((Date.now() - portfolioData.lastUpdated) / 1000) : 0;
+  return {
+    totalValueUsd: portfolioData.totalValueUsd,
+    pairedDevices: portfolioData.pairedDevices,
+    devices: portfolioData.devices || [],
+    networks: portfolioData.networks || [],
+    assets: portfolioData.assets || [],
+    statistics: portfolioData.statistics || {},
+    cached: portfolioData.cached,
+    lastUpdated: portfolioData.lastUpdated,
+    cacheAge,
+    networkPercentages: portfolioData.networks?.map((network) => ({
+      networkId: network.network_id || network.networkId,
+      percentage: network.percentage || 0
+    })) || []
+  };
+}
+function buildAssetQuery(pubkeys, caip) {
+  return pubkeys.map((pubkey) => ({ caip, pubkey: pubkey.pubkey }));
+}
+function logQueryDiagnostics(assetQuery, tag = "") {
+  const caipCounts = new Map;
+  for (const query of assetQuery) {
+    caipCounts.set(query.caip, (caipCounts.get(query.caip) || 0) + 1);
+  }
+  if (tag) {
+    console.log(tag, "Built assetQuery with", assetQuery.length, "entries");
+    console.log(tag, "Sample queries:", assetQuery.slice(0, 5));
+    console.log(tag, "Queries by chain:");
+    caipCounts.forEach((count, caip) => {
+      console.log(`   - ${caip}: ${count} queries`);
+    });
+  }
+}
+function enrichBalancesWithAssetInfo(balances, assetsMap, caipToNetworkId7) {
+  const tag = TAG9 + " | enrichBalancesWithAssetInfo | ";
+  for (const balance of balances) {
+    const assetInfo = assetsMap.get(balance.caip.toLowerCase()) || assetsMap.get(balance.caip);
+    if (!assetInfo) {
+      throw new Error(`Missing AssetInfo for ${balance.caip}`);
+    }
+    Object.assign(balance, assetInfo, {
+      type: balance.type || assetInfo.type,
+      isNative: balance.isNative ?? assetInfo.isNative,
+      networkId: caipToNetworkId7(balance.caip),
+      icon: assetInfo.icon || "https://pioneers.dev/coins/etherum.png",
+      identifier: `${balance.caip}:${balance.pubkey}`,
+      updated: Date.now(),
+      color: assetInfo.color
+    });
+  }
+  return balances;
+}
+
+// src/utils/sync-state.ts
+var TAG10 = " | sync-state | ";
+function resolveAssetInfo(assetsMap, assetData, asset) {
+  const tag = TAG10 + " | resolveAssetInfo | ";
+  let assetInfo = assetsMap.get(asset.caip.toLowerCase());
+  logger.debug(tag, "assetInfo from assetsMap:", assetInfo);
+  const assetInfoDiscovery = assetData[asset.caip];
+  logger.debug(tag, "assetInfoDiscovery:", assetInfoDiscovery);
+  if (assetInfoDiscovery) {
+    assetInfo = assetInfoDiscovery;
+  }
+  if (!assetInfo) {
+    logger.debug(tag, "Building placeholder asset for", asset.caip);
+    assetInfo = {
+      caip: asset.caip.toLowerCase(),
+      networkId: asset.networkId,
+      symbol: asset.symbol || "UNKNOWN",
+      name: asset.name || "Unknown Asset",
+      icon: asset.icon || "https://pioneers.dev/coins/ethereum.png"
+    };
+  }
+  return assetInfo;
+}
+function createInitialSyncState(totalChains) {
+  return {
+    isSynced: false,
+    isInitialSync: true,
+    cacheAge: 0,
+    syncProgress: 0,
+    syncedChains: 0,
+    totalChains,
+    lastSyncTime: null,
+    syncSource: "none"
+  };
+}
+function createCacheSyncState(lastUpdated, totalChains) {
+  const cacheAge = lastUpdated ? Math.floor((Date.now() - lastUpdated) / 1000) : 0;
+  return {
+    isSynced: true,
+    isInitialSync: false,
+    cacheAge,
+    syncProgress: 100,
+    syncedChains: totalChains,
+    totalChains,
+    lastSyncTime: lastUpdated || Date.now(),
+    syncSource: "cache"
+  };
+}
+function createFreshSyncState(totalChains) {
+  return {
+    isSynced: true,
+    isInitialSync: false,
+    cacheAge: 0,
+    syncProgress: 100,
+    syncedChains: totalChains,
+    totalChains,
+    lastSyncTime: Date.now(),
+    syncSource: "fresh"
+  };
+}
+
+// src/utils/fee-reserves.ts
+var TAG11 = " | Pioneer-sdk | fee-reserves | ";
+var FEE_RESERVE_MAP = {
+  "bip122:000000000019d6689c085ae165831e93/slip44:0": 0.00005,
+  "eip155:1/slip44:60": 0.001,
+  "cosmos:thorchain-mainnet-v1/slip44:931": 0.02,
+  "bip122:00000000001a91e3dace36e2be3bf030/slip44:3": 1,
+  "bip122:000007d91d1254d60e2dd1ae58038307/slip44:5": 0.001,
+  "bip122:000000000000000000651ef99cb9fcbe/slip44:145": 0.0005,
+  "bip122:12a765e31ffd4059bada1e25190f6e98/slip44:2": 0.001,
+  "bip122:4da631f2ac1bed857bd968c67c913978/slip44:20": 0.1,
+  "cosmos:cosmoshub-4/slip44:118": 0.005,
+  "cosmos:osmosis-1/slip44:118": 0.035,
+  "cosmos:mayachain-mainnet-v1/slip44:931": 0.5,
+  "eip155:56/slip44:60": 0.001,
+  "eip155:137/slip44:60": 0.01,
+  "eip155:43114/slip44:60": 0.01,
+  "eip155:10/slip44:60": 0.0001,
+  "eip155:8453/slip44:60": 0.0001,
+  "eip155:42161/slip44:60": 0.0001,
+  "ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144": 0.00001
 };
+var DEFAULT_FEE_RESERVE = 0.001;
+function getFeeReserve(caip) {
+  if (FEE_RESERVE_MAP[caip]) {
+    return FEE_RESERVE_MAP[caip];
+  }
+  if (caip.startsWith("eip155:") && caip.includes("/slip44:60")) {
+    return FEE_RESERVE_MAP["eip155:1/slip44:60"] || 0.001;
+  }
+  if (caip.startsWith("cosmos:")) {
+    return 0.01;
+  }
+  if (caip.startsWith("bip122:")) {
+    return 0.0001;
+  }
+  console.warn(TAG11, `No fee reserve defined for ${caip}, using default: ${DEFAULT_FEE_RESERVE}`);
+  return DEFAULT_FEE_RESERVE;
+}
+function getMaxSendableAmount(balance, caip) {
+  const reserve = getFeeReserve(caip);
+  const maxAmount = Math.max(0, balance - reserve);
+  console.log(TAG11, `Max sendable for ${caip}: ${maxAmount} (balance: ${balance}, reserve: ${reserve})`);
+  return maxAmount;
+}
+
+// src/utils/network-helpers.ts
+function matchesNetwork(item, networkId) {
+  if (!item.networks || !Array.isArray(item.networks))
+    return false;
+  if (item.networks.includes(networkId))
+    return true;
+  if (networkId.startsWith("eip155:") && item.networks.includes("eip155:*"))
+    return true;
+  return false;
+}
+function normalizeNetworkId(networkId) {
+  return networkId.includes("eip155:") ? "eip155:*" : networkId;
+}
+function validatePubkeysNetworks(pubkeys, tag = "") {
+  const valid = pubkeys.filter((p) => p.networks && Array.isArray(p.networks));
+  const invalid = pubkeys.filter((p) => !p.networks || !Array.isArray(p.networks));
+  if (tag && invalid.length > 0) {
+    console.warn(tag, `⚠️ ${invalid.length} pubkeys missing networks field`);
+    invalid.forEach((pk) => {
+      console.warn(tag, `  - ${pk.note || pk.pubkey.slice(0, 10)}: networks=${pk.networks}`);
+    });
+  }
+  return { valid, invalid };
+}
+
+// src/utils/path-discovery.ts
+var import_pioneer_coins4 = require("@pioneer-platform/pioneer-coins");
+async function ensurePathsForBlockchains(blockchains, currentPaths, tag) {
+  let allPaths = [...currentPaths];
+  for (const blockchain of blockchains) {
+    const networkId = normalizeNetworkId(blockchain);
+    const existingPaths = allPaths.filter((path) => matchesNetwork(path, networkId));
+    if (existingPaths.length === 0) {
+      logger.info(tag, `Discovering paths for ${networkId}...`);
+      const newPaths = import_pioneer_coins4.getPaths([networkId]);
+      if (!newPaths || newPaths.length === 0) {
+        throw new Error(`Path discovery failed for ${networkId}. ` + `Available blockchains: ${blockchains.join(", ")}`);
+      }
+      logger.debug(tag, `Added ${newPaths.length} paths for ${networkId}`);
+      allPaths = allPaths.concat(newPaths);
+    }
+  }
+  return allPaths;
+}
+
+// src/utils/pubkey-sync.ts
+var import_pioneer_coins5 = require("@pioneer-platform/pioneer-coins");
+async function syncPubkeysForBlockchains(blockchains, paths, existingPubkeys, keepKeySdk, context, getPubkeyFn, addPubkeyCallback, tag) {
+  for (const blockchain of blockchains) {
+    const networkId = normalizeNetworkId(blockchain);
+    const pathsForChain = paths.filter((path) => matchesNetwork(path, networkId));
+    if (pathsForChain.length === 0) {
+      const availablePaths = paths.map((p) => p.note || p.path || "unnamed").join(", ");
+      throw new Error(`No paths found for ${networkId}. ` + `Available paths: ${availablePaths || "none"}`);
+    }
+    logger.info(tag, `Syncing ${pathsForChain.length} pubkeys for ${networkId}...`);
+    for (const path of pathsForChain) {
+      const pathBip32 = import_pioneer_coins5.addressNListToBIP32(path.addressNListMaster);
+      const existingPubkey = existingPubkeys.find((p) => p.pathMaster === pathBip32);
+      if (!existingPubkey) {
+        logger.debug(tag, `Fetching pubkey for path ${pathBip32}...`);
+        const newPubkey = await getPubkeyFn(blockchain, path, keepKeySdk, context);
+        if (!newPubkey) {
+          throw new Error(`Pubkey fetch failed for ${networkId} at path ${pathBip32}. ` + `Ensure hardware wallet is connected and unlocked.`);
+        }
+        addPubkeyCallback(newPubkey);
+        logger.debug(tag, `✓ Added pubkey for ${pathBip32}`);
+      }
+    }
+  }
+  logger.info(tag, `✅ Pubkey sync complete. Total pubkeys: ${existingPubkeys.length}`);
+}
+
+// src/index.ts
+var TAG12 = " | Pioneer-sdk | ";
 
 class SDK {
   status;
@@ -4059,7 +4564,6 @@ class SDK {
   init;
   getUnifiedPortfolio;
   offlineClient;
-  convertVaultPubkeysToPioneerFormat;
   app;
   addAsset;
   getAssets;
@@ -4132,23 +4636,14 @@ class SDK {
     this.utxoApiKey = config.utxoApiKey;
     this.walletConnectProjectId = config.walletConnectProjectId;
     this.contextType = "";
-    this.syncState = {
-      isSynced: false,
-      isInitialSync: true,
-      cacheAge: 0,
-      syncProgress: 0,
-      syncedChains: 0,
-      totalChains: this.blockchains.length,
-      lastSyncTime: null,
-      syncSource: "none"
-    };
+    this.syncState = createInitialSyncState(this.blockchains.length);
     this.offlineClient = config.offlineFirst ? new OfflineClient({
       vaultUrl: config.vaultUrl || "kkapi://",
       timeout: 1000,
       fallbackToRemote: true
     }) : null;
     this.pairWallet = async (options) => {
-      const tag6 = TAG9 + " | pairWallet | ";
+      const tag6 = TAG12 + " | pairWallet | ";
       if (this.viewOnlyMode || this.skipDevicePairing) {
         console.log(tag6, "\uD83D\uDC41️ [VIEW-ONLY] Skipping device pairing");
         return {
@@ -4163,35 +4658,20 @@ class SDK {
         message: "Device pairing not yet implemented"
       });
     };
-    this.getPubkeyKey = (pubkey) => {
-      return `${pubkey.pubkey}_${pubkey.pathMaster}`;
-    };
-    this.deduplicatePubkeys = (pubkeys) => {
-      const seen = new Set;
-      const deduped = pubkeys.filter((pubkey) => {
-        const key = this.getPubkeyKey(pubkey);
-        if (seen.has(key)) {
-          return false;
-        }
-        seen.add(key);
-        return true;
-      });
-      return deduped;
-    };
+    this.getPubkeyKey = getPubkeyKey;
+    this.deduplicatePubkeys = deduplicatePubkeys;
     this.addPubkey = (pubkey) => {
-      if (!pubkey.pubkey || !pubkey.pathMaster) {
+      if (!validatePubkey(pubkey))
         return false;
-      }
-      const key = this.getPubkeyKey(pubkey);
-      if (this.pubkeySet.has(key)) {
+      const key = getPubkeyKey(pubkey);
+      if (this.pubkeySet.has(key))
         return false;
-      }
       this.pubkeys.push(pubkey);
       this.pubkeySet.add(key);
       return true;
     };
     this.setPubkeys = (newPubkeys) => {
-      const tag6 = `${TAG9} | setPubkeys | `;
+      const tag6 = `${TAG12} | setPubkeys | `;
       this.pubkeys = [];
       this.pubkeySet.clear();
       let added = 0;
@@ -4207,17 +4687,8 @@ class SDK {
       this.pubkeys = [];
       this.pubkeySet.clear();
     }
-    this.isViewOnlyMode = () => {
-      return this.viewOnlyMode;
-    };
-    this.canSignTransactions = () => {
-      return !this.viewOnlyMode && !!this.keepKeySdk;
-    };
-    this.isVaultAvailable = () => {
-      return !!this.keepkeyEndpoint && this.keepkeyEndpoint.isAvailable;
-    };
     this.getUnifiedPortfolio = async function() {
-      const tag6 = `${TAG9} | getUnifiedPortfolio | `;
+      const tag6 = `${TAG12} | getUnifiedPortfolio | `;
       try {
         const startTime = performance.now();
         try {
@@ -4249,8 +4720,7 @@ class SDK {
             this.events.emit("SET_BALANCES", this.balances);
           }
           if (portfolioData.pubkeys && portfolioData.pubkeys.length > 0) {
-            const convertedPubkeys = this.convertVaultPubkeysToPioneerFormat(portfolioData.pubkeys);
-            this.setPubkeys(convertedPubkeys);
+            this.setPubkeys(portfolioData.pubkeys);
             this.events.emit("SET_PUBKEYS", this.pubkeys);
           }
           if (portfolioData.devices && portfolioData.devices.length > 0) {
@@ -4263,52 +4733,10 @@ class SDK {
             }));
             this.events.emit("SET_WALLETS", this.wallets);
           }
-          const isCacheDataValid = (portfolioData2) => {
-            if (!portfolioData2.networks || !Array.isArray(portfolioData2.networks)) {
-              console.warn("[CACHE VALIDATION] Networks is not an array");
-              return false;
-            }
-            if (portfolioData2.networks.length > 50) {
-              console.error(`[CACHE VALIDATION] CORRUPTED: ${portfolioData2.networks.length} networks (should be < 50)`);
-              return false;
-            }
-            const validNetworks = portfolioData2.networks.filter((n) => n.networkId && n.totalValueUsd !== undefined && n.gasAssetSymbol);
-            if (validNetworks.length === 0 && portfolioData2.networks.length > 0) {
-              console.error("[CACHE VALIDATION] CORRUPTED: No networks have required fields");
-              return false;
-            }
-            console.log(`[CACHE VALIDATION] Found ${portfolioData2.networks.length} networks, ${validNetworks.length} valid`);
-            return true;
-          };
           if (isCacheDataValid(portfolioData)) {
-            const dashboardData = {
-              totalValueUsd: portfolioData.totalValueUsd,
-              pairedDevices: portfolioData.pairedDevices,
-              devices: portfolioData.devices || [],
-              networks: portfolioData.networks || [],
-              assets: portfolioData.assets || [],
-              statistics: portfolioData.statistics || {},
-              cached: portfolioData.cached,
-              lastUpdated: portfolioData.lastUpdated,
-              cacheAge: portfolioData.lastUpdated ? Math.floor((Date.now() - portfolioData.lastUpdated) / 1000) : 0,
-              networkPercentages: portfolioData.networks?.map((network) => ({
-                networkId: network.network_id || network.networkId,
-                percentage: network.percentage || 0
-              })) || []
-            };
-            this.dashboard = dashboardData;
+            this.dashboard = buildDashboardFromPortfolioData(portfolioData);
             this.events.emit("SET_DASHBOARD", this.dashboard);
-            const cacheAge = portfolioData.lastUpdated ? Math.floor((Date.now() - portfolioData.lastUpdated) / 1000) : 0;
-            this.syncState = {
-              isSynced: true,
-              isInitialSync: false,
-              cacheAge,
-              syncProgress: 100,
-              syncedChains: this.blockchains.length,
-              totalChains: this.blockchains.length,
-              lastSyncTime: portfolioData.lastUpdated || Date.now(),
-              syncSource: "cache"
-            };
+            this.syncState = createCacheSyncState(portfolioData.lastUpdated, this.blockchains.length);
             this.events.emit("SYNC_STATE_CHANGED", this.syncState);
           } else {
             console.warn("[CACHE VALIDATION] ❌ Cache data corrupted, building dashboard from cached balances");
@@ -4343,7 +4771,7 @@ class SDK {
       return this.syncState.isSynced;
     };
     this.init = async function(walletsVerbose, setup) {
-      const tag6 = `${TAG9} | init | `;
+      const tag6 = `${TAG12} | init | `;
       try {
         if (!this.username)
           throw Error("username required!");
@@ -4364,7 +4792,7 @@ class SDK {
         this.pioneer = await PioneerClient.init();
         if (!this.pioneer)
           throw Error("Failed to init pioneer server!");
-        this.paths.concat(import_pioneer_coins4.getPaths(this.blockchains));
+        this.paths.concat(import_pioneer_coins6.getPaths(this.blockchains));
         await this.getGasAssets();
         if (!this.skipKeeperEndpoint) {
           this.keepkeyEndpoint = await detectKkApiAvailability(this.forceLocalhost);
@@ -4408,7 +4836,7 @@ class SDK {
           this.events.emit("message", request);
         });
         clientEvents.events.on("balance:update", (data) => {
-          const tag7 = TAG9 + " | balance:update | ";
+          const tag7 = TAG12 + " | balance:update | ";
           try {
             const payload = typeof data === "string" ? JSON.parse(data) : data;
             const balance = payload.balance;
@@ -4426,7 +4854,7 @@ class SDK {
           }
         });
         clientEvents.events.on("sync:progress", (data) => {
-          const tag7 = TAG9 + " | sync:progress | ";
+          const tag7 = TAG12 + " | sync:progress | ";
           try {
             const payload = typeof data === "string" ? JSON.parse(data) : data;
             console.log(tag7, `Sync progress: ${payload.percentage}%`);
@@ -4439,7 +4867,7 @@ class SDK {
           }
         });
         clientEvents.events.on("sync:complete", (data) => {
-          const tag7 = TAG9 + " | sync:complete | ";
+          const tag7 = TAG12 + " | sync:complete | ";
           try {
             const payload = typeof data === "string" ? JSON.parse(data) : data;
             console.log(tag7, `Sync complete: ${payload.balances} balances in ${payload.duration}ms`);
@@ -4490,155 +4918,60 @@ class SDK {
     this.buildDashboardFromBalances = function() {
       return buildDashboardFromBalances(this.balances, this.blockchains, this.assetsMap);
     };
-    this.inferTypeFromCaip = function(caip) {
-      if (caip.includes("/slip44:"))
-        return "native";
-      if (caip.includes("/erc20:") || caip.includes("/bep20:") || caip.includes("/spl:"))
-        return "token";
-      if (caip.includes("/denom:"))
-        return "native";
-      return "unknown";
-    };
     this.syncMarket = async function() {
       return syncMarket(this.balances, this.pioneer);
     };
     this.sync = async function() {
-      const tag6 = `${TAG9} | sync | `;
+      const tag6 = `${TAG12} | sync | `;
+      const log2 = logger;
       try {
-        const matchesNetwork = (item, networkId) => {
-          if (!item.networks || !Array.isArray(item.networks))
-            return false;
-          if (item.networks.includes(networkId))
-            return true;
-          if (networkId.startsWith("eip155:") && item.networks.includes("eip155:*"))
-            return true;
-          return false;
+        this.syncState = {
+          ...createInitialSyncState(this.blockchains.length),
+          syncProgress: 10
         };
+        this.events.emit("SYNC_STATE_CHANGED", this.syncState);
+        log2.info(tag6, "Fetching initial pubkeys...");
         await this.getPubkeys();
-        for (let i = 0;i < this.blockchains.length; i++) {
-          let networkId = this.blockchains[i];
-          if (networkId.indexOf("eip155:") >= 0)
-            networkId = "eip155:*";
-          let paths = this.paths.filter((path) => matchesNetwork(path, networkId));
-          if (paths.length === 0) {
-            let paths2 = import_pioneer_coins4.getPaths([networkId]);
-            if (!paths2 || paths2.length === 0)
-              throw Error("Unable to find paths for: " + networkId);
-            this.paths = this.paths.concat(paths2);
-          }
-        }
-        for (let i = 0;i < this.blockchains.length; i++) {
-          let networkId = this.blockchains[i];
-          if (networkId.indexOf("eip155:") >= 0)
-            networkId = "eip155:*";
-          const pathsForChain = this.paths.filter((path) => matchesNetwork(path, networkId));
-          if (!pathsForChain || pathsForChain.length === 0)
-            throw Error("No paths found for blockchain: " + networkId);
-          for (let j = 0;j < pathsForChain.length; j++) {
-            const path = pathsForChain[j];
-            let pathBip32 = import_pioneer_coins4.addressNListToBIP32(path.addressNListMaster);
-            let pubkey = this.pubkeys.find((pubkey2) => pubkey2.pathMaster === pathBip32);
-            if (!pubkey) {
-              const pubkey2 = await getPubkey(this.blockchains[i], path, this.keepKeySdk, this.context);
-              if (!pubkey2)
-                throw Error("Unable to get pubkey for network+ " + networkId);
-              this.addPubkey(pubkey2);
-            }
-          }
-        }
+        this.syncState.syncProgress = 20;
+        this.events.emit("SYNC_STATE_CHANGED", this.syncState);
+        log2.info(tag6, "Discovering paths for blockchains...");
+        this.paths = await ensurePathsForBlockchains(this.blockchains, this.paths, tag6);
+        this.syncState.syncProgress = 30;
+        this.events.emit("SYNC_STATE_CHANGED", this.syncState);
+        log2.info(tag6, "Synchronizing pubkeys...");
+        await syncPubkeysForBlockchains(this.blockchains, this.paths, this.pubkeys, this.keepKeySdk, this.context, getPubkey, (pubkey) => this.addPubkey(pubkey), tag6);
+        this.syncState.syncProgress = 50;
+        this.syncState.syncedChains = this.blockchains.length;
+        this.events.emit("SYNC_STATE_CHANGED", this.syncState);
+        log2.info(tag6, "Fetching balances...");
         await this.getBalances();
-        console.log(tag6, "Loading charts (tokens + portfolio)...");
+        this.syncState.syncProgress = 70;
+        this.events.emit("SYNC_STATE_CHANGED", this.syncState);
+        log2.info(tag6, "Loading charts (tokens + portfolio)...");
         await this.getCharts();
-        console.log(tag6, `Charts loaded. Total balances: ${this.balances.length}`);
+        log2.info(tag6, `Charts loaded. Total balances: ${this.balances.length}`);
+        this.syncState.syncProgress = 85;
+        this.events.emit("SYNC_STATE_CHANGED", this.syncState);
+        log2.info(tag6, "Syncing market prices...");
         await this.syncMarket();
-        const dashboardData = {
-          networks: [],
-          totalValueUsd: 0,
-          networkPercentages: []
-        };
-        let totalPortfolioValue = 0;
-        const networksTemp = [];
-        const uniqueBlockchains = [...new Set(this.blockchains)];
-        for (const blockchain of uniqueBlockchains) {
-          const filteredBalances = this.balances.filter((b) => {
-            const networkId = import_pioneer_caip8.caipToNetworkId(b.caip);
-            return networkId === blockchain || blockchain === "eip155:*" && networkId.startsWith("eip155:");
-          });
-          const balanceMap = new Map;
-          const isBitcoin = blockchain.includes("bip122:000000000019d6689c085ae165831e93");
-          if (isBitcoin) {
-            const bitcoinByValue = new Map;
-            filteredBalances.forEach((balance) => {
-              const valueKey = `${balance.balance}_${balance.valueUsd}`;
-              if (!bitcoinByValue.has(valueKey)) {
-                bitcoinByValue.set(valueKey, []);
-              }
-              bitcoinByValue.get(valueKey).push(balance);
-            });
-            for (const [valueKey, balances] of bitcoinByValue.entries()) {
-              if (balances.length === 3 && parseFloat(balances[0].valueUsd || "0") > 0) {
-                const xpubBalance = balances.find((b) => b.pubkey?.startsWith("xpub")) || balances[0];
-                const key = `${xpubBalance.caip}_${xpubBalance.pubkey || "default"}`;
-                balanceMap.set(key, xpubBalance);
-              } else {
-                balances.forEach((balance) => {
-                  const key = `${balance.caip}_${balance.pubkey || "default"}`;
-                  balanceMap.set(key, balance);
-                });
-              }
-            }
-          } else {
-            filteredBalances.forEach((balance) => {
-              const key = `${balance.caip}_${balance.pubkey || "default"}`;
-              if (!balanceMap.has(key) || parseFloat(balance.valueUsd || "0") > parseFloat(balanceMap.get(key).valueUsd || "0")) {
-                balanceMap.set(key, balance);
-              }
-            });
-          }
-          const networkBalances = Array.from(balanceMap.values());
-          const networkTotal = networkBalances.reduce((sum, balance, idx) => {
-            const valueUsd = typeof balance.valueUsd === "string" ? parseFloat(balance.valueUsd) : balance.valueUsd || 0;
-            return sum + valueUsd;
-          }, 0);
-          const nativeAssetCaip = import_pioneer_caip8.networkIdToCaip(blockchain);
-          const gasAsset = networkBalances.find((b) => b.caip === nativeAssetCaip);
-          const totalNativeBalance = networkBalances.filter((b) => b.caip === nativeAssetCaip).reduce((sum, balance) => {
-            const balanceNum = typeof balance.balance === "string" ? parseFloat(balance.balance) : balance.balance || 0;
-            return sum + balanceNum;
-          }, 0).toString();
-          networksTemp.push({
-            networkId: blockchain,
-            totalValueUsd: networkTotal,
-            gasAssetCaip: nativeAssetCaip || null,
-            gasAssetSymbol: gasAsset?.symbol || null,
-            icon: gasAsset?.icon || null,
-            color: gasAsset?.color || null,
-            totalNativeBalance
-          });
-          totalPortfolioValue += networkTotal;
-        }
-        dashboardData.networks = networksTemp.sort((a, b) => b.totalValueUsd - a.totalValueUsd);
-        dashboardData.totalValueUsd = totalPortfolioValue;
-        dashboardData.networkPercentages = dashboardData.networks.map((network) => ({
-          networkId: network.networkId,
-          percentage: totalPortfolioValue > 0 ? Number((network.totalValueUsd / totalPortfolioValue * 100).toFixed(2)) : 0
-        })).filter((entry) => entry.percentage > 0);
-        this.dashboard = dashboardData;
-        this.syncState = {
-          isSynced: true,
-          isInitialSync: false,
-          cacheAge: 0,
-          syncProgress: 100,
-          syncedChains: this.blockchains.length,
-          totalChains: this.blockchains.length,
-          lastSyncTime: Date.now(),
-          syncSource: "fresh"
-        };
+        this.syncState.syncProgress = 95;
+        this.events.emit("SYNC_STATE_CHANGED", this.syncState);
+        log2.info(tag6, "Building dashboard...");
+        this.dashboard = buildDashboardFromBalances(this.balances, [...new Set(this.blockchains)], this.assetsMap);
+        this.syncState = createFreshSyncState(this.blockchains.length);
         this.events.emit("SYNC_STATE_CHANGED", this.syncState);
         this.events.emit("SYNC_COMPLETE", this.syncState);
+        log2.info(tag6, "✅ Sync complete!");
         return true;
       } catch (e) {
-        console.error(tag6, "Error in sync:", e);
+        log2.error(tag6, "Sync failed:", e);
+        this.syncState = {
+          ...this.syncState,
+          isSynced: false,
+          syncProgress: 0
+        };
+        this.events.emit("SYNC_STATE_CHANGED", this.syncState);
+        this.events.emit("SYNC_ERROR", e);
         throw e;
       }
     };
@@ -4652,7 +4985,7 @@ class SDK {
       }
     };
     this.buildTx = async function(sendPayload) {
-      let tag6 = TAG9 + " | buildTx | ";
+      let tag6 = TAG12 + " | buildTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4674,7 +5007,7 @@ class SDK {
       }
     };
     this.buildDelegateTx = async function(caip, params) {
-      let tag6 = TAG9 + " | buildDelegateTx | ";
+      let tag6 = TAG12 + " | buildDelegateTx | ";
       try {
         const delegateParams = {
           ...params,
@@ -4689,7 +5022,7 @@ class SDK {
       }
     };
     this.buildUndelegateTx = async function(caip, params) {
-      let tag6 = TAG9 + " | buildUndelegateTx | ";
+      let tag6 = TAG12 + " | buildUndelegateTx | ";
       try {
         const undelegateParams = {
           ...params,
@@ -4704,7 +5037,7 @@ class SDK {
       }
     };
     this.buildClaimRewardsTx = async function(caip, params) {
-      let tag6 = TAG9 + " | buildClaimRewardsTx | ";
+      let tag6 = TAG12 + " | buildClaimRewardsTx | ";
       try {
         const claimParams = {
           ...params,
@@ -4719,7 +5052,7 @@ class SDK {
       }
     };
     this.buildClaimAllRewardsTx = async function(caip, params) {
-      let tag6 = TAG9 + " | buildClaimAllRewardsTx | ";
+      let tag6 = TAG12 + " | buildClaimAllRewardsTx | ";
       try {
         const claimAllParams = {
           ...params,
@@ -4733,7 +5066,7 @@ class SDK {
       }
     };
     this.signTx = async function(caip, unsignedTx) {
-      let tag6 = TAG9 + " | signTx | ";
+      let tag6 = TAG12 + " | signTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4754,7 +5087,7 @@ class SDK {
       }
     };
     this.broadcastTx = async function(caip, signedTx) {
-      let tag6 = TAG9 + " | broadcastTx | ";
+      let tag6 = TAG12 + " | broadcastTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4778,7 +5111,7 @@ class SDK {
       }
     };
     this.swap = async function(swapPayload) {
-      let tag6 = `${TAG9} | swap | `;
+      let tag6 = `${TAG12} | swap | `;
       try {
         if (!swapPayload)
           throw Error("swapPayload required!");
@@ -4796,15 +5129,6 @@ class SDK {
           throw Error("Invalid networkId for outboundAssetContext");
         if (!this.outboundAssetContext || !this.outboundAssetContext.address)
           throw Error("Invalid outboundAssetContext missing address");
-        const matchesNetwork = (pubkey, networkId) => {
-          if (!pubkey.networks || !Array.isArray(pubkey.networks))
-            return false;
-          if (pubkey.networks.includes(networkId))
-            return true;
-          if (networkId.startsWith("eip155:") && pubkey.networks.includes("eip155:*"))
-            return true;
-          return false;
-        };
         const pubkeys = this.pubkeys.filter((e) => matchesNetwork(e, this.assetContext.networkId));
         let senderAddress = pubkeys[0]?.address || pubkeys[0]?.master || pubkeys[0]?.pubkey;
         if (!senderAddress)
@@ -4836,17 +5160,8 @@ class SDK {
           this.assetContext.balance = totalBalance.toString();
           this.assetContext.valueUsd = (totalBalance * parseFloat(this.assetContext.priceUsd || "0")).toFixed(2);
           console.log(tag6, `Updated assetContext balance to aggregated total: ${totalBalance}`);
-          const feeReserves = {
-            "bip122:000000000019d6689c085ae165831e93/slip44:0": 0.00005,
-            "eip155:1/slip44:60": 0.001,
-            "cosmos:thorchain-mainnet-v1/slip44:931": 0.02,
-            "bip122:00000000001a91e3dace36e2be3bf030/slip44:3": 1,
-            "bip122:000007d91d1254d60e2dd1ae58038307/slip44:5": 0.001,
-            "bip122:000000000000000000651ef99cb9fcbe/slip44:145": 0.0005
-          };
-          const reserve = feeReserves[swapPayload.caipIn] || 0.0001;
-          inputAmount = Math.max(0, totalBalance - reserve);
-          console.log(tag6, `Using max amount for swap: ${inputAmount} (total balance: ${totalBalance}, reserve: ${reserve})`);
+          inputAmount = getMaxSendableAmount(totalBalance, swapPayload.caipIn);
+          console.log(tag6, `Using max amount for swap: ${inputAmount} (total balance: ${totalBalance})`);
         } else {
           inputAmount = typeof swapPayload.amount === "string" ? parseFloat(swapPayload.amount) : swapPayload.amount;
           if (isNaN(inputAmount) || inputAmount <= 0) {
@@ -4967,7 +5282,7 @@ class SDK {
       }
     };
     this.transfer = async function(sendPayload) {
-      let tag6 = `${TAG9} | transfer | `;
+      let tag6 = `${TAG12} | transfer | `;
       try {
         if (!sendPayload)
           throw Error("sendPayload required!");
@@ -5062,7 +5377,7 @@ class SDK {
       }
     };
     this.setBlockchains = async function(blockchains) {
-      const tag6 = `${TAG9} | setBlockchains | `;
+      const tag6 = `${TAG12} | setBlockchains | `;
       try {
         if (!blockchains)
           throw Error("blockchains required!");
@@ -5078,7 +5393,7 @@ class SDK {
       }
     };
     this.addAsset = async function(caip, data) {
-      let tag6 = TAG9 + " | addAsset | ";
+      let tag6 = TAG12 + " | addAsset | ";
       try {
         let success = false;
         if (!caip)
@@ -5116,7 +5431,7 @@ class SDK {
       }
     };
     this.clearWalletState = async function() {
-      const tag6 = `${TAG9} | clearWalletState | `;
+      const tag6 = `${TAG12} | clearWalletState | `;
       try {
         this.context = null;
         this.paths = [];
@@ -5131,7 +5446,7 @@ class SDK {
       }
     };
     this.addPath = async function(path) {
-      const tag6 = `${TAG9} | addPath | `;
+      const tag6 = `${TAG12} | addPath | `;
       try {
         this.paths.push(path);
         const pubkey = await getPubkey(path.networks[0], path, this.keepKeySdk, this.context);
@@ -5145,7 +5460,7 @@ class SDK {
       }
     };
     this.addPaths = async function(paths) {
-      const tag6 = `${TAG9} | addPaths | `;
+      const tag6 = `${TAG12} | addPaths | `;
       try {
         console.log(tag6, `Adding ${paths.length} paths in batch mode...`);
         this.paths.push(...paths);
@@ -5181,7 +5496,7 @@ class SDK {
       return this.getGasAssets();
     };
     this.getGasAssets = async function() {
-      const tag6 = `${TAG9} | getGasAssets | `;
+      const tag6 = `${TAG12} | getGasAssets | `;
       try {
         for (let i = 0;i < this.blockchains.length; i++) {
           let networkId = this.blockchains[i];
@@ -5195,28 +5510,6 @@ class SDK {
             throw Error("GAS Asset MISSING from assetData " + caip);
           }
         }
-        const mayaTokenCaip = "cosmos:mayachain-mainnet-v1/denom:maya";
-        if (!this.assetsMap.has(mayaTokenCaip)) {
-          const mayaToken = {
-            caip: mayaTokenCaip,
-            networkId: "cosmos:mayachain-mainnet-v1",
-            chainId: "mayachain-mainnet-v1",
-            symbol: "MAYA",
-            name: "Maya Token",
-            precision: 4,
-            decimals: 4,
-            color: "#00D4AA",
-            icon: "https://pioneers.dev/coins/maya.png",
-            explorer: "https://explorer.mayachain.info",
-            explorerAddressLink: "https://explorer.mayachain.info/address/{{address}}",
-            explorerTxLink: "https://explorer.mayachain.info/tx/{{txid}}",
-            type: "token",
-            isToken: true,
-            denom: "maya"
-          };
-          this.assetsMap.set(mayaTokenCaip, mayaToken);
-          console.log(tag6, "Added MAYA token to assetsMap");
-        }
         return this.assetsMap;
       } catch (e) {
         console.error(e);
@@ -5224,7 +5517,7 @@ class SDK {
       }
     };
     this.getPubkeys = async function() {
-      const tag6 = `${TAG9} | getPubkeys | `;
+      const tag6 = `${TAG12} | getPubkeys | `;
       try {
         if (this.paths.length === 0)
           throw new Error("No paths found!");
@@ -5269,134 +5562,57 @@ class SDK {
       }
     };
     this.getBalancesForNetworks = async function(networkIds, forceRefresh) {
-      const tag6 = `${TAG9} | getBalancesForNetworks | `;
+      const tag6 = `${TAG12} | getBalancesForNetworks | `;
       try {
         if (!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.");
         }
-        if (forceRefresh) {
-          console.log(tag6, "\uD83D\uDD04 Force refresh requested - bypassing balance cache");
-        }
-        console.log("\uD83D\uDD0D [DIAGNOSTIC] Input networks:", networkIds);
-        console.log("\uD83D\uDD0D [DIAGNOSTIC] Total pubkeys:", this.pubkeys.length);
-        const pubkeysWithNetworks = this.pubkeys.filter((p) => p.networks && Array.isArray(p.networks));
-        const pubkeysWithoutNetworks = this.pubkeys.filter((p) => !p.networks || !Array.isArray(p.networks));
-        console.log("\uD83D\uDD0D [DIAGNOSTIC] Pubkeys WITH networks:", pubkeysWithNetworks.length);
-        console.log("\uD83D\uDD0D [DIAGNOSTIC] Pubkeys WITHOUT networks:", pubkeysWithoutNetworks.length);
-        if (pubkeysWithoutNetworks.length > 0) {
-          console.warn("⚠️ [WARNING] Some pubkeys missing networks field:");
-          pubkeysWithoutNetworks.forEach((pk) => {
-            console.warn(`   - ${pk.note || pk.pubkey.slice(0, 10)}: networks=${pk.networks}`);
-          });
-        }
+        if (forceRefresh)
+          console.log(tag6, "\uD83D\uDD04 Force refresh requested");
+        console.log("\uD83D\uDD0D [DIAGNOSTIC] Networks:", networkIds.length, "Pubkeys:", this.pubkeys.length);
+        const { valid, invalid } = validatePubkeysNetworks(this.pubkeys, "\uD83D\uDD0D [DIAGNOSTIC]");
+        console.log("\uD83D\uDD0D [DIAGNOSTIC] Pubkeys:", { valid: valid.length, invalid: invalid.length });
         const assetQuery = [];
         for (const networkId of networkIds) {
-          let adjustedNetworkId = networkId;
-          if (adjustedNetworkId.includes("eip155:")) {
-            adjustedNetworkId = "eip155:*";
-          }
-          const isEip155 = adjustedNetworkId.includes("eip155");
-          let pubkeys = this.pubkeys.filter((pubkey) => pubkey.networks && Array.isArray(pubkey.networks) && pubkey.networks.some((network) => {
-            if (isEip155)
-              return network.startsWith("eip155:");
-            return network === adjustedNetworkId;
-          }));
-          if (pubkeys.length === 0) {
-            console.warn(tag6, `⚠️ No pubkeys found for ${networkId} with networks field`);
-            console.warn(tag6, "Attempting fallback: finding pubkeys by path matching");
-            const pathsForNetwork = this.paths.filter((p) => p.networks?.includes(networkId) || networkId.startsWith("eip155:") && p.networks?.includes("eip155:*"));
-            for (const path of pathsForNetwork) {
-              const matchingPubkey = this.pubkeys.find((pk) => JSON.stringify(pk.addressNList) === JSON.stringify(path.addressNList));
-              if (matchingPubkey) {
-                console.warn(tag6, `  ✓ Found pubkey via path matching: ${matchingPubkey.note || matchingPubkey.pubkey.slice(0, 10)}`);
-                pubkeys.push(matchingPubkey);
-              }
-            }
-            if (pubkeys.length > 0) {
-              console.warn(tag6, `  ✅ Fallback successful: Found ${pubkeys.length} pubkeys for ${networkId}`);
-            } else {
-              console.error(tag6, `  ❌ Fallback failed: No pubkeys found for ${networkId}`);
-            }
-          }
-          const caipNative = await import_pioneer_caip8.networkIdToCaip(networkId);
-          for (const pubkey of pubkeys) {
-            assetQuery.push({ caip: caipNative, pubkey: pubkey.pubkey });
-          }
-        }
-        console.log("\uD83D\uDD0D [DIAGNOSTIC] Built assetQuery with", assetQuery.length, "entries");
-        console.log("\uD83D\uDD0D [DIAGNOSTIC] Sample queries:", assetQuery.slice(0, 5));
-        const caipCounts = new Map;
-        for (const query of assetQuery) {
-          caipCounts.set(query.caip, (caipCounts.get(query.caip) || 0) + 1);
-        }
-        console.log("\uD83D\uDD0D [DIAGNOSTIC] Queries by chain:");
-        caipCounts.forEach((count, caip) => {
-          console.log(`   - ${caip}: ${count} queries`);
-        });
-        console.log(`⏱️  [PERF] Starting GetPortfolioBalances API call...`);
-        const apiCallStart = performance.now();
-        console.time("GetPortfolioBalances Response Time");
-        try {
-          let marketInfo = await this.pioneer.GetPortfolioBalances({ pubkeys: assetQuery }, forceRefresh ? { forceRefresh: true } : undefined);
-          const apiCallTime = performance.now() - apiCallStart;
-          console.timeEnd("GetPortfolioBalances Response Time");
-          console.log(`⏱️  [PERF] API call completed in ${apiCallTime.toFixed(0)}ms`);
-          const enrichStart = performance.now();
-          let balances = marketInfo.data;
-          console.log(`⏱️  [PERF] Received ${balances?.length || 0} balances from server`);
-          console.log(`⏱️  [PERF] Starting balance enrichment...`);
-          for (let balance of balances) {
-            const assetInfo = this.assetsMap.get(balance.caip.toLowerCase()) || this.assetsMap.get(balance.caip);
-            if (!assetInfo) {
-              console.warn(`⚠️  [ENRICHMENT] Asset metadata missing for ${balance.caip}, using fallback enrichment`);
-              const inferredType = this.inferTypeFromCaip(balance.caip);
-              Object.assign(balance, {
-                type: balance.type || inferredType,
-                isNative: balance.isNative ?? inferredType === "native",
-                networkId: import_pioneer_caip8.caipToNetworkId(balance.caip),
-                icon: "https://pioneers.dev/coins/unknown.png",
-                identifier: `${balance.caip}:${balance.pubkey}`,
-                updated: Date.now()
-              });
-              continue;
-            }
-            const color = ASSET_COLORS[balance.caip] || assetInfo.color;
-            Object.assign(balance, assetInfo, {
-              type: balance.type || assetInfo.type,
-              isNative: balance.isNative ?? assetInfo.isNative,
-              networkId: import_pioneer_caip8.caipToNetworkId(balance.caip),
-              icon: assetInfo.icon || "https://pioneers.dev/coins/etherum.png",
-              identifier: `${balance.caip}:${balance.pubkey}`,
-              updated: Date.now(),
-              color
-            });
-          }
-          const enrichTime = performance.now() - enrichStart;
-          console.log(`⏱️  [PERF] Enrichment completed in ${enrichTime.toFixed(0)}ms`);
-          this.balances = balances;
-          this.events.emit("SET_BALANCES", this.balances);
-          console.log(`⏱️  [PERF] Building dashboard from ${balances.length} balances...`);
-          const dashboardStart = performance.now();
-          const dashboardData = this.buildDashboardFromBalances();
-          this.dashboard = dashboardData;
-          this.events.emit("SET_DASHBOARD", this.dashboard);
-          console.log(`⏱️  [PERF] Dashboard built in ${(performance.now() - dashboardStart).toFixed(0)}ms`);
-          console.log(`\uD83D\uDCCA Dashboard created: ${this.dashboard?.networks?.length || 0} networks, $${this.dashboard?.totalValueUsd?.toFixed(2) || "0.00"} total`);
-          console.log(`⏱️  [PERF] Total getBalancesForNetworks: ${(performance.now() - apiCallStart).toFixed(0)}ms`);
-          return this.balances;
-        } catch (apiError) {
-          console.error(tag6, "GetPortfolioBalances API call failed:", apiError);
-          throw new Error(`GetPortfolioBalances API call failed: ${apiError?.message || "Unknown error"}`);
+          const pubkeys = findPubkeysForNetwork(this.pubkeys, networkId, this.paths, tag6);
+          const caip = await import_pioneer_caip8.networkIdToCaip(networkId);
+          assetQuery.push(...buildAssetQuery(pubkeys, caip));
         }
+        logQueryDiagnostics(assetQuery, "\uD83D\uDD0D [DIAGNOSTIC]");
+        console.log(`⏱️  [PERF] Starting GetPortfolioBalances...`);
+        const apiStart = performance.now();
+        console.time("GetPortfolioBalances Response");
+        const marketInfo = await this.pioneer.GetPortfolioBalances({ pubkeys: assetQuery }, forceRefresh ? { forceRefresh: true } : undefined);
+        console.timeEnd("GetPortfolioBalances Response");
+        console.log(`⏱️  [PERF] API completed in ${(performance.now() - apiStart).toFixed(0)}ms`);
+        const enrichStart = performance.now();
+        console.log(`⏱️  [PERF] Enriching ${marketInfo.data?.length || 0} balances...`);
+        const balances = enrichBalancesWithAssetInfo(marketInfo.data, this.assetsMap, import_pioneer_caip8.caipToNetworkId);
+        console.log(`⏱️  [PERF] Enrichment completed in ${(performance.now() - enrichStart).toFixed(0)}ms`);
+        this.balances = balances;
+        this.events.emit("SET_BALANCES", this.balances);
+        const dashStart = performance.now();
+        this.dashboard = this.buildDashboardFromBalances();
+        this.events.emit("SET_DASHBOARD", this.dashboard);
+        console.log(`⏱️  [PERF] Dashboard built in ${(performance.now() - dashStart).toFixed(0)}ms`);
+        console.log(`\uD83D\uDCCA Dashboard: ${this.dashboard?.networks?.length || 0} networks, $${this.dashboard?.totalValueUsd?.toFixed(2) || "0.00"}`);
+        console.log(`⏱️  [PERF] Total: ${(performance.now() - apiStart).toFixed(0)}ms`);
+        return this.balances;
       } catch (e) {
-        console.error(tag6, "Error: ", e);
+        console.error(tag6, "Error:", e?.message || e);
         throw e;
       }
     };
-    this.getBalances = async function(forceRefresh) {
-      const tag6 = `${TAG9} | getBalances | `;
+    this.getBalances = async function(forceRefresh, caip) {
+      const tag6 = `${TAG12} | getBalances | `;
       try {
+        if (caip) {
+          console.log(tag6, `\uD83C\uDFAF Refreshing single asset: ${caip}`);
+          const networkId = caip.split("/")[0];
+          console.log(tag6, `\uD83D\uDCCD Target network: ${networkId}`);
+          const results = await this.getBalancesForNetworks([networkId], forceRefresh);
+          return results.filter((b) => b.caip === caip || b.networkId === networkId);
+        }
         return await this.getBalancesForNetworks(this.blockchains, forceRefresh);
       } catch (e) {
         console.error(tag6, "Error in getBalances: ", e);
@@ -5404,7 +5620,7 @@ class SDK {
       }
     };
     this.getBalance = async function(networkId) {
-      const tag6 = `${TAG9} | getBalance | `;
+      const tag6 = `${TAG12} | getBalance | `;
       try {
         const results = await this.getBalancesForNetworks([networkId]);
         const filtered = results.filter(async (b) => b.networkId === await import_pioneer_caip8.networkIdToCaip(networkId));
@@ -5415,7 +5631,7 @@ class SDK {
       }
     };
     this.getFees = async function(networkId) {
-      const tag6 = `${TAG9} | getFees | `;
+      const tag6 = `${TAG12} | getFees | `;
       try {
         if (!this.pioneer) {
           throw new Error("Pioneer client not initialized. Call init() first.");
@@ -5430,7 +5646,7 @@ class SDK {
       return estimateTransactionFee(feeRate, unit, networkType, txSize);
     };
     this.getCharts = async function() {
-      const tag6 = `${TAG9} | getCharts | `;
+      const tag6 = `${TAG12} | getCharts | `;
       try {
         console.log(tag6, "Fetching charts (portfolio + tokens + staking)...");
         const { getCharts: getChartsModular } = await Promise.resolve().then(() => (init_charts(), exports_charts));
@@ -5455,7 +5671,7 @@ class SDK {
       }
     };
     this.setContext = async (context) => {
-      const tag6 = `${TAG9} | setContext | `;
+      const tag6 = `${TAG12} | setContext | `;
       try {
         if (!context)
           throw Error("context required!");
@@ -5468,7 +5684,7 @@ class SDK {
       }
     };
     this.setContextType = async (contextType) => {
-      const tag6 = `${TAG9} | setContextType | `;
+      const tag6 = `${TAG12} | setContextType | `;
       try {
         if (!contextType)
           throw Error("contextType required!");
@@ -5481,7 +5697,7 @@ class SDK {
       }
     };
     this.refresh = async (forceRefresh) => {
-      const tag6 = `${TAG9} | refresh | `;
+      const tag6 = `${TAG12} | refresh | `;
       try {
         if (forceRefresh) {
           console.log(tag6, "\uD83D\uDD04 Force refresh - fetching fresh balances from blockchain");
@@ -5496,7 +5712,7 @@ class SDK {
       }
     };
     this.setAssetContext = async function(asset) {
-      const tag6 = `${TAG9} | setAssetContext | `;
+      const tag6 = `${TAG12} | setAssetContext | `;
       try {
         if (!asset) {
           this.assetContext = null;
@@ -5506,114 +5722,28 @@ class SDK {
           throw Error("Invalid Asset! missing caip!");
         if (!asset.networkId)
           asset.networkId = import_pioneer_caip8.caipToNetworkId(asset.caip);
-        if (!this.pubkeys || this.pubkeys.length === 0) {
-          const errorMsg = `Cannot set asset context for ${asset.caip} - no pubkeys loaded. Please initialize wallet first.`;
-          console.error(tag6, errorMsg);
-          throw new Error(errorMsg);
-        }
-        const pubkeysForNetwork = this.pubkeys.filter((e) => {
-          if (!e.networks || !Array.isArray(e.networks))
-            return false;
-          if (e.networks.includes(asset.networkId))
-            return true;
-          if (asset.networkId.startsWith("eip155:") && e.networks.includes("eip155:*")) {
-            return true;
-          }
-          return false;
-        });
-        if (pubkeysForNetwork.length === 0) {
-          const errorMsg = `Cannot set asset context for ${asset.caip} - no address/xpub found for network ${asset.networkId}`;
-          console.error(tag6, errorMsg);
-          console.error(tag6, "Available networks in pubkeys:", [
-            ...new Set(this.pubkeys.flatMap((p) => p.networks || []))
-          ]);
-          throw new Error(errorMsg);
-        }
-        const isUtxoChain = asset.networkId.startsWith("bip122:");
-        if (isUtxoChain) {
-          const xpubFound = pubkeysForNetwork.some((p) => p.type === "xpub" && p.pubkey);
-          if (!xpubFound) {
-            const errorMsg = `Cannot set asset context for UTXO chain ${asset.caip} - xpub required but not found`;
-            console.error(tag6, errorMsg);
-            throw new Error(errorMsg);
-          }
-        }
-        const hasValidAddress = pubkeysForNetwork.some((p) => p.address || p.master || p.pubkey);
-        if (!hasValidAddress) {
-          const errorMsg = `Cannot set asset context for ${asset.caip} - no valid address found in pubkeys`;
-          console.error(tag6, errorMsg);
-          throw new Error(errorMsg);
-        }
+        validatePubkeysForNetwork(this.pubkeys, asset.networkId, asset.caip);
+        const pubkeysForNetwork = findPubkeysForNetwork(this.pubkeys, 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(tag6, "Invalid or missing CAIP, skipping market price fetch:", asset.caip);
-          } else {
-            console.log(tag6, "Fetching fresh market price for:", asset.caip);
-            const marketData = await this.pioneer.GetMarketInfo([asset.caip]);
-            console.log(tag6, "Market data response:", marketData);
-            if (marketData && marketData.data && marketData.data.length > 0) {
-              freshPriceUsd = marketData.data[0];
-              console.log(tag6, "✅ Fresh market price:", freshPriceUsd);
-            } else {
-              console.warn(tag6, "No market data returned for:", asset.caip);
-            }
-          }
-        } catch (marketError) {
-          console.error(tag6, "Error fetching market price:", marketError);
-        }
-        let assetInfo = this.assetsMap.get(asset.caip.toLowerCase());
-        console.log(tag6, "assetInfo: ", assetInfo);
-        let assetInfoDiscovery = import_pioneer_discovery2.assetData[asset.caip];
-        console.log(tag6, "assetInfoDiscovery: ", assetInfoDiscovery);
-        if (assetInfoDiscovery)
-          assetInfo = assetInfoDiscovery;
-        if (!assetInfo) {
-          console.log(tag6, "Building placeholder asset!");
-          assetInfo = {
-            caip: asset.caip.toLowerCase(),
-            networkId: asset.networkId,
-            symbol: asset.symbol || "UNKNOWN",
-            name: asset.name || "Unknown Asset",
-            icon: asset.icon || "https://pioneers.dev/coins/ethereum.png"
-          };
-        }
+        const freshPriceUsd = await fetchMarketPrice(this.pioneer, asset.caip);
+        let assetInfo = resolveAssetInfo(this.assetsMap, import_pioneer_discovery2.assetData, asset);
         const matchingBalances = this.balances.filter((b) => b.caip === asset.caip);
         if (matchingBalances.length > 0) {
-          let priceValue = matchingBalances[0].priceUsd || matchingBalances[0].price;
-          if ((!priceValue || priceValue === 0) && matchingBalances[0].valueUsd && matchingBalances[0].balance) {
-            const balance = parseFloat(matchingBalances[0].balance);
-            const valueUsd = parseFloat(matchingBalances[0].valueUsd);
-            if (balance > 0 && valueUsd > 0) {
-              priceValue = valueUsd / balance;
-              console.log(tag6, "calculated priceUsd from valueUsd/balance:", priceValue);
-            }
-          }
-          if (priceValue && priceValue > 0) {
+          const priceValue = extractPriceFromBalances(matchingBalances);
+          if (priceValue > 0) {
             console.log(tag6, "detected priceUsd from balance:", priceValue);
             assetInfo.priceUsd = priceValue;
           }
         }
-        if (freshPriceUsd && freshPriceUsd > 0) {
+        if (freshPriceUsd > 0) {
           assetInfo.priceUsd = freshPriceUsd;
           console.log(tag6, "✅ Using fresh market price:", freshPriceUsd);
-          let totalBalance = 0;
-          let totalValueUsd = 0;
-          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(tag6, `  Balance entry: ${balance} (${valueUsd} USD)`);
-          }
+          const { totalBalance, totalValueUsd } = aggregateBalances(matchingBalances, asset.caip);
           assetInfo.balance = totalBalance.toString();
           assetInfo.valueUsd = totalValueUsd.toFixed(2);
-          console.log(tag6, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
         }
         const assetBalances = this.balances.filter((b) => b.caip === asset.caip);
-        const assetPubkeys = this.pubkeys.filter((p) => p.networks && Array.isArray(p.networks) && p.networks.includes(import_pioneer_caip8.caipToNetworkId(asset.caip)) || import_pioneer_caip8.caipToNetworkId(asset.caip).includes("eip155") && p.networks && Array.isArray(p.networks) && p.networks.some((n) => n.startsWith("eip155")));
+        const assetPubkeys = filterPubkeysForAsset(this.pubkeys, asset.caip, import_pioneer_caip8.caipToNetworkId);
         const finalAssetContext = {
           ...assetInfo,
           ...asset,
@@ -5623,45 +5753,12 @@ class SDK {
         if ((!asset.priceUsd || asset.priceUsd === 0) && assetInfo.priceUsd && assetInfo.priceUsd > 0) {
           finalAssetContext.priceUsd = assetInfo.priceUsd;
         }
-        if (freshPriceUsd && freshPriceUsd > 0) {
-          for (const balance of assetBalances) {
-            balance.price = freshPriceUsd;
-            balance.priceUsd = freshPriceUsd;
-            const balanceAmount = parseFloat(balance.balance || 0);
-            balance.valueUsd = (balanceAmount * freshPriceUsd).toString();
-          }
-          console.log(tag6, "Updated all balances with fresh price data");
+        if (freshPriceUsd > 0) {
+          updateBalancesWithPrice(assetBalances, freshPriceUsd);
         }
         this.assetContext = finalAssetContext;
         if (asset.isToken || asset.type === "token" || assetInfo.isToken || assetInfo.type === "token") {
           const networkId = asset.networkId || assetInfo.networkId;
-          let nativeSymbol = "GAS";
-          let nativeCaip = "";
-          if (networkId.includes("mayachain")) {
-            nativeSymbol = "CACAO";
-            nativeCaip = "cosmos:mayachain-mainnet-v1/slip44:931";
-          } else if (networkId.includes("thorchain")) {
-            nativeSymbol = "RUNE";
-            nativeCaip = "cosmos:thorchain-mainnet-v1/slip44:931";
-          } else if (networkId.includes("cosmoshub")) {
-            nativeSymbol = "ATOM";
-            nativeCaip = "cosmos:cosmoshub-4/slip44:118";
-          } else if (networkId.includes("osmosis")) {
-            nativeSymbol = "OSMO";
-            nativeCaip = "cosmos:osmosis-1/slip44:118";
-          } else if (networkId.includes("eip155:1")) {
-            nativeSymbol = "ETH";
-            nativeCaip = "eip155:1/slip44:60";
-          } else if (networkId.includes("eip155:137")) {
-            nativeSymbol = "MATIC";
-            nativeCaip = "eip155:137/slip44:60";
-          } else if (networkId.includes("eip155:56")) {
-            nativeSymbol = "BNB";
-            nativeCaip = "eip155:56/slip44:60";
-          } else if (networkId.includes("eip155:43114")) {
-            nativeSymbol = "AVAX";
-            nativeCaip = "eip155:43114/slip44:60";
-          }
           this.assetContext.nativeSymbol = nativeSymbol;
           if (nativeCaip) {
             const nativeBalance = this.balances.find((b) => b.caip === nativeCaip);
@@ -5695,7 +5792,7 @@ class SDK {
       }
     };
     this.setPubkeyContext = async function(pubkey) {
-      let tag6 = `${TAG9} | setPubkeyContext | `;
+      let tag6 = `${TAG12} | setPubkeyContext | `;
       try {
         if (!pubkey)
           throw Error("pubkey is required");
@@ -5714,97 +5811,40 @@ class SDK {
       }
     };
     this.setOutboundAssetContext = async function(asset) {
-      const tag6 = `${TAG9} | setOutputAssetContext | `;
+      const tag6 = `${TAG12} | setOutputAssetContext | `;
       try {
-        console.log(tag6, "0. asset: ", asset);
+        console.log(tag6, "asset:", asset);
         if (!asset) {
           this.outboundAssetContext = null;
           return;
         }
-        console.log(tag6, "1 asset: ", asset);
         if (!asset.caip)
           throw Error("Invalid Asset! missing caip!");
         if (!asset.networkId)
           asset.networkId = import_pioneer_caip8.caipToNetworkId(asset.caip);
-        console.log(tag6, "networkId: ", asset.networkId);
-        console.log(tag6, "this.pubkeys: ", this.pubkeys);
-        const pubkey = this.pubkeys.find((p) => {
-          if (!p.networks || !Array.isArray(p.networks))
-            return false;
-          if (p.networks.includes(asset.networkId))
-            return true;
-          if (asset.networkId.startsWith("eip155:") && p.networks.includes("eip155:*"))
-            return true;
-          return false;
-        });
+        console.log(tag6, "networkId:", asset.networkId);
+        const pubkey = findPubkeyForNetwork(this.pubkeys, asset.networkId);
         if (!pubkey)
           throw Error("Invalid network! missing pubkey for network! " + asset.networkId);
-        let freshPriceUsd = 0;
-        try {
-          if (!asset.caip || typeof asset.caip !== "string" || !asset.caip.includes(":")) {
-            console.warn(tag6, "Invalid or missing CAIP, skipping market price fetch:", asset.caip);
-          } else {
-            console.log(tag6, "Fetching fresh market price for:", asset.caip);
-            const marketData = await this.pioneer.GetMarketInfo([asset.caip]);
-            console.log(tag6, "Market data response:", marketData);
-            if (marketData && marketData.data && marketData.data.length > 0) {
-              freshPriceUsd = marketData.data[0];
-              console.log(tag6, "✅ Fresh market price:", freshPriceUsd);
-            } else {
-              console.warn(tag6, "No market data returned for:", asset.caip);
-            }
-          }
-        } catch (marketError) {
-          console.error(tag6, "Error fetching market price:", marketError);
-        }
-        let assetInfo = this.assetsMap.get(asset.caip.toLowerCase());
-        console.log(tag6, "assetInfo: ", assetInfo);
-        if (!assetInfo) {
-          assetInfo = {
-            caip: asset.caip.toLowerCase(),
-            networkId: asset.networkId,
-            symbol: asset.symbol || "UNKNOWN",
-            name: asset.name || "Unknown Asset",
-            icon: asset.icon || "https://pioneers.dev/coins/ethereum.png"
-          };
-        }
+        const freshPriceUsd = await fetchMarketPrice(this.pioneer, asset.caip);
+        let assetInfo = resolveAssetInfo(this.assetsMap, import_pioneer_discovery2.assetData, asset);
         const matchingBalances = this.balances.filter((b) => b.caip === asset.caip);
         if (matchingBalances.length > 0) {
-          let priceValue = matchingBalances[0].priceUsd || matchingBalances[0].price;
-          if ((!priceValue || priceValue === 0) && matchingBalances[0].valueUsd && matchingBalances[0].balance) {
-            const balance = parseFloat(matchingBalances[0].balance);
-            const valueUsd = parseFloat(matchingBalances[0].valueUsd);
-            if (balance > 0 && valueUsd > 0) {
-              priceValue = valueUsd / balance;
-              console.log(tag6, "calculated priceUsd from valueUsd/balance:", priceValue);
-            }
-          }
-          if (priceValue && priceValue > 0) {
+          const priceValue = extractPriceFromBalances(matchingBalances);
+          if (priceValue > 0) {
             console.log(tag6, "detected priceUsd from balance:", priceValue);
             assetInfo.priceUsd = priceValue;
           }
         }
-        if (freshPriceUsd && freshPriceUsd > 0) {
+        if (freshPriceUsd > 0) {
           assetInfo.priceUsd = freshPriceUsd;
           console.log(tag6, "✅ Using fresh market price:", freshPriceUsd);
-          let totalBalance = 0;
-          let totalValueUsd = 0;
-          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(tag6, `  Balance entry: ${balance} (${valueUsd} USD)`);
-          }
+          const { totalBalance, totalValueUsd } = aggregateBalances(matchingBalances, asset.caip);
           assetInfo.balance = totalBalance.toString();
           assetInfo.valueUsd = totalValueUsd.toFixed(2);
-          console.log(tag6, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
         }
-        console.log(tag6, "CHECKPOINT 1");
         this.outboundAssetContext = { ...assetInfo, ...asset, ...pubkey };
-        console.log(tag6, "CHECKPOINT 3");
-        console.log(tag6, "outboundAssetContext: assetInfo: ", assetInfo);
+        console.log(tag6, "outboundAssetContext set:", this.outboundAssetContext.caip);
         if (asset.caip) {
           this.outboundBlockchainContext = import_pioneer_caip8.caipToNetworkId(asset.caip);
         } else if (asset.networkId) {
@@ -5820,28 +5860,12 @@ class SDK {
     };
   }
   CheckERC20Allowance = async (params) => {
-    const tag6 = TAG9 + " | CheckERC20Allowance | ";
-    try {
-      console.log(tag6, "Checking ERC20 allowance:", params);
-      const result = await this.pioneer.GetTokenAllowance(params);
-      console.log(tag6, "Allowance result:", result);
-      return result.data;
-    } catch (e) {
-      console.error(tag6, "Error checking ERC20 allowance:", e);
-      throw e;
-    }
+    const result = await this.pioneer.GetTokenAllowance(params);
+    return result.data;
   };
   BuildERC20ApprovalTx = async (params) => {
-    const tag6 = TAG9 + " | BuildERC20ApprovalTx | ";
-    try {
-      console.log(tag6, "Building ERC20 approval transaction:", params);
-      const result = await this.pioneer.BuildApprovalTransaction(params);
-      console.log(tag6, "Approval tx built:", result);
-      return result.data;
-    } catch (e) {
-      console.error(tag6, "Error building approval transaction:", e);
-      throw e;
-    }
+    const result = await this.pioneer.BuildApprovalTransaction(params);
+    return result.data;
   };
 }
 var src_default = SDK;