@pioneer-platform/pioneer-sdk 8.14.0 → 8.15.2

package/dist/index.js

@@ -15,6 +15,16 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -219,6 +229,545 @@ var require_split = __commonJS((exports, module) => {
   };
 });
 
+// src/charts/utils.ts
+import { assetData } from "@pioneer-platform/pioneer-discovery";
+function hydrateAssetData(caip) {
+  return assetData[caip] || assetData[caip.toLowerCase()];
+}
+function checkDuplicateBalance(balances, caip, pubkey, validator) {
+  return balances.some((b2) => b2.caip === caip && b2.pubkey === pubkey && (!validator || b2.validator === validator));
+}
+function createBalanceIdentifier(caip, pubkey) {
+  return `${caip}:${pubkey}`;
+}
+var init_utils = () => {
+};
+
+// src/charts/custom-tokens.ts
+async function fetchCustomTokens(params, balances) {
+  const { pioneer, pubkeys, blockchains, context } = params;
+  console.log(tag, "Fetching custom tokens...");
+  const evmPubkey = pubkeys.find((e) => e.networks && Array.isArray(e.networks) && e.networks.includes("eip155:*"));
+  const primaryAddress = evmPubkey?.address || evmPubkey?.master;
+  if (!primaryAddress) {
+    console.log(tag, "No EVM address found, skipping custom tokens");
+    return;
+  }
+  console.log(tag, "Using EVM address for custom tokens:", primaryAddress);
+  const supportedNetworks = blockchains.filter((net) => net.startsWith("eip155:"));
+  if (supportedNetworks.length === 0) {
+    console.log(tag, "No EVM networks for custom tokens");
+    return;
+  }
+  console.log(tag, `Checking custom tokens on ${supportedNetworks.length} networks`);
+  for (const networkId of supportedNetworks) {
+    try {
+      const response = await pioneer.GetCustomTokens({ networkId, userAddress: primaryAddress });
+      const customTokens = response?.data?.tokens || [];
+      console.log(tag, `Found ${customTokens.length} custom tokens on ${networkId}`);
+      for (const token of customTokens) {
+        const chartBalance = processCustomToken(token, primaryAddress, context, blockchains);
+        if (chartBalance && !checkDuplicateBalance(balances, chartBalance.caip, chartBalance.pubkey)) {
+          balances.push(chartBalance);
+          console.log(tag, `Added custom token: ${chartBalance.symbol} = ${chartBalance.balance}`);
+        }
+      }
+    } catch (error) {
+      console.error(tag, `Error fetching custom tokens for ${networkId}:`, error.message);
+    }
+  }
+  console.log(tag, `Custom tokens complete. Total balances: ${balances.length}`);
+}
+function processCustomToken(token, primaryAddress, context, blockchains) {
+  if (!token.assetCaip || !token.networkId) {
+    return null;
+  }
+  let extractedNetworkId = token.networkId;
+  if (token.assetCaip.includes("/denom:")) {
+    const parts = token.assetCaip.split("/denom:");
+    if (parts.length > 0) {
+      extractedNetworkId = parts[0];
+    }
+  } else if (token.networkId && token.networkId.includes("/")) {
+    extractedNetworkId = token.networkId.split("/")[0];
+  }
+  const isEip155 = extractedNetworkId.startsWith("eip155:");
+  if (!isEip155 && !blockchains.includes(extractedNetworkId)) {
+    return null;
+  }
+  const tokenAssetInfo = hydrateAssetData(token.assetCaip);
+  const tokenPubkey = token.pubkey || primaryAddress;
+  const chartBalance = {
+    context,
+    chart: "pioneer",
+    contextType: context.split(":")[0],
+    name: tokenAssetInfo?.name || token.token?.name || "Unknown Custom Token",
+    caip: token.assetCaip,
+    icon: tokenAssetInfo?.icon || token.token?.icon || "",
+    pubkey: tokenPubkey,
+    ticker: tokenAssetInfo?.symbol || token.token?.symbol || "UNK",
+    ref: `${context}${token.assetCaip}`,
+    identifier: createBalanceIdentifier(token.assetCaip, tokenPubkey),
+    networkId: extractedNetworkId,
+    symbol: tokenAssetInfo?.symbol || token.token?.symbol || "UNK",
+    type: tokenAssetInfo?.type || "erc20",
+    token: true,
+    decimal: tokenAssetInfo?.decimal || token.token?.decimal,
+    balance: token.token?.balance?.toString() || "0",
+    priceUsd: token.token?.price || 0,
+    valueUsd: token.token?.balanceUSD || 0,
+    updated: new Date().getTime()
+  };
+  return chartBalance;
+}
+var tag = "| charts-custom-tokens |";
+var init_custom_tokens = __esm(() => {
+  init_utils();
+});
+
+// src/charts/evm.ts
+async function getEvmCharts(params) {
+  const { blockchains, pioneer, pubkeys, context } = params;
+  const balances = [];
+  const evmPubkey = pubkeys.find((e) => e.networks && Array.isArray(e.networks) && e.networks.includes("eip155:*"));
+  const primaryAddress = evmPubkey?.address || evmPubkey?.master;
+  console.log(tag2, "Total pubkeys available:", pubkeys.length);
+  console.log(tag2, "Blockchains to process:", blockchains);
+  const pubkeysForBatch = [];
+  for (const pubkey of pubkeys) {
+    const address = pubkey.address || pubkey.master || pubkey.pubkey;
+    if (!address)
+      continue;
+    const supportedNetworks = pubkey.networks || [];
+    for (const blockchain of blockchains) {
+      const supportsNetwork = supportedNetworks.some((net) => net === blockchain || net.endsWith(":*") && blockchain.startsWith(net.replace(":*", ":")));
+      if (supportsNetwork) {
+        let caip;
+        if (blockchain.startsWith("eip155:")) {
+          caip = `${blockchain}/slip44:60`;
+        } else {
+          caip = `${blockchain}/slip44:0`;
+        }
+        pubkeysForBatch.push({
+          pubkey: address,
+          caip
+        });
+      }
+    }
+  }
+  console.log(tag2, `Built ${pubkeysForBatch.length} pubkey-chain combinations for batch request`);
+  if (pubkeysForBatch.length === 0) {
+    console.log(tag2, "No pubkeys to query, skipping portfolio lookup");
+    return balances;
+  }
+  if (primaryAddress) {
+    await fetchStableCoins(pioneer, primaryAddress, blockchains, balances, context);
+  }
+  await fetchCustomTokens({ blockchains, pioneer, pubkeys, context }, balances);
+  try {
+    console.log(tag2, `Calling GetPortfolio with ${pubkeysForBatch.length} pubkeys (batch + non-blocking)`);
+    let portfolio = await pioneer.GetPortfolio({
+      pubkeys: pubkeysForBatch
+    });
+    portfolio = portfolio.data?.data || portfolio.data;
+    if (!portfolio || !portfolio.balances) {
+      console.error(tag2, "No portfolio.balances found:", portfolio);
+      return balances;
+    }
+    console.log(tag2, `Portfolio returned ${portfolio.balances.length} balances`);
+    let processedCount = 0;
+    let skippedCount = 0;
+    for (const balance of portfolio.balances) {
+      const processedBalance = processPortfolioBalance(balance, primaryAddress, context, blockchains);
+      if (processedBalance) {
+        if (!checkDuplicateBalance(balances, processedBalance.caip, processedBalance.pubkey)) {
+          balances.push(processedBalance);
+          processedCount++;
+        }
+      } else {
+        skippedCount++;
+      }
+    }
+    console.log(tag2, `Processed ${processedCount} balances, skipped ${skippedCount}`);
+    if (portfolio.tokens && portfolio.tokens.length > 0) {
+      console.log(tag2, "Processing portfolio.tokens:", portfolio.tokens.length);
+      for (const token of portfolio.tokens) {
+        const processedToken = processPortfolioToken(token, primaryAddress, context, blockchains);
+        if (processedToken && !checkDuplicateBalance(balances, processedToken.caip, processedToken.pubkey)) {
+          balances.push(processedToken);
+        }
+      }
+    }
+    console.log(tag2, `Total balances (native + tokens): ${balances.length}`);
+  } catch (e) {
+    console.error(tag2, "Error fetching portfolio:", e);
+  }
+  return balances;
+}
+function processPortfolioBalance(balance, primaryAddress, context, blockchains) {
+  if (!balance.caip) {
+    console.error(tag2, "No caip found for:", balance);
+    return null;
+  }
+  const networkId = balance.caip.split("/")[0];
+  const isEip155 = networkId.startsWith("eip155:");
+  if (!isEip155 && !blockchains.includes(networkId)) {
+    return null;
+  }
+  const assetInfo = hydrateAssetData(balance.caip);
+  const balancePubkey = balance.pubkey || primaryAddress;
+  const balanceType = assetInfo?.type || balance.type || "native";
+  const isToken = balanceType !== "native" && balance.caip.includes("/erc20:");
+  let calculatedPrice = balance.priceUsd || balance.price || 0;
+  if ((!calculatedPrice || calculatedPrice === 0) && balance.valueUsd && balance.balance) {
+    const balanceNum = parseFloat(balance.balance.toString());
+    const valueNum = parseFloat(balance.valueUsd.toString());
+    if (balanceNum > 0 && valueNum > 0) {
+      calculatedPrice = valueNum / balanceNum;
+      console.log(tag2, `Calculated price from value/balance: ${calculatedPrice} for ${balance.caip}`);
+    }
+  }
+  const chartBalance = {
+    context,
+    chart: "pioneer",
+    contextType: "keepkey",
+    name: assetInfo?.name || balance.name || "Unknown",
+    caip: balance.caip,
+    icon: assetInfo?.icon || balance.icon || "",
+    pubkey: balancePubkey,
+    ticker: assetInfo?.symbol || balance.symbol || "UNK",
+    ref: `${context}${balance.caip}`,
+    identifier: createBalanceIdentifier(balance.caip, balancePubkey),
+    networkId,
+    chain: networkId,
+    symbol: assetInfo?.symbol || balance.symbol || "UNK",
+    type: balanceType,
+    token: isToken,
+    decimal: assetInfo?.decimal || balance.decimal,
+    balance: balance.balance.toString(),
+    price: calculatedPrice,
+    priceUsd: calculatedPrice,
+    valueUsd: balance.valueUsd.toString(),
+    updated: new Date().getTime()
+  };
+  if (balance.display) {
+    chartBalance.icon = ["multi", chartBalance.icon, balance.display.toString()].toString();
+  }
+  return chartBalance;
+}
+function processPortfolioToken(token, primaryAddress, context, blockchains) {
+  if (!token.assetCaip || !token.networkId) {
+    return null;
+  }
+  let extractedNetworkId = token.networkId;
+  if (token.assetCaip.includes("/denom:")) {
+    const parts = token.assetCaip.split("/denom:");
+    if (parts.length > 0) {
+      extractedNetworkId = parts[0];
+    }
+  } else if (token.networkId && token.networkId.includes("/")) {
+    extractedNetworkId = token.networkId.split("/")[0];
+  }
+  const isEip155 = extractedNetworkId.startsWith("eip155:");
+  if (!isEip155 && !blockchains.includes(extractedNetworkId)) {
+    return null;
+  }
+  const tokenAssetInfo = hydrateAssetData(token.assetCaip);
+  const tokenPubkey = token.pubkey || primaryAddress;
+  const chartBalance = {
+    context,
+    chart: "pioneer",
+    contextType: context.split(":")[0],
+    name: tokenAssetInfo?.name || token.token?.coingeckoId || token.token?.name || "Unknown",
+    caip: token.assetCaip,
+    icon: tokenAssetInfo?.icon || token.token?.icon || "",
+    pubkey: tokenPubkey,
+    ticker: tokenAssetInfo?.symbol || token.token?.symbol || "UNK",
+    ref: `${context}${token.assetCaip}`,
+    identifier: createBalanceIdentifier(token.assetCaip, tokenPubkey),
+    networkId: extractedNetworkId,
+    symbol: tokenAssetInfo?.symbol || token.token?.symbol || "UNK",
+    type: tokenAssetInfo?.type || "token",
+    token: true,
+    decimal: tokenAssetInfo?.decimal || token.token?.decimal,
+    balance: token.token?.balance?.toString() || "0",
+    priceUsd: token.token?.price || 0,
+    valueUsd: token.token?.balanceUSD || 0,
+    updated: new Date().getTime()
+  };
+  return chartBalance;
+}
+async function fetchStableCoins(pioneer, primaryAddress, blockchains, balances, context) {
+  console.log(tag2, "Fetching stable coins for redundancy...");
+  try {
+    const fastFlag = typeof process !== "undefined" && process.env && process.env.PIONEER_FAST === "1";
+    const isTestContext = typeof context === "string" && /test|e2e/i.test(context);
+    if (fastFlag || isTestContext) {
+      console.log(tag2, "Fast mode detected (test/e2e). Skipping stable coin redundancy.");
+      return;
+    }
+  } catch (_2) {
+  }
+  const supportedNetworks = ["eip155:1", "eip155:137", "eip155:8453", "eip155:56"];
+  const networksToCheck = blockchains.filter((net) => supportedNetworks.includes(net));
+  if (networksToCheck.length === 0) {
+    console.log(tag2, "No supported networks for stable coins");
+    return;
+  }
+  console.log(tag2, `Checking stable coins on ${networksToCheck.length} networks`);
+  const withTimeout2 = (p, ms) => {
+    return new Promise((resolve, reject) => {
+      const t = setTimeout(() => reject(new Error(`timeout ${ms}ms`)), ms);
+      p.then((v2) => {
+        clearTimeout(t);
+        resolve(v2);
+      }).catch((e) => {
+        clearTimeout(t);
+        reject(e);
+      });
+    });
+  };
+  const results = await Promise.allSettled(networksToCheck.map(async (networkId) => {
+    try {
+      const response = await withTimeout2(pioneer.GetStableCoins({ networkId, address: primaryAddress }), 2000);
+      const stableCoins = response?.data?.tokens || [];
+      console.log(tag2, `Found ${stableCoins.length} stable coins on ${networkId}`);
+      for (const token of stableCoins) {
+        const chartBalance = processPortfolioToken(token, primaryAddress, context, blockchains);
+        if (chartBalance && !checkDuplicateBalance(balances, chartBalance.caip, chartBalance.pubkey)) {
+          balances.push(chartBalance);
+          console.log(tag2, `Added stable coin: ${chartBalance.symbol} = ${chartBalance.balance}`);
+        }
+      }
+    } catch (error) {
+      console.error(tag2, `Error fetching stable coins for ${networkId}:`, error?.message || error);
+    }
+  }));
+  const failures = results.filter((r) => r.status === "rejected").length;
+  if (failures > 0)
+    console.log(tag2, `Stable coin fetch had ${failures} failures (non-blocking)`);
+  console.log(tag2, `Stable coin redundancy complete. Total balances: ${balances.length}`);
+}
+var tag2 = "| charts-evm |";
+var init_evm = __esm(() => {
+  init_utils();
+  init_custom_tokens();
+});
+
+// src/charts/maya.ts
+async function getMayaCharts(params, existingBalances) {
+  const { blockchains, pioneer, pubkeys, context } = params;
+  const balances = [];
+  try {
+    const mayaPubkey = pubkeys.find((p) => p.networks && Array.isArray(p.networks) && p.networks.includes("cosmos:mayachain-mainnet-v1"));
+    if (!mayaPubkey || !mayaPubkey.address) {
+      console.log(tag3, "No MAYA pubkey found, skipping MAYA token fetch");
+      return balances;
+    }
+    if (!blockchains.includes("cosmos:mayachain-mainnet-v1")) {
+      console.log(tag3, "MAYA network not in blockchains list, skipping MAYA token fetch");
+      return balances;
+    }
+    const hasMayaToken = existingBalances.some((b2) => b2.caip === "cosmos:mayachain-mainnet-v1/denom:maya");
+    if (hasMayaToken) {
+      console.log(tag3, "MAYA token already exists in balances, skipping");
+      return balances;
+    }
+    console.log(tag3, "MAYA token not found in portfolio, fetching separately...");
+    console.log(tag3, "MAYA pubkey address:", mayaPubkey.address);
+    const mayaBalanceResponse = await pioneer.GetPortfolioBalances({
+      pubkeys: [
+        {
+          caip: "cosmos:mayachain-mainnet-v1/denom:maya",
+          pubkey: mayaPubkey.address
+        }
+      ]
+    });
+    console.log(tag3, "MAYA balance response:", JSON.stringify(mayaBalanceResponse?.data, null, 2));
+    if (!mayaBalanceResponse?.data || mayaBalanceResponse.data.length === 0) {
+      console.log(tag3, "No MAYA token balance returned from GetPortfolioBalances API");
+      return balances;
+    }
+    console.log(tag3, "Found MAYA token balances:", mayaBalanceResponse.data.length);
+    for (const mayaBalance of mayaBalanceResponse.data) {
+      if (mayaBalance.caip !== "cosmos:mayachain-mainnet-v1/denom:maya") {
+        console.log(tag3, "Unexpected balance in MAYA response:", mayaBalance);
+        continue;
+      }
+      const mayaAssetInfo = hydrateAssetData(mayaBalance.caip);
+      const isToken = mayaBalance.caip.includes("/denom:") && !mayaBalance.caip.endsWith("/denom:cacao");
+      const mayaTokenBalance = {
+        context,
+        chart: "pioneer",
+        contextType: context.split(":")[0],
+        name: mayaAssetInfo?.name || "Maya Token",
+        caip: mayaBalance.caip,
+        icon: mayaAssetInfo?.icon || "https://pioneers.dev/coins/maya.png",
+        pubkey: mayaPubkey.address,
+        ticker: mayaAssetInfo?.symbol || "MAYA",
+        ref: `${context}${mayaBalance.caip}`,
+        identifier: createBalanceIdentifier(mayaBalance.caip, mayaPubkey.address),
+        networkId: "cosmos:mayachain-mainnet-v1",
+        symbol: mayaAssetInfo?.symbol || "MAYA",
+        type: mayaAssetInfo?.type || "token",
+        token: isToken,
+        decimal: mayaAssetInfo?.decimal,
+        balance: mayaBalance.balance?.toString() || "0",
+        priceUsd: parseFloat(mayaBalance.priceUsd) || 0,
+        valueUsd: parseFloat(mayaBalance.valueUsd) || 0,
+        updated: new Date().getTime()
+      };
+      console.log(tag3, "Adding MAYA token to balances:", mayaTokenBalance);
+      balances.push(mayaTokenBalance);
+    }
+  } catch (mayaError) {
+    console.error(tag3, "Error fetching MAYA token balance:", mayaError);
+  }
+  return balances;
+}
+var tag3 = "| charts-maya |";
+var init_maya = __esm(() => {
+  init_utils();
+});
+
+// src/charts/cosmos-staking.ts
+async function getCosmosStakingCharts(params) {
+  const { blockchains, pioneer, pubkeys, context } = params;
+  const balances = [];
+  try {
+    try {
+      const fastFlag = typeof process !== "undefined" && process.env && process.env.PIONEER_FAST === "1";
+      const isTestContext = typeof context === "string" && /test|e2e/i.test(context);
+      if (fastFlag || isTestContext) {
+        console.log(tag4, "Fast mode detected (test/e2e). Skipping cosmos staking fetch.");
+        return balances;
+      }
+    } catch (_2) {
+    }
+    console.log(tag4, "Adding Cosmos staking positions to charts...");
+    const cosmosPubkeys = pubkeys.filter((p) => p.networks && Array.isArray(p.networks) && p.networks.some((n) => n.includes("cosmos:cosmoshub") || n.includes("cosmos:osmosis")));
+    if (cosmosPubkeys.length === 0) {
+      console.log(tag4, "No cosmos pubkeys found for staking positions");
+      return balances;
+    }
+    console.log(tag4, "Found cosmos pubkeys for staking:", cosmosPubkeys.length);
+    await Promise.allSettled(cosmosPubkeys.map(async (cosmosPubkey) => {
+      if (!cosmosPubkey.address)
+        return;
+      const cosmosNetworks = cosmosPubkey.networks.filter((n) => n.includes("cosmos:cosmoshub") || n.includes("cosmos:osmosis"));
+      await Promise.allSettled(cosmosNetworks.filter((networkId) => blockchains.includes(networkId)).map(async (networkId) => {
+        await fetchStakingPositionsForNetwork(networkId, cosmosPubkey.address, context, pioneer, balances);
+      }));
+    }));
+  } catch (e) {
+    console.error(tag4, "Error adding cosmos staking positions:", e);
+  }
+  return balances;
+}
+async function fetchStakingPositionsForNetwork(networkId, address, context, pioneer, balances) {
+  try {
+    console.log(tag4, `Fetching staking positions for ${address} on ${networkId}...`);
+    let network;
+    if (networkId === "cosmos:cosmoshub-4") {
+      network = "cosmos";
+    } else if (networkId === "cosmos:osmosis-1") {
+      network = "osmosis";
+    } else {
+      console.error(tag4, `Unsupported networkId for staking: ${networkId}`);
+      return;
+    }
+    const stakingResponse = await pioneer.GetStakingPositions({
+      network,
+      address
+    });
+    if (!stakingResponse?.data || !Array.isArray(stakingResponse.data)) {
+      console.log(tag4, `No staking positions found for ${address} on ${networkId}`);
+      return;
+    }
+    console.log(tag4, `Found ${stakingResponse.data.length} staking positions for ${networkId}`);
+    for (const position of stakingResponse.data) {
+      const processedPosition = processStakingPosition(position, address, context, networkId);
+      if (processedPosition && !checkDuplicateBalance(balances, processedPosition.caip, processedPosition.pubkey, processedPosition.validator)) {
+        balances.push(processedPosition);
+        console.log(tag4, `Added ${position.type} position:`, {
+          balance: processedPosition.balance,
+          ticker: processedPosition.ticker,
+          valueUsd: processedPosition.valueUsd,
+          validator: processedPosition.validator
+        });
+      }
+    }
+  } catch (stakingError) {
+    console.error(tag4, `Error fetching staking positions for ${address} on ${networkId}:`, stakingError);
+  }
+}
+function processStakingPosition(position, address, context, networkId) {
+  if (!position.balance || position.balance <= 0 || !position.caip) {
+    return null;
+  }
+  const stakingAssetInfo = hydrateAssetData(position.caip);
+  const stakingBalance = {
+    context,
+    chart: "staking",
+    contextType: context.split(":")[0],
+    name: stakingAssetInfo?.name || position.name || `${position.type} Position`,
+    caip: position.caip,
+    icon: stakingAssetInfo?.icon || position.icon || "",
+    pubkey: address,
+    ticker: stakingAssetInfo?.symbol || position.ticker || position.symbol || "UNK",
+    ref: `${context}${position.caip}`,
+    identifier: createBalanceIdentifier(position.caip, address),
+    networkId,
+    symbol: stakingAssetInfo?.symbol || position.symbol || position.ticker || "UNK",
+    type: stakingAssetInfo?.type || position.type || "staking",
+    token: false,
+    decimal: stakingAssetInfo?.decimal,
+    balance: position.balance.toString(),
+    priceUsd: position.priceUsd || 0,
+    valueUsd: position.valueUsd || position.balance * (position.priceUsd || 0),
+    status: position.status || "active",
+    validator: position.validatorAddress || position.validator || "",
+    updated: new Date().getTime()
+  };
+  return stakingBalance;
+}
+var tag4 = "| charts-cosmos-staking |";
+var init_cosmos_staking = __esm(() => {
+  init_utils();
+});
+// src/charts/index.ts
+var exports_charts = {};
+__export(exports_charts, {
+  getCharts: () => getCharts
+});
+var tag5 = "| getCharts |", getCharts = async (blockchains, pioneer, pubkeys, context) => {
+  try {
+    const balances = [];
+    console.log(tag5, "init");
+    const params = {
+      blockchains,
+      pioneer,
+      pubkeys,
+      context
+    };
+    const evmBalances = await getEvmCharts(params);
+    balances.push(...evmBalances);
+    const mayaBalances = await getMayaCharts(params, balances);
+    balances.push(...mayaBalances);
+    const stakingBalances = await getCosmosStakingCharts(params);
+    balances.push(...stakingBalances);
+    return balances;
+  } catch (error) {
+    console.error(tag5, "Error processing charts:", error);
+    throw error;
+  }
+};
+var init_charts = __esm(() => {
+  init_evm();
+  init_maya();
+  init_cosmos_staking();
+});
+
 // src/index.ts
 import { KeepKeySdk } from "@keepkey/keepkey-sdk";
 import { caipToNetworkId as caipToNetworkId7, networkIdToCaip as networkIdToCaip2 } from "@pioneer-platform/pioneer-caip";
@@ -367,7 +916,7 @@ class Pioneer {
 
 // src/index.ts
 import { addressNListToBIP32 as addressNListToBIP322, getPaths } from "@pioneer-platform/pioneer-coins";
-import { assetData } from "@pioneer-platform/pioneer-discovery";
+import { assetData as assetData2 } from "@pioneer-platform/pioneer-discovery";
 import { Events } from "@pioneer-platform/pioneer-events";
 
 // node:events
@@ -2945,6 +3494,10 @@ async function getFees(pioneer, networkId) {
       console.log(tag, "Using hardcoded fees for Cosmos network:", networkId);
       return getCosmosFees(networkId);
     }
+    if (networkId === "ripple:4109c6f2045fc7eff4cde8f9905d19c2") {
+      console.log(tag, "Using hardcoded fees for Ripple: 0.00001 XRP");
+      return getRippleFees(networkId);
+    }
     if (networkId === "bip122:00000000001a91e3dace36e2be3bf030") {
       console.log(tag, "Using hardcoded fees for Dogecoin: 10 sat/byte");
       return {
@@ -3271,6 +3824,39 @@ function getCosmosFees(networkId) {
     raw: { hardcoded: true, base: feeConfig.base, unit: feeConfig.unit, denom: feeConfig.denom }
   };
 }
+function getRippleFees(networkId) {
+  const networkName = getNetworkName(networkId);
+  const standardFee = "0.00001";
+  return {
+    slow: {
+      label: "Standard",
+      value: standardFee,
+      unit: "XRP",
+      description: `Fixed fee for ${networkName}. XRP uses a deterministic fee model.`,
+      estimatedTime: "~4 seconds",
+      priority: "low"
+    },
+    average: {
+      label: "Standard",
+      value: standardFee,
+      unit: "XRP",
+      description: `Fixed fee for ${networkName}. XRP uses a deterministic fee model.`,
+      estimatedTime: "~4 seconds",
+      priority: "medium"
+    },
+    fastest: {
+      label: "Standard",
+      value: standardFee,
+      unit: "XRP",
+      description: `Fixed fee for ${networkName}. XRP uses a deterministic fee model.`,
+      estimatedTime: "~4 seconds",
+      priority: "high"
+    },
+    networkId,
+    networkType: "RIPPLE",
+    raw: { hardcoded: true, fee: standardFee, unit: "XRP" }
+  };
+}
 function getFallbackFees(networkId) {
   const networkType = getNetworkType(networkId);
   const networkName = getNetworkName(networkId);
@@ -3669,7 +4255,7 @@ class SDK {
     this.appIcon = config.appIcon || "https://pioneers.dev/coins/keepkey.png";
     this.spec = spec || config.spec || "https://api.keepkey.info/spec/swagger";
     this.wss = config.wss || "wss://api.keepkey.info";
-    this.assets = assetData;
+    this.assets = assetData2;
     this.assetsMap = new Map;
     this.username = config.username;
     this.queryKey = config.queryKey;
@@ -3720,9 +4306,9 @@ class SDK {
       fallbackToRemote: true
     }) : null;
     this.pairWallet = async (options) => {
-      const tag = TAG9 + " | pairWallet | ";
+      const tag6 = TAG9 + " | pairWallet | ";
       if (this.viewOnlyMode || this.skipDevicePairing) {
-        console.log(tag, "\uD83D\uDC41️ [VIEW-ONLY] Skipping device pairing");
+        console.log(tag6, "\uD83D\uDC41️ [VIEW-ONLY] Skipping device pairing");
         return {
           success: false,
           reason: "view-only-mode",
@@ -3763,7 +4349,7 @@ class SDK {
       return true;
     };
     this.setPubkeys = (newPubkeys) => {
-      const tag = `${TAG9} | setPubkeys | `;
+      const tag6 = `${TAG9} | setPubkeys | `;
       this.pubkeys = [];
       this.pubkeySet.clear();
       let added = 0;
@@ -3789,7 +4375,7 @@ class SDK {
       return !!this.keepkeyEndpoint && this.keepkeyEndpoint.isAvailable;
     };
     this.getUnifiedPortfolio = async function() {
-      const tag = `${TAG9} | getUnifiedPortfolio | `;
+      const tag6 = `${TAG9} | getUnifiedPortfolio | `;
       try {
         const startTime = performance.now();
         try {
@@ -3800,17 +4386,17 @@ class SDK {
             signal: AbortSignal.timeout(2000)
           });
           if (!portfolioResponse.ok) {
-            console.warn(tag, "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(tag, "Portfolio API returned success=false");
+            console.warn(tag6, "Portfolio API returned success=false");
             return null;
           }
           if (portfolioData.totalValueUsd === 0 || !portfolioData.totalValueUsd) {
-            console.warn(tag, "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 = [];
@@ -3897,14 +4483,14 @@ class SDK {
           };
         } catch (fetchError) {
           if (fetchError.name === "AbortError") {
-            console.log(tag, "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(tag, "Failed to fetch unified portfolio:", fetchError.message);
+            console.log(tag6, "Failed to fetch unified portfolio:", fetchError.message);
           }
           return null;
         }
       } catch (e) {
-        console.error(tag, "Error:", e);
+        console.error(tag6, "Error:", e);
         return null;
       }
     };
@@ -3915,7 +4501,7 @@ class SDK {
       return this.syncState.isSynced;
     };
     this.init = async function(walletsVerbose, setup) {
-      const tag = `${TAG9} | init | `;
+      const tag6 = `${TAG9} | init | `;
       try {
         if (!this.username)
           throw Error("username required!");
@@ -3980,11 +4566,11 @@ class SDK {
           this.events.emit("message", request);
         });
         clientEvents.events.on("balance:update", (data) => {
-          const tag2 = TAG9 + " | balance:update | ";
+          const tag7 = TAG9 + " | balance:update | ";
           try {
             const payload = typeof data === "string" ? JSON.parse(data) : data;
             const balance = payload.balance;
-            console.log(tag2, "Received balance update:", balance.caip);
+            console.log(tag7, "Received balance update:", balance.caip);
             const exists = this.balances.find((b2) => b2.caip === balance.caip && b2.pubkey === balance.pubkey);
             if (!exists) {
               this.balances.push(balance);
@@ -3994,27 +4580,27 @@ class SDK {
             }
             this.events.emit("BALANCE_UPDATE", balance);
           } catch (e) {
-            console.error(tag2, "Error processing balance update:", e);
+            console.error(tag7, "Error processing balance update:", e);
           }
         });
         clientEvents.events.on("sync:progress", (data) => {
-          const tag2 = TAG9 + " | sync:progress | ";
+          const tag7 = TAG9 + " | sync:progress | ";
           try {
             const payload = typeof data === "string" ? JSON.parse(data) : data;
-            console.log(tag2, `Sync progress: ${payload.percentage}%`);
+            console.log(tag7, `Sync progress: ${payload.percentage}%`);
             this.syncState.syncProgress = payload.percentage;
             this.syncState.syncedChains = payload.completed;
             this.syncState.totalChains = payload.total;
             this.events.emit("SYNC_PROGRESS", this.syncState);
           } catch (e) {
-            console.error(tag2, "Error processing sync progress:", e);
+            console.error(tag7, "Error processing sync progress:", e);
           }
         });
         clientEvents.events.on("sync:complete", (data) => {
-          const tag2 = TAG9 + " | sync:complete | ";
+          const tag7 = TAG9 + " | sync:complete | ";
           try {
             const payload = typeof data === "string" ? JSON.parse(data) : data;
-            console.log(tag2, `Sync complete: ${payload.balances} balances in ${payload.duration}ms`);
+            console.log(tag7, `Sync complete: ${payload.balances} balances in ${payload.duration}ms`);
             this.syncState.isSynced = true;
             this.syncState.isInitialSync = false;
             this.syncState.syncProgress = 100;
@@ -4023,7 +4609,7 @@ class SDK {
             this.events.emit("SYNC_COMPLETE", this.syncState);
             this.events.emit("SYNC_STATE_CHANGED", this.syncState);
           } catch (e) {
-            console.error(tag2, "Error processing sync complete:", e);
+            console.error(tag7, "Error processing sync complete:", e);
           }
         });
         this.events.emit("SET_STATUS", "init");
@@ -4055,18 +4641,27 @@ class SDK {
         }
         return this.pioneer;
       } catch (e) {
-        console.error(tag, "e: ", e);
+        console.error(tag6, "e: ", e);
         throw e;
       }
     };
     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 tag = `${TAG9} | sync | `;
+      const tag6 = `${TAG9} | sync | `;
       try {
         const matchesNetwork = (item, networkId) => {
           if (!item.networks || !Array.isArray(item.networks))
@@ -4110,9 +4705,9 @@ class SDK {
           }
         }
         await this.getBalances();
-        console.log(tag, "Loading charts (tokens + portfolio)...");
+        console.log(tag6, "Loading charts (tokens + portfolio)...");
         await this.getCharts();
-        console.log(tag, `Charts loaded. Total balances: ${this.balances.length}`);
+        console.log(tag6, `Charts loaded. Total balances: ${this.balances.length}`);
         await this.syncMarket();
         const dashboardData = {
           networks: [],
@@ -4201,7 +4796,7 @@ class SDK {
         this.events.emit("SYNC_COMPLETE", this.syncState);
         return true;
       } catch (e) {
-        console.error(tag, "Error in sync:", e);
+        console.error(tag6, "Error in sync:", e);
         throw e;
       }
     };
@@ -4215,7 +4810,7 @@ class SDK {
       }
     };
     this.buildTx = async function(sendPayload) {
-      let tag = TAG9 + " | buildTx | ";
+      let tag6 = TAG9 + " | buildTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4229,7 +4824,7 @@ class SDK {
         };
         let txManager = new TransactionManager(transactionDependencies, this.events);
         let unsignedTx = await txManager.transfer(sendPayload);
-        console.log(tag, "unsignedTx: ", unsignedTx);
+        console.log(tag6, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -4237,14 +4832,14 @@ class SDK {
       }
     };
     this.buildDelegateTx = async function(caip, params) {
-      let tag = 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(tag, "unsignedTx: ", unsignedTx);
+        console.log(tag6, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -4252,14 +4847,14 @@ class SDK {
       }
     };
     this.buildUndelegateTx = async function(caip, params) {
-      let tag = 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(tag, "unsignedTx: ", unsignedTx);
+        console.log(tag6, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -4267,14 +4862,14 @@ class SDK {
       }
     };
     this.buildClaimRewardsTx = async function(caip, params) {
-      let tag = 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(tag, "unsignedTx: ", unsignedTx);
+        console.log(tag6, "unsignedTx: ", unsignedTx);
         return unsignedTx;
       } catch (e) {
         console.error(e);
@@ -4282,7 +4877,7 @@ class SDK {
       }
     };
     this.buildClaimAllRewardsTx = async function(caip, params) {
-      let tag = TAG9 + " | buildClaimAllRewardsTx | ";
+      let tag6 = TAG9 + " | buildClaimAllRewardsTx | ";
       try {
         const claimAllParams = {
           ...params,
@@ -4296,7 +4891,7 @@ class SDK {
       }
     };
     this.signTx = async function(caip, unsignedTx) {
-      let tag = TAG9 + " | signTx | ";
+      let tag6 = TAG9 + " | signTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4317,7 +4912,7 @@ class SDK {
       }
     };
     this.broadcastTx = async function(caip, signedTx) {
-      let tag = TAG9 + " | broadcastTx | ";
+      let tag6 = TAG9 + " | broadcastTx | ";
       try {
         const transactionDependencies = {
           context: this.context,
@@ -4341,7 +4936,7 @@ class SDK {
       }
     };
     this.swap = async function(swapPayload) {
-      let tag = `${TAG9} | swap | `;
+      let tag6 = `${TAG9} | swap | `;
       try {
         if (!swapPayload)
           throw Error("swapPayload required!");
@@ -4390,15 +4985,15 @@ class SDK {
             throw new Error(`Cannot use max amount: no balance found for ${swapPayload.caipIn}`);
           }
           let totalBalance = 0;
-          console.log(tag, `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(tag, `  - ${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(tag, `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,
@@ -4409,7 +5004,7 @@ class SDK {
           };
           const reserve = feeReserves[swapPayload.caipIn] || 0.0001;
           inputAmount = Math.max(0, totalBalance - reserve);
-          console.log(tag, `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) {
@@ -4429,7 +5024,7 @@ class SDK {
           result = await this.pioneer.Quote(quote);
           result = result.data;
         } catch (e) {
-          console.error(tag, "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 || result.length === 0)
@@ -4456,16 +5051,16 @@ class SDK {
           if (tx.type === "deposit") {
             unsignedTx = await createUnsignedTendermintTx(caip, tx.type, tx.txParams.amount, tx.txParams.memo, this.pubkeys, this.pioneer, this.pubkeyContext, false, undefined);
           } else if (tx.type === "EVM" || tx.type === "evm") {
-            console.log(tag, "Building EVM swap transaction with createUnsignedEvmTx");
+            console.log(tag6, "Building EVM swap transaction with createUnsignedEvmTx");
             unsignedTx = await createUnsignedEvmTx(caip, tx.txParams.recipientAddress, parseFloat(tx.txParams.amount), tx.txParams.memo, this.pubkeys, this.pioneer, this.pubkeyContext, false);
-            console.log(tag, "✅ Built complete EVM transaction:", {
+            console.log(tag6, "✅ Built complete EVM transaction:", {
               to: unsignedTx.to,
               from: this.pubkeyContext?.address,
               value: unsignedTx.value,
               chainId: unsignedTx.chainId,
               hasData: !!unsignedTx.data
             });
-            console.log(tag, "\uD83D\uDEE1️  Running Tenderly simulation for EVM swap...");
+            console.log(tag6, "\uD83D\uDEE1️  Running Tenderly simulation for EVM swap...");
             try {
               const insightResult = await this.pioneer.Insight({
                 tx: unsignedTx,
@@ -4473,15 +5068,15 @@ class SDK {
                 isThorchainSwap: tx.txParams.isThorchainSwap || false
               });
               const insight = insightResult.body;
-              console.log(tag, "Simulation result:", insight?.simulation);
+              console.log(tag6, "Simulation result:", insight?.simulation);
               if (!insight || !insight.simulation) {
-                console.warn(tag, "⚠️  WARNING: Tenderly simulation unavailable - proceeding without validation");
+                console.warn(tag6, "⚠️  WARNING: Tenderly simulation unavailable - proceeding without validation");
               } else if (!insight.simulation.success) {
-                console.warn(tag, `⚠️  WARNING: Swap simulation FAILED - ${insight.simulation.error || "Transaction may revert"}`);
-                console.warn(tag, "⚠️  Proceeding anyway - USE CAUTION");
+                console.warn(tag6, `⚠️  WARNING: Swap simulation FAILED - ${insight.simulation.error || "Transaction may revert"}`);
+                console.warn(tag6, "⚠️  Proceeding anyway - USE CAUTION");
               } else {
                 if (tx.txParams.isThorchainSwap) {
-                  console.log(tag, "\uD83D\uDD0D Verifying THORChain swap parameters...");
+                  console.log(tag6, "\uD83D\uDD0D Verifying THORChain swap parameters...");
                   const method = insight.simulation.method;
                   if (!method || !method.toLowerCase().includes("deposit")) {
                     throw new Error(`❌ CRITICAL: Invalid THORChain swap method: ${method} - expected depositWithExpiry`);
@@ -4492,20 +5087,20 @@ class SDK {
                     if (routerAddress.toLowerCase() === vaultAddress.toLowerCase()) {
                       throw new Error(`❌ CRITICAL: Sending directly to vault ${vaultAddress} instead of router!`);
                     }
-                    console.log(tag, `✅ Router: ${routerAddress}`);
-                    console.log(tag, `✅ Vault: ${vaultAddress}`);
+                    console.log(tag6, `✅ Router: ${routerAddress}`);
+                    console.log(tag6, `✅ Vault: ${vaultAddress}`);
                   }
                   if (insight.simulation.addresses && insight.simulation.addresses.length > 0) {
-                    console.log(tag, `✅ Addresses involved: ${insight.simulation.addresses.length}`);
+                    console.log(tag6, `✅ Addresses involved: ${insight.simulation.addresses.length}`);
                   } else {
-                    console.log(tag, "⚠️  WARNING: No addresses detected in simulation");
+                    console.log(tag6, "⚠️  WARNING: No addresses detected in simulation");
                   }
                 }
-                console.log(tag, `✅ Simulation PASSED - Gas used: ${insight.simulation.gasUsed}`);
-                console.log(tag, `✅ Method: ${insight.simulation.method}`);
+                console.log(tag6, `✅ Simulation PASSED - Gas used: ${insight.simulation.gasUsed}`);
+                console.log(tag6, `✅ Method: ${insight.simulation.method}`);
               }
             } catch (e) {
-              console.error(tag, "❌ Simulation validation failed:", e.message);
+              console.error(tag6, "❌ Simulation validation failed:", e.message);
               throw new Error(`Swap blocked by simulation failure: ${e.message}`);
             }
           } else {
@@ -4525,12 +5120,12 @@ class SDK {
           return unsignedTx;
         }
       } catch (e) {
-        console.error(tag, "Error: ", e);
+        console.error(tag6, "Error: ", e);
         throw e;
       }
     };
     this.transfer = async function(sendPayload) {
-      let tag = `${TAG9} | transfer | `;
+      let tag6 = `${TAG9} | transfer | `;
       try {
         if (!sendPayload)
           throw Error("sendPayload required!");
@@ -4564,15 +5159,15 @@ class SDK {
         return { txid, events: this.events };
       } catch (error) {
         if (error instanceof Error) {
-          console.error(tag, "An error occurred during the transfer process:", error.message);
+          console.error(tag6, "An error occurred during the transfer process:", error.message);
         } else {
-          console.error(tag, "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 tag = " | followTransaction | ";
+      let tag6 = " | followTransaction | ";
       try {
         const finalConfirmationBlocksByCaip = {
           dogecoin: 3,
@@ -4602,7 +5197,7 @@ class SDK {
               }
             }
           } catch (error) {
-            console.error(tag, "Error:", error);
+            console.error(tag6, "Error:", error);
           }
           if (!isConfirmed) {
             await new Promise((resolve) => setTimeout(resolve, 8000));
@@ -4620,18 +5215,18 @@ class SDK {
           requiredConfirmations
         };
       } catch (error) {
-        console.error(tag, "Error:", error);
+        console.error(tag6, "Error:", error);
         throw new Error("Failed to follow transaction");
       }
     };
     this.setBlockchains = async function(blockchains) {
-      const tag = `${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(tag, `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);
@@ -4641,12 +5236,12 @@ class SDK {
       }
     };
     this.addAsset = async function(caip, data) {
-      let tag = TAG9 + " | addAsset | ";
+      let tag6 = TAG9 + " | addAsset | ";
       try {
         let success = false;
         if (!caip)
           throw new Error("caip required!");
-        let dataLocal = assetData[caip];
+        let dataLocal = assetData2[caip];
         if (!dataLocal) {
           if (!data.networkId)
             throw new Error("networkId required! can not build asset");
@@ -4679,22 +5274,22 @@ class SDK {
       }
     };
     this.clearWalletState = async function() {
-      const tag = `${TAG9} | clearWalletState | `;
+      const tag6 = `${TAG9} | clearWalletState | `;
       try {
         this.context = null;
         this.paths = [];
         this.blockchains = [];
         this.pubkeys = [];
         this.pubkeySet.clear();
-        console.log(tag, "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(tag, "e: ", e);
+        console.error(tag6, "e: ", e);
         throw e;
       }
     };
     this.addPath = async function(path) {
-      const tag = `${TAG9} | addPath | `;
+      const tag6 = `${TAG9} | addPath | `;
       try {
         this.paths.push(path);
         const pubkey = await getPubkey(path.networks[0], path, this.keepKeySdk, this.context);
@@ -4703,14 +5298,14 @@ class SDK {
         this.buildDashboardFromBalances();
         return { success: true, pubkey };
       } catch (e) {
-        console.error(tag, "Failed:", e);
+        console.error(tag6, "Failed:", e);
         throw e;
       }
     };
     this.addPaths = async function(paths) {
-      const tag = `${TAG9} | addPaths | `;
+      const tag6 = `${TAG9} | addPaths | `;
       try {
-        console.log(tag, `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) {
@@ -4719,10 +5314,10 @@ class SDK {
             this.addPubkey(pubkey);
             newPubkeys.push(pubkey);
           } catch (error) {
-            console.warn(tag, `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(tag, `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)) {
@@ -4730,13 +5325,13 @@ class SDK {
           }
         }
         const uniqueNetworks = [...networkSet];
-        console.log(tag, `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(tag, `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(tag, "Failed:", e);
+        console.error(tag6, "Failed:", e);
         throw e;
       }
     };
@@ -4744,12 +5339,12 @@ class SDK {
       return this.getGasAssets();
     };
     this.getGasAssets = async function() {
-      const tag = `${TAG9} | getGasAssets | `;
+      const tag6 = `${TAG9} | getGasAssets | `;
       try {
         for (let i = 0;i < this.blockchains.length; i++) {
           let networkId = this.blockchains[i];
           let caip = networkIdToCaip2(networkId);
-          let asset = await assetData[caip.toLowerCase()];
+          let asset = await assetData2[caip.toLowerCase()];
           if (asset) {
             asset.caip = caip.toLowerCase();
             asset.networkId = networkId;
@@ -4778,7 +5373,7 @@ class SDK {
             denom: "maya"
           };
           this.assetsMap.set(mayaTokenCaip, mayaToken);
-          console.log(tag, "Added MAYA token to assetsMap");
+          console.log(tag6, "Added MAYA token to assetsMap");
         }
         return this.assetsMap;
       } catch (e) {
@@ -4787,7 +5382,7 @@ class SDK {
       }
     };
     this.getPubkeys = async function() {
-      const tag = `${TAG9} | getPubkeys | `;
+      const tag6 = `${TAG9} | getPubkeys | `;
       try {
         if (this.paths.length === 0)
           throw new Error("No paths found!");
@@ -4801,43 +5396,46 @@ class SDK {
         }
         const pubkeysWithoutNetworks = this.pubkeys.filter((pk) => !pk.networks || !Array.isArray(pk.networks) || pk.networks.length === 0);
         if (pubkeysWithoutNetworks.length > 0) {
-          console.error(tag, "ERROR: Some pubkeys missing networks field!");
-          console.error(tag, "Affected pubkeys:", pubkeysWithoutNetworks.length);
+          console.error(tag6, "ERROR: Some pubkeys missing networks field!");
+          console.error(tag6, "Affected pubkeys:", pubkeysWithoutNetworks.length);
           pubkeysWithoutNetworks.forEach((pk) => {
-            console.error(tag, `  - ${pk.note || pk.pubkey}: networks=${pk.networks}`);
+            console.error(tag6, `  - ${pk.note || pk.pubkey}: networks=${pk.networks}`);
           });
           for (const pubkey of pubkeysWithoutNetworks) {
             const matchingPath = this.paths.find((p) => JSON.stringify(p.addressNList) === JSON.stringify(pubkey.addressNList));
             if (matchingPath && matchingPath.networks) {
-              console.warn(tag, `  ⚠️ Auto-fixing: Adding networks from path ${matchingPath.note}`);
+              console.warn(tag6, `  ⚠️ Auto-fixing: Adding networks from path ${matchingPath.note}`);
               pubkey.networks = matchingPath.networks;
             }
           }
           const stillMissing = this.pubkeys.filter((pk) => !pk.networks || !Array.isArray(pk.networks) || pk.networks.length === 0);
           if (stillMissing.length > 0) {
-            console.error(tag, `❌ CRITICAL: ${stillMissing.length} pubkeys still missing networks after auto-fix!`);
+            console.error(tag6, `❌ CRITICAL: ${stillMissing.length} pubkeys still missing networks after auto-fix!`);
             stillMissing.forEach((pk) => {
-              console.error(tag, `  - ${pk.note || pk.pubkey}`);
+              console.error(tag6, `  - ${pk.note || pk.pubkey}`);
             });
           } else {
-            console.log(tag, `✅ Auto-fix successful: All pubkeys now have networks field`);
+            console.log(tag6, `✅ Auto-fix successful: All pubkeys now have networks field`);
           }
         }
         this.events.emit("SET_PUBKEYS", this.pubkeys);
         return pubkeys;
       } catch (error) {
         console.error("Error in getPubkeys:", error);
-        console.error(tag, "Error in getPubkeys:", error);
+        console.error(tag6, "Error in getPubkeys:", error);
         throw error;
       }
     };
-    this.getBalancesForNetworks = async function(networkIds) {
-      const tag = `${TAG9} | getBalancesForNetworks | `;
+    this.getBalancesForNetworks = async function(networkIds, forceRefresh) {
+      const tag6 = `${TAG9} | getBalancesForNetworks | `;
       try {
         if (!this.pioneer) {
-          console.error(tag, "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.");
         }
+        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));
@@ -4863,20 +5461,20 @@ class SDK {
             return network === adjustedNetworkId;
           }));
           if (pubkeys.length === 0) {
-            console.warn(tag, `⚠️ No pubkeys found for ${networkId} with networks field`);
-            console.warn(tag, "Attempting fallback: finding pubkeys by path matching");
+            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(tag, `  ✓ Found pubkey via path matching: ${matchingPubkey.note || matchingPubkey.pubkey.slice(0, 10)}`);
+                console.warn(tag6, `  ✓ Found pubkey via path matching: ${matchingPubkey.note || matchingPubkey.pubkey.slice(0, 10)}`);
                 pubkeys.push(matchingPubkey);
               }
             }
             if (pubkeys.length > 0) {
-              console.warn(tag, `  ✅ Fallback successful: Found ${pubkeys.length} pubkeys for ${networkId}`);
+              console.warn(tag6, `  ✅ Fallback successful: Found ${pubkeys.length} pubkeys for ${networkId}`);
             } else {
-              console.error(tag, `  ❌ Fallback failed: No pubkeys found for ${networkId}`);
+              console.error(tag6, `  ❌ Fallback failed: No pubkeys found for ${networkId}`);
             }
           }
           const caipNative = await networkIdToCaip2(networkId);
@@ -4898,7 +5496,7 @@ class SDK {
         const apiCallStart = performance.now();
         console.time("GetPortfolioBalances Response Time");
         try {
-          let marketInfo = await this.pioneer.GetPortfolioBalances({ pubkeys: assetQuery });
+          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`);
@@ -4908,10 +5506,23 @@ class SDK {
           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)
+            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: caipToNetworkId7(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: caipToNetworkId7(balance.caip),
               icon: assetInfo.icon || "https://pioneers.dev/coins/etherum.png",
               identifier: `${balance.caip}:${balance.pubkey}`,
@@ -4933,43 +5544,43 @@ class SDK {
           console.log(`⏱️  [PERF] Total getBalancesForNetworks: ${(performance.now() - apiCallStart).toFixed(0)}ms`);
           return this.balances;
         } catch (apiError) {
-          console.error(tag, "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(tag, "Error: ", e);
+        console.error(tag6, "Error: ", e);
         throw e;
       }
     };
-    this.getBalances = async function() {
-      const tag = `${TAG9} | getBalances | `;
+    this.getBalances = async function(forceRefresh) {
+      const tag6 = `${TAG9} | getBalances | `;
       try {
-        return await this.getBalancesForNetworks(this.blockchains);
+        return await this.getBalancesForNetworks(this.blockchains, forceRefresh);
       } catch (e) {
-        console.error(tag, "Error in getBalances: ", e);
+        console.error(tag6, "Error in getBalances: ", e);
         throw e;
       }
     };
     this.getBalance = async function(networkId) {
-      const tag = `${TAG9} | getBalance | `;
+      const tag6 = `${TAG9} | getBalance | `;
       try {
         const results = await this.getBalancesForNetworks([networkId]);
         const filtered = results.filter(async (b2) => b2.networkId === await networkIdToCaip2(networkId));
         return filtered;
       } catch (e) {
-        console.error(tag, "Error: ", e);
+        console.error(tag6, "Error: ", e);
         throw e;
       }
     };
     this.getFees = async function(networkId) {
-      const tag = `${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(tag, "Error getting fees: ", e);
+        console.error(tag6, "Error getting fees: ", e);
         throw e;
       }
     };
@@ -4977,42 +5588,12 @@ class SDK {
       return estimateTransactionFee(feeRate, unit, networkType, txSize);
     };
     this.getCharts = async function() {
-      const tag = `${TAG9} | getCharts | `;
+      const tag6 = `${TAG9} | getCharts | `;
       try {
-        console.log(tag, "Fetching charts from batch endpoint");
-        const pubkeysForBatch = [];
-        for (const pubkey of this.pubkeys) {
-          const address = pubkey.address || pubkey.master || pubkey.pubkey;
-          if (!address)
-            continue;
-          const supportedNetworks = pubkey.networks || [];
-          for (const blockchain of this.blockchains) {
-            const supportsNetwork = supportedNetworks.some((net) => net === blockchain || net.endsWith(":*") && blockchain.startsWith(net.replace(":*", ":")));
-            if (supportsNetwork) {
-              let caip;
-              if (blockchain.startsWith("eip155:")) {
-                caip = `${blockchain}/slip44:60`;
-              } else {
-                caip = `${blockchain}/slip44:0`;
-              }
-              pubkeysForBatch.push({
-                pubkey: address,
-                caip
-              });
-            }
-          }
-        }
-        console.log(tag, `Calling batch GetCharts with ${pubkeysForBatch.length} pubkeys`);
-        let newBalances = [];
-        try {
-          const chartsResponse = await this.pioneer.GetCharts({
-            pubkeys: pubkeysForBatch
-          });
-          newBalances = chartsResponse?.data?.balances || [];
-          console.log(tag, `Received ${newBalances.length} balances from batch endpoint`);
-        } catch (chartsError) {
-          console.warn(tag, `GetCharts API not available (${chartsError.message}), continuing without charts data`);
-        }
+        console.log(tag6, "Fetching charts (portfolio + tokens + staking)...");
+        const { getCharts: getChartsModular } = await Promise.resolve().then(() => (init_charts(), exports_charts));
+        const newBalances = await getChartsModular(this.blockchains, this.pioneer, this.pubkeys, this.context);
+        console.log(tag6, `Modular charts returned ${newBalances.length} balances (native + tokens + staking)`);
         const uniqueBalances = new Map([...this.balances, ...newBalances].map((balance) => [
           balance.identifier || `${balance.caip}:${balance.pubkey}`,
           {
@@ -5020,17 +5601,19 @@ class SDK {
             type: balance.type || "balance"
           }
         ]));
-        console.log(tag, "uniqueBalances: ", uniqueBalances.size);
+        console.log(tag6, "Deduplicated to:", uniqueBalances.size, "unique balances");
         this.balances = Array.from(uniqueBalances.values());
-        console.log(tag, "Updated this.balances: ", this.balances.length);
+        const tokens = this.balances.filter((b2) => b2.token === true);
+        const native = this.balances.filter((b2) => b2.token !== true);
+        console.log(tag6, `Balance breakdown: ${native.length} native + ${tokens.length} tokens = ${this.balances.length} total`);
         return this.balances;
       } catch (e) {
-        console.error(tag, "Error in getCharts:", e);
+        console.error(tag6, "Error in getCharts:", e);
         throw e;
       }
     };
     this.setContext = async (context) => {
-      const tag = `${TAG9} | setContext | `;
+      const tag6 = `${TAG9} | setContext | `;
       try {
         if (!context)
           throw Error("context required!");
@@ -5038,12 +5621,12 @@ class SDK {
         this.events.emit("SET_CONTEXT", context);
         return { success: true };
       } catch (e) {
-        console.error(tag, "e: ", e);
+        console.error(tag6, "e: ", e);
         return { success: false };
       }
     };
     this.setContextType = async (contextType) => {
-      const tag = `${TAG9} | setContextType | `;
+      const tag6 = `${TAG9} | setContextType | `;
       try {
         if (!contextType)
           throw Error("contextType required!");
@@ -5051,22 +5634,27 @@ class SDK {
         this.events.emit("SET_CONTEXT_TYPE", contextType);
         return { success: true };
       } catch (e) {
-        console.error(tag, "e: ", e);
+        console.error(tag6, "e: ", e);
         return { success: false };
       }
     };
-    this.refresh = async () => {
-      const tag = `${TAG9} | refresh | `;
+    this.refresh = async (forceRefresh) => {
+      const tag6 = `${TAG9} | refresh | `;
       try {
-        await this.sync();
+        if (forceRefresh) {
+          console.log(tag6, "\uD83D\uDD04 Force refresh - fetching fresh balances from blockchain");
+          await this.getBalances(true);
+        } else {
+          await this.sync();
+        }
         return this.balances;
       } catch (e) {
-        console.error(tag, "e: ", e);
+        console.error(tag6, "e: ", e);
         throw e;
       }
     };
     this.setAssetContext = async function(asset) {
-      const tag = `${TAG9} | setAssetContext | `;
+      const tag6 = `${TAG9} | setAssetContext | `;
       try {
         if (!asset) {
           this.assetContext = null;
@@ -5078,7 +5666,7 @@ class SDK {
           asset.networkId = caipToNetworkId7(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(tag, errorMsg);
+          console.error(tag6, errorMsg);
           throw new Error(errorMsg);
         }
         const pubkeysForNetwork = this.pubkeys.filter((e) => {
@@ -5093,8 +5681,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(tag, errorMsg);
-          console.error(tag, "Available networks in pubkeys:", [
+          console.error(tag6, errorMsg);
+          console.error(tag6, "Available networks in pubkeys:", [
             ...new Set(this.pubkeys.flatMap((p) => p.networks || []))
           ]);
           throw new Error(errorMsg);
@@ -5104,43 +5692,43 @@ class SDK {
           const xpubFound = pubkeysForNetwork.some((p) => p.type === "xpub" && p.pubkey);
           if (!xpubFound) {
             const errorMsg = `Cannot set asset context for UTXO chain ${asset.caip} - xpub required but not found`;
-            console.error(tag, errorMsg);
+            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(tag, errorMsg);
+          console.error(tag6, errorMsg);
           throw new Error(errorMsg);
         }
-        console.log(tag, `✅ 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(tag, "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(tag, "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(tag, "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(tag, "✅ Fresh market price:", freshPriceUsd);
+              console.log(tag6, "✅ Fresh market price:", freshPriceUsd);
             } else {
-              console.warn(tag, "No market data returned for:", asset.caip);
+              console.warn(tag6, "No market data returned for:", asset.caip);
             }
           }
         } catch (marketError) {
-          console.error(tag, "Error fetching market price:", marketError);
+          console.error(tag6, "Error fetching market price:", marketError);
         }
         let assetInfo = this.assetsMap.get(asset.caip.toLowerCase());
-        console.log(tag, "assetInfo: ", assetInfo);
-        let assetInfoDiscovery = assetData[asset.caip];
-        console.log(tag, "assetInfoDiscovery: ", assetInfoDiscovery);
+        console.log(tag6, "assetInfo: ", assetInfo);
+        let assetInfoDiscovery = assetData2[asset.caip];
+        console.log(tag6, "assetInfoDiscovery: ", assetInfoDiscovery);
         if (assetInfoDiscovery)
           assetInfo = assetInfoDiscovery;
         if (!assetInfo) {
-          console.log(tag, "Building placeholder asset!");
+          console.log(tag6, "Building placeholder asset!");
           assetInfo = {
             caip: asset.caip.toLowerCase(),
             networkId: asset.networkId,
@@ -5157,30 +5745,30 @@ class SDK {
             const valueUsd = parseFloat(matchingBalances[0].valueUsd);
             if (balance > 0 && valueUsd > 0) {
               priceValue = valueUsd / balance;
-              console.log(tag, "calculated priceUsd from valueUsd/balance:", priceValue);
+              console.log(tag6, "calculated priceUsd from valueUsd/balance:", priceValue);
             }
           }
           if (priceValue && priceValue > 0) {
-            console.log(tag, "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(tag, "✅ Using fresh market price:", freshPriceUsd);
+          console.log(tag6, "✅ Using fresh market price:", freshPriceUsd);
           let totalBalance = 0;
           let totalValueUsd = 0;
-          console.log(tag, `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(tag, `  Balance entry: ${balance} (${valueUsd} USD)`);
+            console.log(tag6, `  Balance entry: ${balance} (${valueUsd} USD)`);
           }
           assetInfo.balance = totalBalance.toString();
           assetInfo.valueUsd = totalValueUsd.toFixed(2);
-          console.log(tag, `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((p) => p.networks && Array.isArray(p.networks) && p.networks.includes(caipToNetworkId7(asset.caip)) || caipToNetworkId7(asset.caip).includes("eip155") && p.networks && Array.isArray(p.networks) && p.networks.some((n) => n.startsWith("eip155")));
@@ -5200,7 +5788,7 @@ class SDK {
             const balanceAmount = parseFloat(balance.balance || 0);
             balance.valueUsd = (balanceAmount * freshPriceUsd).toString();
           }
-          console.log(tag, "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") {
@@ -5252,20 +5840,20 @@ class SDK {
           const currentContextValid = this.pubkeyContext?.networks?.includes(networkId);
           if (!this.pubkeyContext || !currentContextValid) {
             this.pubkeyContext = assetPubkeys[0];
-            console.log(tag, "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(tag, "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(tag, "e: ", e);
+        console.error(tag6, "e: ", e);
         throw e;
       }
     };
     this.setPubkeyContext = async function(pubkey) {
-      let tag = `${TAG9} | setPubkeyContext | `;
+      let tag6 = `${TAG9} | setPubkeyContext | `;
       try {
         if (!pubkey)
           throw Error("pubkey is required");
@@ -5273,31 +5861,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(tag, "Pubkey not found in current pubkeys array");
+          console.warn(tag6, "Pubkey not found in current pubkeys array");
         }
         this.pubkeyContext = pubkey;
-        console.log(tag, "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(tag, "e: ", e);
+        console.error(tag6, "e: ", e);
         throw e;
       }
     };
     this.setOutboundAssetContext = async function(asset) {
-      const tag = `${TAG9} | setOutputAssetContext | `;
+      const tag6 = `${TAG9} | setOutputAssetContext | `;
       try {
-        console.log(tag, "0. asset: ", asset);
+        console.log(tag6, "0. asset: ", asset);
         if (!asset) {
           this.outboundAssetContext = null;
           return;
         }
-        console.log(tag, "1 asset: ", asset);
+        console.log(tag6, "1 asset: ", asset);
         if (!asset.caip)
           throw Error("Invalid Asset! missing caip!");
         if (!asset.networkId)
           asset.networkId = caipToNetworkId7(asset.caip);
-        console.log(tag, "networkId: ", asset.networkId);
-        console.log(tag, "this.pubkeys: ", this.pubkeys);
+        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;
@@ -5312,23 +5900,23 @@ class SDK {
         let freshPriceUsd = 0;
         try {
           if (!asset.caip || typeof asset.caip !== "string" || !asset.caip.includes(":")) {
-            console.warn(tag, "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(tag, "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(tag, "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(tag, "✅ Fresh market price:", freshPriceUsd);
+              console.log(tag6, "✅ Fresh market price:", freshPriceUsd);
             } else {
-              console.warn(tag, "No market data returned for:", asset.caip);
+              console.warn(tag6, "No market data returned for:", asset.caip);
             }
           }
         } catch (marketError) {
-          console.error(tag, "Error fetching market price:", marketError);
+          console.error(tag6, "Error fetching market price:", marketError);
         }
         let assetInfo = this.assetsMap.get(asset.caip.toLowerCase());
-        console.log(tag, "assetInfo: ", assetInfo);
+        console.log(tag6, "assetInfo: ", assetInfo);
         if (!assetInfo) {
           assetInfo = {
             caip: asset.caip.toLowerCase(),
@@ -5346,70 +5934,70 @@ class SDK {
             const valueUsd = parseFloat(matchingBalances[0].valueUsd);
             if (balance > 0 && valueUsd > 0) {
               priceValue = valueUsd / balance;
-              console.log(tag, "calculated priceUsd from valueUsd/balance:", priceValue);
+              console.log(tag6, "calculated priceUsd from valueUsd/balance:", priceValue);
             }
           }
           if (priceValue && priceValue > 0) {
-            console.log(tag, "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(tag, "✅ Using fresh market price:", freshPriceUsd);
+          console.log(tag6, "✅ Using fresh market price:", freshPriceUsd);
           let totalBalance = 0;
           let totalValueUsd = 0;
-          console.log(tag, `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(tag, `  Balance entry: ${balance} (${valueUsd} USD)`);
+            console.log(tag6, `  Balance entry: ${balance} (${valueUsd} USD)`);
           }
           assetInfo.balance = totalBalance.toString();
           assetInfo.valueUsd = totalValueUsd.toFixed(2);
-          console.log(tag, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
+          console.log(tag6, `Aggregated balance: ${totalBalance} (${totalValueUsd.toFixed(2)} USD)`);
         }
-        console.log(tag, "CHECKPOINT 1");
+        console.log(tag6, "CHECKPOINT 1");
         this.outboundAssetContext = { ...assetInfo, ...asset, ...pubkey };
-        console.log(tag, "CHECKPOINT 3");
-        console.log(tag, "outboundAssetContext: assetInfo: ", assetInfo);
+        console.log(tag6, "CHECKPOINT 3");
+        console.log(tag6, "outboundAssetContext: assetInfo: ", assetInfo);
         if (asset.caip) {
           this.outboundBlockchainContext = caipToNetworkId7(asset.caip);
         } else if (asset.networkId) {
           this.outboundBlockchainContext = asset.networkId;
         }
-        console.log(tag, "CHECKPOINT 4");
+        console.log(tag6, "CHECKPOINT 4");
         this.events.emit("SET_OUTBOUND_ASSET_CONTEXT", this.outboundAssetContext);
         return this.outboundAssetContext;
       } catch (e) {
-        console.error(tag, "e: ", e);
+        console.error(tag6, "e: ", e);
         throw e;
       }
     };
   }
   CheckERC20Allowance = async (params) => {
-    const tag = TAG9 + " | CheckERC20Allowance | ";
+    const tag6 = TAG9 + " | CheckERC20Allowance | ";
     try {
-      console.log(tag, "Checking ERC20 allowance:", params);
+      console.log(tag6, "Checking ERC20 allowance:", params);
       const result = await this.pioneer.GetTokenAllowance(params);
-      console.log(tag, "Allowance result:", result);
+      console.log(tag6, "Allowance result:", result);
       return result.data;
     } catch (e) {
-      console.error(tag, "Error checking ERC20 allowance:", e);
+      console.error(tag6, "Error checking ERC20 allowance:", e);
       throw e;
     }
   };
   BuildERC20ApprovalTx = async (params) => {
-    const tag = TAG9 + " | BuildERC20ApprovalTx | ";
+    const tag6 = TAG9 + " | BuildERC20ApprovalTx | ";
     try {
-      console.log(tag, "Building ERC20 approval transaction:", params);
+      console.log(tag6, "Building ERC20 approval transaction:", params);
       const result = await this.pioneer.BuildApprovalTransaction(params);
-      console.log(tag, "Approval tx built:", result);
+      console.log(tag6, "Approval tx built:", result);
       return result.data;
     } catch (e) {
-      console.error(tag, "Error building approval transaction:", e);
+      console.error(tag6, "Error building approval transaction:", e);
       throw e;
     }
   };