@rash2x/bridge-widget 0.6.53 → 0.6.58

package/dist/{index-CTtu-a2U.cjs → index-DiF0Z4eu.cjs}

@@ -12,7 +12,6 @@ const wagmi = require("wagmi");
 const tronwalletAdapterReactHooks = require("@tronweb3/tronwallet-adapter-react-hooks");
 const uiReact = require("@tonconnect/ui-react");
 const core = require("@ton/core");
-const ton = require("@ton/ton");
 const reactQuery = require("@tanstack/react-query");
 const utils$1 = require("@/lib/utils");
 const skeleton = require("@/components/ui/skeleton");
@@ -28,6 +27,7 @@ const sonner = require("sonner");
 const badge = require("@/components/ui/badge");
 const reactDialog = require("@radix-ui/react-dialog");
 const viem = require("viem");
+const ton = require("@ton/ton");
 const tronwalletAdapters = require("@tronweb3/tronwallet-adapters");
 const tronweb = require("tronweb");
 const card = require("@/components/ui/card");
@@ -35,7 +35,7 @@ const reactWindow = require("react-window");
 const common$1 = { "connecting": "Connecting…", "initializing": "Initializing...", "loading": "Loading...", "paste": "paste", "close": "Close", "zeroPlaceholder": "0", "nativeToken": "Native Token" };
 const wallets$1 = { "addTonWallet": "Add TON wallet", "addEvmWallet": "Add EVM wallet", "connectTonWallet": "Connect TON wallet", "connectEvmWallet": "Connect EVM wallet", "initializingMetamask": "Initializing MetaMask SDK...", "initializingTronlink": "Initializing TronLink...", "failedToConnectTon": "Failed to connect to TON wallet", "failedToDisconnect": "Failed to disconnect", "metamaskConnectionError": "MetaMask connection error", "failedToConnectMetamask": "Failed to connect to MetaMask", "failedToDisconnectMetamask": "Failed to disconnect from MetaMask", "selectWallet": "Select Wallet", "tonWallets": "TON", "evmWallets": "EVM", "tronWallets": "TRON", "tonconnect": "TonConnect", "metaMask": "WalletConnect", "walletConnect": "WalletConnect", "tronLink": "TronLink", "addTronWallet": "Add Tron wallet", "comingSoon": "Coming Soon", "connected": "CONNECTED", "connectedStatus": "Connected", "disconnect": "Disconnect", "chooseWallet": "Connect wallet", "oneWalletPerEnv": "You can only connect one wallet per environment.", "connect": "Connect", "connectTronWallet": "Connect Tron wallet", "connectWallet": "Connect wallet" };
 const bridge$1 = { "max": "Max", "sourceNetwork": "Source network", "destinationNetwork": "Destination network", "selectToken": "Select token", "selectNetwork": "Select network", "selectSourceNetwork": "Select source network", "selectDestinationNetwork": "Select destination network", "searchToken": "Search token", "myTokens": "My tokens", "allTokens": "All tokens", "search": "Search", "select": "Select", "willChangeSourceChain": "Will change source network", "willChangeSourceNetworkAndToken": "Will change source token", "noBalancesFound": "No balances found.", "noResults": "No results", "tokenNotFound": "We couldn't find a token with that name or symbol. Please try again.", "chainNotFound": "We couldn't find a chain with that name. Please try again.", "sendToAnotherAddress": "Send to another address", "youWillReceive": "You will receive", "anotherAddressPlaceholder": "Address", "addressDoesntMatch": "Address doesn't match the {{network}} network", "checkBeforeTransfer": "Check correctness before transfer" };
-const transaction$1 = { "enterAmount": "Enter amount", "transfer": "Transfer", "getQuote": "Get quote", "failed": "Transaction Failed", "confirm": "Confirm transaction", "signTransaction": "Sign in transaction in wallet", "quoting": "Quoting...", "inProgress": "Transaction in progress...", "checkingBalance": "Checking balance...", "insufficientBalance": "Insufficient balance", "amountTooSmall": "Min {{min}}", "amountTooLarge": "Max {{max}}", "success": "Success", "successTitle": "Success", "done": "Done", "hashCopied": "Hash copied to clipboard", "bridged": "Bridged", "transferTitle": "Transfer", "hash": "Hash", "layerzeroScan": "LayerZero Scan", "finalFee": "Final Fee", "route": "Route", "estTime": "Est. Time", "slippage": "Slippage", "minimumReceived": "Minimum received", "totalFee": "Total Fee", "noRouteFound": "No route found", "notEnoughGas": "Not enough gas", "pasteAddressToTransfer": "Paste address to transfer", "noRouteFoundForSettings": "No route found for current settings.", "tryAdjustSettings": "Try disabling Gas on Destination, or adjust amount/networks.", "quoteError": "Quote error", "steps": { "sent": "Sent", "processing": "Processing", "processingNote": "Up to 2 minutes", "completed": "Completed" } };
+const transaction$1 = { "enterAmount": "Enter amount", "transfer": "Transfer", "getQuote": "Get quote", "failed": "Transaction Failed", "confirm": "Confirm transaction", "signTransaction": "Sign in transaction in wallet", "quoting": "Quoting...", "inProgress": "Transaction in progress...", "checkingBalance": "Checking balance...", "insufficientBalance": "Insufficient balance", "amountTooSmall": "Min {{min}}", "amountTooLarge": "Max {{max}}", "success": "Success", "successTitle": "Success", "done": "Done", "hashCopied": "Hash copied to clipboard", "bridged": "Bridged", "transferTitle": "Transfer", "hash": "Hash", "layerzeroScan": "TxHash", "finalFee": "Final Fee", "route": "Route", "estTime": "Est. Time", "slippage": "Slippage", "minimumReceived": "Minimum received", "totalFee": "Total Fee", "noRouteFound": "No route found", "notEnoughGas": "Not enough gas", "pasteAddressToTransfer": "Paste address to transfer", "noRouteFoundForSettings": "No route found for current settings.", "tryAdjustSettings": "Try disabling Gas on Destination, or adjust amount/networks.", "quoteError": "Quote error", "steps": { "sent": "Sent", "processing": "Processing", "processingNote": "Up to 2 minutes", "completed": "Completed" } };
 const telegram$1 = { "openWebVersion": "Open EVAA Web to Bridge", "restrictionMessage": "You can bridge between the chosen networks on EVAA web version" };
 const app$1 = { "stargateWidgetName": "Stargate Bridge Widget", "liveWidget": "Live Widget", "getStarted": "Get Started" };
 const settings$1 = { "title": "Settings", "gasOnDestination": "Gas on destination", "gasOnDestinationDescription": "The default amount allows you to perform a couple of transactions (e.g. Approve and Swap).", "slippageTolerance": "Slippage tolerance", "slippageToleranceDescription": "Your transaction will revert if the amount you're receiving is outside of this tolerance", "routePriority": "Route Priority", "routePriorityDescription": "Choose how your transfer is routed. Recommended picks the best overall path for cost. Fastest prioritizes speed above all else.", "highSlippageWarning": "High slippage warning", "gasPresets": { "auto": "Auto", "none": "None", "medium": "Medium", "max": "Max" }, "routePresets": { "fastest": "Fastest", "cheapest": "Cheapest", "recommended": "Recommended" } };
@@ -53,7 +53,7 @@ const en$3 = {
 const common = { "connecting": "Подключение…", "initializing": "Инициализация...", "loading": "Загрузка...", "paste": "вставить", "close": "Закрыть", "zeroPlaceholder": "0", "nativeToken": "Нативный токен" };
 const wallets = { "addTonWallet": "Добавить TON кошелёк", "addEvmWallet": "Добавить EVM кошелёк", "connectTonWallet": "Подключить TON кошелёк", "connectEvmWallet": "Подключить EVM кошелёк", "initializingMetamask": "Инициализация MetaMask SDK...", "initializingTronlink": "Инициализация TronLink...", "failedToConnectTon": "Не удалось подключиться к TON кошельку", "failedToDisconnect": "Не удалось отключиться", "metamaskConnectionError": "Ошибка подключения MetaMask", "failedToConnectMetamask": "Не удалось подключиться к MetaMask", "failedToDisconnectMetamask": "Не удалось отключиться от MetaMask", "selectWallet": "Выберите кошелёк", "tonWallets": "TON", "evmWallets": "EVM", "tronWallets": "TRON", "tonconnect": "TonConnect", "metaMask": "WalletConnect", "walletConnect": "WalletConnect", "tronLink": "TronLink", "addTronWallet": "Добавить Tron кошелёк", "comingSoon": "Скоро", "connected": "ПОДКЛЮЧЕНО", "connectedStatus": "Подключён", "disconnect": "Отключить", "chooseWallet": "Подключите кошелек", "oneWalletPerEnv": "Можно подключить только один кошелёк на окружение.", "connect": "Подключить", "connectTronWallet": "Подключить Tron кошелёк", "connectWallet": "Подключить кошелёк" };
 const bridge = { "max": "Макс", "sourceNetwork": "Исходная сеть", "destinationNetwork": "Целевая сеть", "selectToken": "Выбрать токен", "selectNetwork": "Выбрать сеть", "selectSourceNetwork": "Выбрать исходную сеть", "selectDestinationNetwork": "Выбрать целевую сеть", "searchToken": "Поиск токена", "myTokens": "Мои токены", "allTokens": "Все токены", "search": "Поиск", "select": "Выбрать", "willChangeSourceChain": "Сменит исходную сеть", "willChangeSourceNetworkAndToken": "Сменит исходный токен", "noBalancesFound": "Балансы не найдены.", "noResults": "Нет результатов", "tokenNotFound": "Мы не смогли найти токен с таким названием или символом. Пожалуйста, попробуйте снова.", "chainNotFound": "Мы не смогли найти сеть с таким названием. Пожалуйста, попробуйте снова.", "sendToAnotherAddress": "Отправить на другой адрес", "youWillReceive": "Вы получите", "anotherAddressPlaceholder": "Адрес", "addressDoesntMatch": "Адрес не соответствует сети {{network}}", "checkBeforeTransfer": "Проверьте корректность перед переводом" };
-const transaction = { "enterAmount": "Введите сумму", "transfer": "Перевести", "getQuote": "Получить котировку", "quoting": "Расчет котировки...", "failed": "Ошибка транзакции", "confirm": "Подтвердите транзакцию", "signTransaction": "Подпишите транзакцию в кошельке", "inProgress": "Транзакция выполняется...", "checkingBalance": "Проверка баланса...", "insufficientBalance": "Недостаточно средств", "amountTooSmall": "Минимум {{min}}", "amountTooLarge": "Максимум {{max}}", "success": "Успех", "successTitle": "Успех", "done": "Готово", "hashCopied": "Хэш скопирован в буфер обмена", "bridged": "Переведено", "transferTitle": "Перевод", "hash": "Хэш", "layerzeroScan": "LayerZero Scan", "finalFee": "Итоговая комиссия", "route": "Маршрут", "estTime": "Время", "slippage": "Проскальзывание", "minimumReceived": "Минимум к получению", "totalFee": "Общая комиссия", "noRouteFound": "Маршрут не найден", "notEnoughGas": "Недостаточно газа", "pasteAddressToTransfer": "Укажите адрес получателя", "noRouteFoundForSettings": "Маршрут не найден для текущих настроек.", "tryAdjustSettings": "Попробуйте отключить Gas on Destination или измените сумму/сети.", "quoteError": "Ошибка котировки", "steps": { "sent": "Отправлено", "processing": "Обработка", "processingNote": "До 2 минут", "completed": "Завершено" } };
+const transaction = { "enterAmount": "Введите сумму", "transfer": "Перевести", "getQuote": "Получить котировку", "quoting": "Расчет котировки...", "failed": "Ошибка транзакции", "confirm": "Подтвердите транзакцию", "signTransaction": "Подпишите транзакцию в кошельке", "inProgress": "Транзакция выполняется...", "checkingBalance": "Проверка баланса...", "insufficientBalance": "Недостаточно средств", "amountTooSmall": "Минимум {{min}}", "amountTooLarge": "Максимум {{max}}", "success": "Успех", "successTitle": "Успех", "done": "Готово", "hashCopied": "Хэш скопирован в буфер обмена", "bridged": "Переведено", "transferTitle": "Перевод", "hash": "Хэш", "layerzeroScan": "TxHash", "finalFee": "Итоговая комиссия", "route": "Маршрут", "estTime": "Время", "slippage": "Проскальзывание", "minimumReceived": "Минимум к получению", "totalFee": "Общая комиссия", "noRouteFound": "Маршрут не найден", "notEnoughGas": "Недостаточно газа", "pasteAddressToTransfer": "Укажите адрес получателя", "noRouteFoundForSettings": "Маршрут не найден для текущих настроек.", "tryAdjustSettings": "Попробуйте отключить Gas on Destination или измените сумму/сети.", "quoteError": "Ошибка котировки", "steps": { "sent": "Отправлено", "processing": "Обработка", "processingNote": "До 2 минут", "completed": "Завершено" } };
 const telegram = { "openWebVersion": "Открыть EVAA веб для трансфера", "restrictionMessage": "Трансфер между выбранными сетями доступен только в веб-версии EVAA" };
 const app = { "stargateWidgetName": "Виджет Stargate Bridge", "liveWidget": "Живой виджет", "getStarted": "Начало работы" };
 const settings = { "title": "Настройки", "gasOnDestination": "Газ на назначении", "gasOnDestinationDescription": "Значение по умолчанию позволяет выполнить пару транзакций (например, Approve и Swap).", "slippageTolerance": "Толерантность к проскальзыванию", "slippageToleranceDescription": "Ваша транзакция будет отклонена, если получаемая сумма выйдет за пределы этой допустимой погрешности.", "routePriority": "Приоритет маршрута", "routePriorityDescription": "Выберите, как будет выполняться ваш трансфер. Recommended — выбирает оптимальный маршрут с учётом общей стоимости. Fastest — отдаёт приоритет максимальной скорости.", "highSlippageWarning": "Высокое проскальзывание", "gasPresets": { "auto": "Авто", "none": "Нет", "medium": "Средний", "max": "Макс" }, "routePresets": { "fastest": "Быстрейший", "cheapest": "Дешевейший", "recommended": "Рекомендуемый" } };
@@ -941,375 +941,6 @@ function useChainStrategies() {
   }
   return context;
 }
-const truncateToDecimals = (num, decimals) => {
-  if (!isFinite(num) || isNaN(num)) return "0";
-  const multiplier = Math.pow(10, decimals);
-  const truncated = Math.floor(num * multiplier) / multiplier;
-  return truncated.toFixed(decimals).replace(/\.?0+$/, "");
-};
-const formatTokenAmount = (amount, symbol, options) => {
-  const normalizedSymbol = (symbol ?? "").toUpperCase();
-  if (["USDT", "USDC", "DAI", "BUSD"].includes(normalizedSymbol) && amount >= 1) {
-    return `${Math.floor(amount)} ${normalizedSymbol}`;
-  }
-  if (options?.decimals !== void 0) {
-    return `${amount.toFixed(options.decimals)} ${normalizedSymbol}`;
-  }
-  if (amount >= 1) {
-    return `${amount.toFixed(0)} ${normalizedSymbol}`;
-  } else if (amount >= 1e-3) {
-    return `${amount.toFixed(3)} ${normalizedSymbol}`;
-  } else {
-    return `${amount.toFixed(6)} ${normalizedSymbol}`;
-  }
-};
-const formatUsd = (value) => {
-  if (!value || !isFinite(value)) return "$0";
-  if (value >= 1) return `$${value.toFixed(2)}`;
-  return `$${value.toFixed(6).replace(/0+$/, "").replace(/\.$/, "")}`;
-};
-const formatPercentage = (bps, decimals = 2) => {
-  return `${(bps / 100).toFixed(decimals).replace(/0+$/, "").replace(/\.$/, "")}%`;
-};
-const formatBalance = (amount, decimals = 2) => {
-  if (!isFinite(amount) || isNaN(amount) || amount <= 0) {
-    return "0.00";
-  }
-  return amount.toFixed(decimals);
-};
-const formatHash = (hash, startChars = 4, endChars = 4) => {
-  if (!hash) return "";
-  if (hash.length <= startChars + endChars) return hash;
-  return `${hash.slice(0, startChars)}...${hash.slice(-endChars)}`;
-};
-const formatAddress = formatHash;
-const EVM_CONFIG = {
-  usdtAddress: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
-  gasEstimates: {
-    approve: 65000n,
-    bridge: 300000n
-  },
-  gasBuffer: 1.2,
-  // 20% buffer
-  timeout: 3e5,
-  // 5 minutes (increased for slower networks)
-  requiredConfirmations: 3
-  // Wait for 3 confirmations for reorg protection
-};
-const TON_CONFIG = {
-  apiUrl: "https://toncenter.com/api/v2",
-  timeout: 36e4,
-  // 6 minutes
-  validUntil: 600,
-  // 10 minutes
-  pollingInterval: 5e3,
-  // 5 seconds between transaction status checks
-  estimatedNetworkFee: "100000000"
-  // 0.1 TON in nanoton (conservative estimate)
-};
-const TRON_CONFIG = {
-  timeout: 12e4,
-  // 2 minutes (for 19 confirmations)
-  feeLimit: 1e8,
-  // 100 TRX in sun
-  requiredConfirmations: 19,
-  // TRON standard: 19 blocks for confirmation
-  pollingInterval: 3e3,
-  // 3 seconds between checks
-  estimatedNetworkFee: "10000000"
-  // 10 TRX in SUN (fallback estimate)
-};
-let tonClientInstance = null;
-function getTonClient(customClient, apiKey) {
-  if (customClient) {
-    return customClient;
-  }
-  if (!tonClientInstance) {
-    tonClientInstance = new ton.TonClient({
-      endpoint: `${TON_CONFIG.apiUrl}/jsonRPC`,
-      apiKey
-    });
-  }
-  return tonClientInstance;
-}
-function getQuoteAmounts(quote, srcToken, dstToken) {
-  if (!quote || !srcToken || !dstToken) {
-    return {
-      inputHuman: 0,
-      outputHuman: 0,
-      outputHumanRounded: "0",
-      minReceivedHuman: 0
-    };
-  }
-  const inputHuman = fromLD(quote.srcAmount, srcToken.decimals);
-  const outputHuman = fromLD(quote.dstAmount, dstToken.decimals);
-  const outputHumanRounded = truncateToDecimals(outputHuman, 2);
-  const minReceivedHuman = fromLD(quote.dstAmountMin || "0", dstToken.decimals);
-  return {
-    inputHuman,
-    outputHuman,
-    outputHumanRounded,
-    minReceivedHuman
-  };
-}
-function getQuoteFees(quote, tokens, chains, srcToken, dstToken) {
-  if (!quote || !tokens || !chains) {
-    return {
-      fees: { usd: /* @__PURE__ */ new Map(), original: /* @__PURE__ */ new Map(), formatted: /* @__PURE__ */ new Map() },
-      inSrcToken: void 0,
-      inDstToken: void 0
-    };
-  }
-  const feeData = computeFeesUsdFromArray(quote.fees, tokens, chains);
-  let inSrcToken = void 0;
-  let inDstToken = void 0;
-  if (srcToken && quote.srcChainKey) {
-    const feeInSrcLD = sumFeeByTokenLD(
-      quote.fees,
-      srcToken.address,
-      quote.srcChainKey
-    );
-    const feeInSrcHuman = fromLD(feeInSrcLD, srcToken.decimals);
-    if (feeInSrcHuman > 0) {
-      inSrcToken = Number(truncateToDecimals(feeInSrcHuman, 8));
-    } else if ((feeData.usd.get("total") || 0) > 0 && srcToken.price?.usd) {
-      const feeInSrcApprox = (feeData.usd.get("total") || 0) / srcToken.price.usd;
-      inSrcToken = Number(truncateToDecimals(feeInSrcApprox, 8));
-    }
-  }
-  if (dstToken && quote.dstChainKey) {
-    const feeInDstLD = sumFeeByTokenLD(
-      quote.fees,
-      dstToken.address,
-      quote.dstChainKey
-    );
-    const feeInDstHuman = fromLD(feeInDstLD, dstToken.decimals);
-    if (feeInDstHuman > 0) {
-      inDstToken = Number(truncateToDecimals(feeInDstHuman, 8));
-    }
-  }
-  return {
-    fees: feeData,
-    inSrcToken,
-    inDstToken
-  };
-}
-function calculateMinReceived(quote, slippageBps, dstToken) {
-  if (!quote || !dstToken) return 0;
-  const dstAmountLD = BigInt(quote.dstAmount);
-  const minAmountLD = dstAmountLD * BigInt(1e4 - slippageBps) / BigInt(1e4);
-  return fromLD(minAmountLD.toString(), dstToken.decimals);
-}
-function estimateTonNetworkFee(quote) {
-  try {
-    const tonStep = quote.steps?.find(
-      (s2) => s2.chainKey.toLowerCase() === "ton" && s2.type === "bridge"
-    );
-    if (!tonStep?.transaction?.messages) {
-      console.warn("No TON messages found in quote, using fallback");
-      return TON_CONFIG.estimatedNetworkFee;
-    }
-    const messages = tonStep.transaction.messages;
-    const messageCount = messages.length;
-    const baseFeePerMessage = 10000000n;
-    let totalFee = 0n;
-    for (const message of messages) {
-      let messageFee = baseFeePerMessage;
-      if (message.payload) {
-        const payloadSize = message.payload.length;
-        const sizeFee = BigInt(Math.floor(payloadSize / 100)) * 100000n;
-        messageFee += sizeFee;
-      }
-      if (message.amount) {
-        const amount = BigInt(message.amount);
-        if (amount > 0n && message.payload) {
-          messageFee += 5000000n;
-        }
-      }
-      totalFee += messageFee;
-    }
-    const minBuffer = 50000000n;
-    totalFee = totalFee > minBuffer ? totalFee : minBuffer;
-    totalFee = totalFee * 120n / 100n;
-    const maxFee = 1000000000n;
-    if (totalFee > maxFee) {
-      totalFee = maxFee;
-    }
-    console.log(
-      `TON fee estimate: ${messageCount} messages = ${Number(totalFee) / 1e9} TON`
-    );
-    return totalFee.toString();
-  } catch (error) {
-    console.warn("Failed to estimate TON fee:", error);
-    return TON_CONFIG.estimatedNetworkFee;
-  }
-}
-function addTonNetworkFee(quote, chains, estimatedFee) {
-  if (!quote || quote.srcChainKey.toLowerCase() !== "ton") {
-    return quote;
-  }
-  const tonChain = chains?.find((c2) => c2.chainKey.toLowerCase() === "ton");
-  if (!tonChain?.nativeCurrency?.address) {
-    console.warn("Could not find TON native currency address");
-    return quote;
-  }
-  const networkFee = {
-    token: tonChain.nativeCurrency.address,
-    chainKey: "ton",
-    amount: estimatedFee || TON_CONFIG.estimatedNetworkFee,
-    type: "network"
-  };
-  const hasNetworkFee = quote.fees?.some(
-    (fee) => fee.type === "network" && fee.chainKey === "ton"
-  );
-  if (hasNetworkFee) {
-    return quote;
-  }
-  return {
-    ...quote,
-    fees: [...quote.fees || [], networkFee]
-  };
-}
-async function estimateTronNetworkFee(tronWeb, quote, userAddress) {
-  try {
-    const accountResources = await tronWeb.trx.getAccountResources(userAddress);
-    const availableEnergy = accountResources.EnergyLimit || 0;
-    const tronStep = quote.steps?.find(
-      (s2) => s2.chainKey.toLowerCase() === "tron" && s2.type === "bridge"
-    );
-    if (!tronStep?.transaction?.data || !tronStep.transaction.to) {
-      console.warn("No TRON transaction data in quote, using fallback");
-      return TRON_CONFIG.estimatedNetworkFee;
-    }
-    const contractAddress = tronWeb.address.fromHex(
-      tronStep.transaction.to.startsWith("41") ? tronStep.transaction.to : "41" + tronStep.transaction.to.slice(2)
-    );
-    const simulation = await tronWeb.transactionBuilder.triggerSmartContract(
-      contractAddress,
-      "function signature doesn't matter for energy estimation",
-      {
-        feeLimit: TRON_CONFIG.feeLimit,
-        callValue: tronStep.transaction.value ? Number(tronStep.transaction.value) : 0
-      },
-      [],
-      userAddress
-    );
-    const requiredEnergy = simulation.energy_used || 0;
-    const energyDeficit = Math.max(0, requiredEnergy - availableEnergy);
-    if (energyDeficit === 0) {
-      return "0";
-    }
-    const energyPriceInSun = 420;
-    const feeSun = energyDeficit * energyPriceInSun;
-    console.log(
-      `TRON fee estimation: ${requiredEnergy} energy required, ${availableEnergy} available, ${feeSun / 1e6} TRX fee`
-    );
-    return feeSun.toString();
-  } catch (error) {
-    console.warn("Failed to estimate TRON network fee:", error);
-    return TRON_CONFIG.estimatedNetworkFee;
-  }
-}
-function addTronNetworkFee(quote, chains, estimatedFee) {
-  if (!quote || quote.srcChainKey.toLowerCase() !== "tron") {
-    return quote;
-  }
-  const tronChain = chains?.find((c2) => c2.chainKey.toLowerCase() === "tron");
-  if (!tronChain?.nativeCurrency?.address) {
-    console.warn("Could not find TRON native currency address");
-    return quote;
-  }
-  const networkFee = {
-    token: tronChain.nativeCurrency.address,
-    chainKey: "tron",
-    amount: estimatedFee || TRON_CONFIG.estimatedNetworkFee,
-    type: "network"
-  };
-  const hasNetworkFee = quote.fees?.some(
-    (fee) => fee.type === "network" && fee.chainKey === "tron"
-  );
-  if (hasNetworkFee) {
-    return quote;
-  }
-  return {
-    ...quote,
-    fees: [...quote.fees || [], networkFee]
-  };
-}
-async function estimateEvmNetworkFee(publicClient, quote, chainKey) {
-  try {
-    let totalGasLimit = 0n;
-    for (const step of quote.steps || []) {
-      if (step.chainKey.toLowerCase() !== chainKey.toLowerCase()) continue;
-      if (step.type === "approve") {
-        totalGasLimit += EVM_CONFIG.gasEstimates.approve;
-      } else if (step.type === "bridge") {
-        totalGasLimit += EVM_CONFIG.gasEstimates.bridge;
-      }
-    }
-    if (totalGasLimit === 0n) {
-      return "0";
-    }
-    totalGasLimit = totalGasLimit * BigInt(Math.floor(EVM_CONFIG.gasBuffer * 100)) / 100n;
-    const gasPrice = await publicClient.getGasPrice();
-    const totalCostWei = totalGasLimit * gasPrice;
-    return totalCostWei.toString();
-  } catch (error) {
-    console.warn("Failed to estimate EVM gas fee:", error);
-    return "10000000000000000";
-  }
-}
-function addEvmNetworkFee(quote, chains, estimatedFee) {
-  if (!quote) return quote;
-  const srcChainKey = quote.srcChainKey.toLowerCase();
-  if (srcChainKey === "ton" || srcChainKey === "tron") {
-    return quote;
-  }
-  const srcChain = chains?.find(
-    (c2) => c2.chainKey.toLowerCase() === srcChainKey
-  );
-  if (!srcChain?.nativeCurrency?.address) {
-    return quote;
-  }
-  const hasNetworkFee = quote.fees?.some(
-    (fee) => fee.type === "network" && fee.chainKey.toLowerCase() === srcChainKey
-  );
-  if (hasNetworkFee) {
-    return quote;
-  }
-  const networkFee = {
-    token: srcChain.nativeCurrency.address,
-    chainKey: quote.srcChainKey,
-    amount: estimatedFee || "10000000000000000",
-    type: "network"
-  };
-  return {
-    ...quote,
-    fees: [...quote.fees || [], networkFee]
-  };
-}
-function getQuoteDetails(quote, srcToken, dstToken, tokens, chains, slippageBps) {
-  const amounts = getQuoteAmounts(quote, srcToken, dstToken);
-  const fees = getQuoteFees(quote, tokens, chains, srcToken, dstToken);
-  const minimumReceived = calculateMinReceived(quote, slippageBps, dstToken);
-  return {
-    inputAmount: amounts.inputHuman,
-    outputAmount: amounts.outputHuman,
-    outputAmountRounded: amounts.outputHumanRounded,
-    minimumReceived,
-    etaSeconds: quote?.duration?.estimated,
-    fees
-  };
-}
-function getRouteDisplayName(route) {
-  if (!route) return "Stargate Bridge";
-  const routeLower = route.toLowerCase();
-  if (routeLower.includes("taxi")) return "Stargate V2 Fast";
-  if (routeLower.includes("bus")) return "Stargate V2 Economy";
-  if (routeLower.includes("oft")) return "OFT Bridge";
-  if (routeLower.includes("v2")) return "Stargate V2";
-  return route.split(/[/\-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
-}
 const toSharedDecimals = (amount, fromDecimals, toDecimals) => {
   const value = BigInt(amount);
   const diff = BigInt(toDecimals) - BigInt(fromDecimals);
@@ -1432,88 +1063,7 @@ function useBridgeQuote() {
           return;
         }
         if (cancelled) return;
-        let quoteWithFees = quoteRoute;
-        if (quoteRoute.srcChainKey.toLowerCase() === "ton") {
-          try {
-            const estimatedFee = estimateTonNetworkFee(quoteRoute);
-            quoteWithFees = addTonNetworkFee(quoteRoute, chains, estimatedFee);
-          } catch (error) {
-            console.warn("Failed to estimate TON fee, using fallback:", error);
-            quoteWithFees = addTonNetworkFee(quoteRoute, chains);
-          }
-        }
-        if (quoteRoute.srcChainKey.toLowerCase() === "tron") {
-          const tronStrategy = chainRegistry.getStrategy("tron");
-          if (tronStrategy?.isConnected()) {
-            const tronWeb = tronStrategy.getClient();
-            const tronAddress = tronStrategy.getAccount();
-            if (tronWeb && tronAddress) {
-              try {
-                const estimatedFee = await estimateTronNetworkFee(
-                  tronWeb,
-                  quoteRoute,
-                  tronAddress
-                );
-                quoteWithFees = addTronNetworkFee(
-                  quoteWithFees || quoteRoute,
-                  chains,
-                  estimatedFee
-                );
-              } catch (error) {
-                console.warn(
-                  "Failed to estimate TRON fee, using fallback:",
-                  error
-                );
-                quoteWithFees = addTronNetworkFee(
-                  quoteWithFees || quoteRoute,
-                  chains
-                );
-              }
-            } else {
-              quoteWithFees = addTronNetworkFee(
-                quoteWithFees || quoteRoute,
-                chains
-              );
-            }
-          } else {
-            quoteWithFees = addTronNetworkFee(
-              quoteWithFees || quoteRoute,
-              chains
-            );
-          }
-        }
-        const srcChainKey = quoteRoute.srcChainKey.toLowerCase();
-        if (srcChainKey !== "ton" && srcChainKey !== "tron") {
-          if (publicClient) {
-            try {
-              const estimatedFee = await estimateEvmNetworkFee(
-                publicClient,
-                quoteRoute,
-                quoteRoute.srcChainKey
-              );
-              quoteWithFees = addEvmNetworkFee(
-                quoteWithFees || quoteRoute,
-                chains,
-                estimatedFee
-              );
-            } catch (error) {
-              console.warn(
-                "Failed to estimate EVM fee, using fallback:",
-                error
-              );
-              quoteWithFees = addEvmNetworkFee(
-                quoteWithFees || quoteRoute,
-                chains
-              );
-            }
-          } else {
-            quoteWithFees = addEvmNetworkFee(
-              quoteWithFees || quoteRoute,
-              chains
-            );
-          }
-        }
-        setQuote(quoteWithFees || quoteRoute);
+        setQuote(quoteRoute);
       } catch {
         if (!cancelled) {
           resetUi();
@@ -2694,6 +2244,48 @@ const useWalletSelectModal = zustand.create((set2) => ({
   onOpen: (addressType) => set2({ isOpen: true, addressType }),
   onClose: () => set2({ isOpen: false, addressType: void 0 })
 }));
+const truncateToDecimals = (num, decimals) => {
+  if (!isFinite(num) || isNaN(num)) return "0";
+  const multiplier = Math.pow(10, decimals);
+  const truncated = Math.floor(num * multiplier) / multiplier;
+  return truncated.toFixed(decimals).replace(/\.?0+$/, "");
+};
+const formatTokenAmount = (amount, symbol, options) => {
+  const normalizedSymbol = (symbol ?? "").toUpperCase();
+  if (["USDT", "USDC", "DAI", "BUSD"].includes(normalizedSymbol) && amount >= 1) {
+    return `${Math.floor(amount)} ${normalizedSymbol}`;
+  }
+  if (options?.decimals !== void 0) {
+    return `${amount.toFixed(options.decimals)} ${normalizedSymbol}`;
+  }
+  if (amount >= 1) {
+    return `${amount.toFixed(0)} ${normalizedSymbol}`;
+  } else if (amount >= 1e-3) {
+    return `${amount.toFixed(3)} ${normalizedSymbol}`;
+  } else {
+    return `${amount.toFixed(6)} ${normalizedSymbol}`;
+  }
+};
+const formatUsd = (value) => {
+  if (!value || !isFinite(value)) return "$0";
+  if (value >= 1) return `$${value.toFixed(2)}`;
+  return `$${value.toFixed(6).replace(/0+$/, "").replace(/\.$/, "")}`;
+};
+const formatPercentage = (bps, decimals = 2) => {
+  return `${(bps / 100).toFixed(decimals).replace(/0+$/, "").replace(/\.$/, "")}%`;
+};
+const formatBalance = (amount, decimals = 2) => {
+  if (!isFinite(amount) || isNaN(amount) || amount <= 0) {
+    return "0.00";
+  }
+  return amount.toFixed(decimals);
+};
+const formatHash = (hash, startChars = 4, endChars = 4) => {
+  if (!hash) return "";
+  if (hash.length <= startChars + endChars) return hash;
+  return `${hash.slice(0, startChars)}...${hash.slice(-endChars)}`;
+};
+const formatAddress = formatHash;
 const EditIcon = (props) => {
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "svg",
@@ -3119,8 +2711,8 @@ const InfoIcon = (props) => {
         {
           d: "M6.56836 5.8519C6.56836 5.06104 7.20948 4.41992 8.00034 4.41992C8.7912 4.41992 9.43232 5.06104 9.43232 5.8519C9.43232 6.13698 9.34902 6.40259 9.20543 6.62574C8.77748 7.29081 8.00034 7.92501 8.00034 8.71587V9.07386M8.00034 11.3159V11.5798",
           stroke: "currentColor",
-          "stroke-width": "1.68349",
-          "stroke-linecap": "round"
+          strokeWidth: "1.68349",
+          strokeLinecap: "round"
         }
       )
     }
@@ -3143,6 +2735,96 @@ const TokenSymbol = ({
   const src2 = `${BASE_URL}/${normalizedSymbol}.svg`;
   return /* @__PURE__ */ jsxRuntime.jsx("img", { src: src2, alt: alt ?? symbol, className });
 };
+function getQuoteAmounts(quote, srcToken, dstToken) {
+  if (!quote || !srcToken || !dstToken) {
+    return {
+      inputHuman: 0,
+      outputHuman: 0,
+      outputHumanRounded: "0",
+      minReceivedHuman: 0
+    };
+  }
+  const inputHuman = fromLD(quote.srcAmount, srcToken.decimals);
+  const outputHuman = fromLD(quote.dstAmount, dstToken.decimals);
+  const outputHumanRounded = truncateToDecimals(outputHuman, 2);
+  const minReceivedHuman = fromLD(quote.dstAmountMin || "0", dstToken.decimals);
+  return {
+    inputHuman,
+    outputHuman,
+    outputHumanRounded,
+    minReceivedHuman
+  };
+}
+function getQuoteFees(quote, tokens, chains, srcToken, dstToken) {
+  if (!quote || !tokens || !chains) {
+    return {
+      fees: { usd: /* @__PURE__ */ new Map(), original: /* @__PURE__ */ new Map(), formatted: /* @__PURE__ */ new Map() },
+      inSrcToken: void 0,
+      inDstToken: void 0
+    };
+  }
+  const feeData = computeFeesUsdFromArray(quote.fees, tokens, chains);
+  let inSrcToken = void 0;
+  let inDstToken = void 0;
+  if (srcToken && quote.srcChainKey) {
+    const feeInSrcLD = sumFeeByTokenLD(
+      quote.fees,
+      srcToken.address,
+      quote.srcChainKey
+    );
+    const feeInSrcHuman = fromLD(feeInSrcLD, srcToken.decimals);
+    if (feeInSrcHuman > 0) {
+      inSrcToken = Number(truncateToDecimals(feeInSrcHuman, 8));
+    } else if ((feeData.usd.get("total") || 0) > 0 && srcToken.price?.usd) {
+      const feeInSrcApprox = (feeData.usd.get("total") || 0) / srcToken.price.usd;
+      inSrcToken = Number(truncateToDecimals(feeInSrcApprox, 8));
+    }
+  }
+  if (dstToken && quote.dstChainKey) {
+    const feeInDstLD = sumFeeByTokenLD(
+      quote.fees,
+      dstToken.address,
+      quote.dstChainKey
+    );
+    const feeInDstHuman = fromLD(feeInDstLD, dstToken.decimals);
+    if (feeInDstHuman > 0) {
+      inDstToken = Number(truncateToDecimals(feeInDstHuman, 8));
+    }
+  }
+  return {
+    fees: feeData,
+    inSrcToken,
+    inDstToken
+  };
+}
+function calculateMinReceived(quote, slippageBps, dstToken) {
+  if (!quote || !dstToken) return 0;
+  const dstAmountLD = BigInt(quote.dstAmount);
+  const minAmountLD = dstAmountLD * BigInt(1e4 - slippageBps) / BigInt(1e4);
+  return fromLD(minAmountLD.toString(), dstToken.decimals);
+}
+function getQuoteDetails(quote, srcToken, dstToken, tokens, chains, slippageBps) {
+  const amounts = getQuoteAmounts(quote, srcToken, dstToken);
+  const fees = getQuoteFees(quote, tokens, chains, srcToken, dstToken);
+  const minimumReceived = calculateMinReceived(quote, slippageBps, dstToken);
+  return {
+    inputAmount: amounts.inputHuman,
+    outputAmount: amounts.outputHuman,
+    outputAmountRounded: amounts.outputHumanRounded,
+    minimumReceived,
+    etaSeconds: quote?.duration?.estimated,
+    fees
+  };
+}
+function getRouteDisplayName(route) {
+  if (!route) return "Stargate Bridge";
+  const routeLower = route.toLowerCase();
+  if (routeLower.includes("taxi")) return "Stargate V2 Fast";
+  if (routeLower.includes("bus")) return "Stargate V2 Economy";
+  if (routeLower.includes("oft")) return "OFT Bridge";
+  if (routeLower.includes("v2")) return "Stargate V2";
+  return route.split(/[/\-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
 function useGasEstimate(amountNum) {
   const { fromChain } = useChainsStore();
   const { selectedAssetSymbol } = useTokensStore();
@@ -3152,6 +2834,9 @@ function useGasEstimate(amountNum) {
     srcAddress
   );
   const { quote } = useBridgeQuoteStore();
+  const { chainRegistry } = useChainStrategies();
+  const [networkFeeEstimate, setNetworkFeeEstimate] = react.useState(0);
+  const [networkFeeKnown, setNetworkFeeKnown] = react.useState(false);
   const balancesKnown = !balancesLoading;
   const chainKey = fromChain?.chainKey;
   const nativeCurrencySymbol = fromChain?.nativeCurrency?.symbol;
@@ -3160,6 +2845,42 @@ function useGasEstimate(amountNum) {
   const quoteFees = quote?.fees;
   const quoteSrcChainKey = quote?.srcChainKey;
   const nativeBalanceValue = nativeCurrencySymbol ? Number(balances[nativeCurrencySymbol.toUpperCase()]?.balance ?? 0) : 0;
+  react.useEffect(() => {
+    let cancelled = false;
+    const estimate = async () => {
+      setNetworkFeeEstimate(0);
+      setNetworkFeeKnown(false);
+      if (!chainKey || !quote?.steps?.length) {
+        return;
+      }
+      const strategy = chainRegistry.getStrategy(chainKey);
+      if (!strategy) {
+        setNetworkFeeKnown(true);
+        return;
+      }
+      const steps = quote.steps.filter((step) => step.chainKey === chainKey);
+      if (!steps.length) {
+        setNetworkFeeKnown(true);
+        return;
+      }
+      try {
+        const estimateValue = await strategy.estimateNetworkFee(steps);
+        if (cancelled) return;
+        setNetworkFeeEstimate(Number.isFinite(estimateValue) ? estimateValue : 0);
+      } catch {
+        if (cancelled) return;
+        setNetworkFeeEstimate(0);
+      } finally {
+        if (!cancelled) {
+          setNetworkFeeKnown(true);
+        }
+      }
+    };
+    void estimate();
+    return () => {
+      cancelled = true;
+    };
+  }, [chainKey, quote?.steps, chainRegistry]);
   const result = react.useMemo(() => {
     if (!chainKey || !nativeCurrencySymbol) {
       return {
@@ -3179,7 +2900,7 @@ function useGasEstimate(amountNum) {
     if (quoteFees && quoteSrcChainKey === chainKey) {
       const fees = quoteFees;
       const feesInNative = fees.filter(
-        (f4) => f4.chainKey === chainKey && f4.token === nativeCurrencyAddress && f4.type === "network"
+        (f4) => f4.chainKey === chainKey && f4.token === nativeCurrencyAddress
       ).reduce(
         (sum, f4) => sum + BigInt(f4.amount || "0"),
         0n
@@ -3188,13 +2909,16 @@ function useGasEstimate(amountNum) {
       requiredNative = Number(feesInNative) / Math.pow(10, decimals);
       quoteFeesAvailable = true;
     }
+    if (networkFeeKnown) {
+      requiredNative += networkFeeEstimate;
+    }
     let hasEnoughGas = true;
     if (isNativeSelected) {
       hasEnoughGas = nativeBalance - (amountNum ?? 0) >= requiredNative;
     } else {
       hasEnoughGas = nativeBalance >= requiredNative;
     }
-    const shouldCheckGas = balancesKnown && quoteFeesAvailable;
+    const shouldCheckGas = balancesKnown && quoteFeesAvailable && networkFeeKnown;
     return {
       nativeSym,
       nativeBalance,
@@ -3213,7 +2937,9 @@ function useGasEstimate(amountNum) {
     quoteSrcChainKey,
     amountNum,
     balancesKnown,
-    nativeBalanceValue
+    nativeBalanceValue,
+    networkFeeEstimate,
+    networkFeeKnown
   ]);
   return result;
 }
@@ -3622,33 +3348,6 @@ class TransactionFailedError extends ChainStrategyError {
     this.txHash = txHash;
   }
 }
-class TransactionTimeoutError extends ChainStrategyError {
-  constructor(chainKey, txHash) {
-    super(
-      `${chainKey.toUpperCase()} transaction confirmation timeout: ${txHash}`,
-      "TRANSACTION_TIMEOUT",
-      chainKey
-    );
-    __publicField(this, "txHash");
-    this.name = "TransactionTimeoutError";
-    this.txHash = txHash;
-  }
-}
-class TransactionRevertedError extends ChainStrategyError {
-  constructor(chainKey, txHash, revertReason) {
-    const reason = revertReason ? `: ${revertReason}` : "";
-    super(
-      `${chainKey.toUpperCase()} transaction reverted on-chain${reason}`,
-      "TRANSACTION_REVERTED",
-      chainKey
-    );
-    __publicField(this, "txHash");
-    __publicField(this, "revertReason");
-    this.name = "TransactionRevertedError";
-    this.txHash = txHash;
-    this.revertReason = revertReason;
-  }
-}
 class ProviderNotAvailableError extends ChainStrategyError {
   constructor(chainKey, reason) {
     const message = reason ? `${chainKey.toUpperCase()} provider not available: ${reason}` : `${chainKey.toUpperCase()} provider not available`;
@@ -3705,6 +3404,38 @@ async function getLayerZeroMessageByTx(txHash) {
     return null;
   }
 }
+async function waitForLayerZeroCompletion(txHash, timeoutMs = 6e5, pollIntervalMs = 1e4) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const message = await getLayerZeroMessageByTx(txHash);
+      if (message) {
+        const statusName = message.status?.name;
+        if (statusName === "DELIVERED") {
+          return {
+            completed: true,
+            status: "DELIVERED",
+            dstTxHash: message.destination?.tx?.txHash,
+            message
+          };
+        }
+        if (statusName === "FAILED") {
+          return {
+            completed: false,
+            status: "FAILED",
+            message
+          };
+        }
+      }
+    } catch {
+    }
+    await new Promise((r2) => setTimeout(r2, pollIntervalMs));
+  }
+  return {
+    completed: false,
+    status: "TIMEOUT"
+  };
+}
 function useBridgeTransaction() {
   const { quote } = useBridgeQuoteStore();
   const { chainRegistry } = useChainStrategies();
@@ -3780,59 +3511,76 @@ function useBridgeTransaction() {
         txStore.setSrcHash(hash);
         txStore.updateStatus("processing");
       });
-      if (txResult?.tonTransactionHash) {
-        txStore.setTonTransactionHash(txResult.tonTransactionHash);
-      }
       if (txResult?.hash) {
-        strategy.waitForCompletion(txResult.hash, context).then((result) => {
-          if (result.completed) {
-            if (result.dstTxHash) {
-              txStore.setDstHash(result.dstTxHash);
+        const trackWithLayerZero = async () => {
+          let hashForLayerZero = txResult.hash;
+          const messageHash = txResult.hash;
+          if (quote.srcChainKey === "ton" && strategy.convertMessageHashToTxHash) {
+            const tonTxHash = await strategy.convertMessageHashToTxHash(
+              messageHash,
+              6e4
+            );
+            if (tonTxHash) {
+              hashForLayerZero = tonTxHash;
+              txStore.setTonTransactionHash(tonTxHash);
+            } else {
+              console.warn("Failed to convert TON message hash to tx hash");
             }
-            if (result.actualFeeValue) {
-              let feeSymbol = result.actualFeeSymbol;
-              if (!feeSymbol) {
-                const srcChain2 = chains?.find(
-                  (c2) => c2.chainKey === quote.srcChainKey
-                );
-                feeSymbol = srcChain2?.nativeCurrency?.symbol || "";
-              }
-              const feeValue = parseFloat(result.actualFeeValue);
-              if (!isNaN(feeValue)) {
-                txStore.updateActualFee(feeValue, feeSymbol);
-              }
+          }
+          const lzResult = await waitForLayerZeroCompletion(
+            hashForLayerZero,
+            6e5,
+            1e4
+          );
+          console.log("LayerZero delivery status:", lzResult.status);
+          if (lzResult.completed) {
+            if (lzResult.dstTxHash) {
+              txStore.setDstHash(lzResult.dstTxHash);
             }
-            txStore.updateStatus("completed");
-            console.log("Transaction completed successfully");
-            if (txResult.hash && strategy.getSourceCost) {
+            if (strategy.getSourceCost) {
               const srcChain2 = chains?.find(
                 (c2) => c2.chainKey === quote.srcChainKey
               );
               const feeSymbol = srcChain2?.nativeCurrency?.symbol || "";
               const { priceUsd } = findNativeMeta(allTokens, srcChain2);
-              const srcHash = txResult.hash;
-              const getSourceCost = strategy.getSourceCost;
-              getLayerZeroMessageByTx(srcHash).then((message) => {
-                if (quote.srcChainKey === "ton") return srcHash;
-                return message?.source?.tx?.txHash ?? srcHash;
-              }).then((sourceTxHash) => getSourceCost(sourceTxHash)).then((sourceCost) => {
+              const hashForSourceCost = quote.srcChainKey === "ton" ? messageHash : hashForLayerZero;
+              try {
+                const sourceCost = await strategy.getSourceCost(
+                  hashForSourceCost
+                );
                 if (sourceCost?.totalNative !== void 0 && isFinite(sourceCost.totalNative)) {
                   const feeUsd = priceUsd && priceUsd > 0 ? sourceCost.totalNative * priceUsd : void 0;
+                  console.log("Source cost calculated:", {
+                    gasFee: sourceCost.breakdown?.gasFee + " " + feeSymbol,
+                    layerZeroFee: sourceCost.breakdown?.layerZeroFee + " " + feeSymbol,
+                    total: sourceCost.totalNative + " " + feeSymbol,
+                    totalUsd: feeUsd ? "$" + feeUsd.toFixed(2) : "N/A"
+                  });
                   txStore.updateLayerZeroTotalFee(
                     sourceCost.totalNative,
                     feeSymbol,
                     feeUsd
                   );
                 }
-              }).catch((error) => {
-                console.warn("Failed to compute LayerZero total fee:", error);
-              });
+              } catch (error) {
+                console.warn("Failed to compute source cost:", error);
+              }
             }
+            txStore.updateStatus("completed");
+            console.log("Transaction completed successfully via LayerZero");
           } else {
-            txStore.setError("TRANSACTION_FAILED_TO_COMPLETE");
-            console.error("Transaction completion failed:", result.error);
+            if (lzResult.status === "FAILED") {
+              txStore.setError("TRANSACTION_FAILED_TO_COMPLETE");
+              console.error("LayerZero delivery failed");
+            } else {
+              txStore.updateStatus("completed");
+              console.warn(
+                "LayerZero tracking timed out, marking as completed"
+              );
+            }
           }
-        }).catch((err) => {
+        };
+        trackWithLayerZero().catch((err) => {
           if (isUserRejection(err)) {
             txStore.setError("TRANSACTION_REJECTED");
           } else if (ChainStrategyError.isChainStrategyError(err)) {
@@ -4932,11 +4680,60 @@ class ChainStrategyRegistry {
     await strategy.disconnect(options);
   }
 }
+const EVM_CONFIG = {
+  usdtAddress: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+  gasEstimates: {
+    approve: 65000n,
+    bridge: 300000n
+  },
+  gasBuffer: 1.2,
+  // 20% buffer
+  gasFeeMultiplier: 2,
+  // Multiplier for wallet fee estimates
+  timeout: 3e5,
+  // 5 minutes (increased for slower networks)
+  requiredConfirmations: 3
+  // Wait for 3 confirmations for reorg protection
+};
+const TON_CONFIG = {
+  apiUrl: "https://toncenter.com/api/v2",
+  timeout: 36e4,
+  // 6 minutes
+  validUntil: 600,
+  // 10 minutes
+  pollingInterval: 5e3,
+  // 5 seconds between transaction status checks
+  estimatedNetworkFee: "1000000000"
+  // 1 TON in nanoton (conservative estimate)
+};
+const TRON_CONFIG = {
+  // 2 minutes (for 19 confirmations)
+  feeLimit: 1e8,
+  // 3 seconds between checks
+  estimatedNetworkFee: "10000000"
+  // 10 TRX in SUN (fallback estimate)
+};
+let tonClientInstance = null;
+function getTonClient(customClient, apiKey) {
+  if (customClient) {
+    return customClient;
+  }
+  if (!tonClientInstance) {
+    tonClientInstance = new ton.TonClient({
+      endpoint: `${TON_CONFIG.apiUrl}/jsonRPC`,
+      apiKey
+    });
+  }
+  return tonClientInstance;
+}
 function isNativeAddress(addr) {
   if (!addr) return false;
   const a2 = addr.toLowerCase();
   return a2 === "native" || a2 === "0x0000000000000000000000000000000000000000" || a2 === "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" || addr === "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
 }
+function sleep(ms2) {
+  return new Promise((resolve) => setTimeout(resolve, ms2));
+}
 function toTronBase58(addr, tronWeb) {
   if (!addr) throw new Error("Empty TRON address");
   if (addr.startsWith("T")) return addr;
@@ -4983,24 +4780,27 @@ async function getEvmBalances(publicClient, address, tokens) {
     if (!publicClient) {
       throw new Error("No public client provided");
     }
-    const nativeTokens = tokens.filter((t2) => isNativeAddress(t2.address));
     const erc20Tokens = tokens.filter(
       (t2) => !isNativeAddress(t2.address) && viem.isAddress(t2.address)
     );
-    for (const token of nativeTokens) {
+    const chainNative = publicClient.chain?.nativeCurrency;
+    const nativeSymbol = chainNative?.symbol ?? "ETH";
+    const nativeDecimals = chainNative?.decimals ?? 18;
+    const maxAttempts = 2;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
       try {
-        const ethBalance = await publicClient.getBalance({
+        const nativeBalance = await publicClient.getBalance({
           address
         });
-        const balance = parseFloat(viem.formatUnits(ethBalance, token.decimals));
+        const balance = parseFloat(viem.formatUnits(nativeBalance, nativeDecimals));
         if (balance > 0) {
-          balances[token.symbol] = { balance, address };
+          balances[nativeSymbol] = { balance, address };
+        }
+        break;
+      } catch {
+        if (attempt !== maxAttempts) {
+          await sleep(250 * attempt);
         }
-      } catch (error) {
-        console.debug(
-          `Failed to get native balance for ${token.symbol}:`,
-          error
-        );
       }
     }
     if (erc20Tokens.length > 0) {
@@ -5034,11 +4834,7 @@ async function getEvmBalances(publicClient, address, tokens) {
               if (balance > 0) {
                 balances[token.symbol] = { balance, address };
               }
-            } catch (error) {
-              console.debug(
-                `Failed to parse balance for ${token.symbol}:`,
-                error
-              );
+            } catch {
             }
           }
         });
@@ -5069,8 +4865,7 @@ async function getEvmBalances(publicClient, address, tokens) {
             if (balance > 0) {
               balances[token.symbol] = { balance, address };
             }
-          } catch (error2) {
-            console.debug(`Failed to get balance for ${token.symbol}:`, error2);
+          } catch {
           }
         }
       }
@@ -5130,12 +4925,7 @@ async function getTonBalances(address, tokens, customTonClient, tonApiKey) {
             balances[symbolNorm] = entry;
           }
         }
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const isNoWalletError = errorMessage.includes("exit_code: -13") || errorMessage.includes("exit_code:-13") || errorMessage.includes("exitCode: -13");
-        if (!isNoWalletError) {
-          console.debug(`Failed to get balance for ${token.symbol}:`, error);
-        }
+      } catch {
       }
     }
   } catch (error) {
@@ -5157,8 +4947,7 @@ async function getTronBalances(tronWeb, address, tokens) {
       if (trxBalance > 0) {
         balances.TRX = { balance: trxBalance, address: ownerB58 };
       }
-    } catch (error) {
-      console.warn("Failed to get native TRX balance:", error);
+    } catch {
     }
     for (const token of tokens) {
       try {
@@ -5192,21 +4981,19 @@ async function getTronBalances(tronWeb, address, tokens) {
         if (balance > 0) {
           balances[token.symbol] = { balance, address: ownerB58 };
         }
-      } catch (error) {
-        console.warn(`Failed to get TRON balance for ${token.symbol}:`, error);
+      } catch {
       }
     }
-  } catch (error) {
-    console.error("Failed to get Tron balances:", error);
+  } catch {
   }
   return balances;
 }
-const ERC20_ABI = [
+const ERC20_ABI = viem.parseAbi([
   "function approve(address spender, uint256 amount) returns (bool)",
   "function allowance(address owner, address spender) view returns (uint256)",
   "function decimals() view returns (uint8)",
   "function balanceOf(address owner) view returns (uint256)"
-];
+]);
 class EvmChainStrategy {
   constructor(config) {
     __publicField(this, "config");
@@ -5254,14 +5041,9 @@ class EvmChainStrategy {
   }
   async getBalances(address, tokens) {
     if (!this.publicClient) {
-      console.warn("No publicClient available for balance query");
       return {};
     }
-    return await getEvmBalances(
-      this.publicClient,
-      address,
-      tokens
-    );
+    return await getEvmBalances(this.publicClient, address, tokens);
   }
   isAddressValid(address) {
     if (!address) return false;
@@ -5297,7 +5079,6 @@ class EvmChainStrategy {
   }
   async getSourceCost(txHash) {
     if (!this.publicClient) {
-      console.warn("No publicClient available for source cost query");
       return null;
     }
     try {
@@ -5312,18 +5093,61 @@ class EvmChainStrategy {
       const gasFeeWei = gasUsed * gasPrice;
       const txValueWei = tx.value ?? 0n;
       const totalWei = gasFeeWei + txValueWei;
-      return {
+      const sourceCost = {
         totalNative: Number(viem.formatUnits(totalWei, 18)),
         breakdown: {
           gasFee: Number(viem.formatUnits(gasFeeWei, 18)),
           layerZeroFee: Number(viem.formatUnits(txValueWei, 18))
         }
       };
+      return sourceCost;
     } catch (error) {
       console.warn("Failed to compute EVM source cost:", error);
       return null;
     }
   }
+  async estimateNetworkFee(steps) {
+    if (!this.walletClient) {
+      return 0;
+    }
+    const account = this.config.evmAddress;
+    const txSteps = steps.filter((step) => step.transaction?.to);
+    if (!txSteps.length) {
+      return 0;
+    }
+    const applyFeeMultiplier = (feePerGas) => {
+      const multiplier = EVM_CONFIG.gasFeeMultiplier;
+      if (!Number.isFinite(multiplier) || multiplier <= 1) {
+        return feePerGas;
+      }
+      const scaled = BigInt(Math.round(multiplier * 100));
+      return (feePerGas * scaled + 99n) / 100n;
+    };
+    let totalFeeWei = 0n;
+    for (const step of txSteps) {
+      const tx = step.transaction;
+      if (!tx?.to) continue;
+      try {
+        const request = await this.walletClient.prepareTransactionRequest({
+          account: tx.from || account,
+          to: tx.to,
+          data: tx.data,
+          value: tx.value ? BigInt(tx.value) : void 0,
+          chain: this.walletClient.chain
+        });
+        const gasLimit = request.gas;
+        const maxFeePerGas = request.maxFeePerGas ?? request.gasPrice;
+        if (gasLimit && maxFeePerGas) {
+          totalFeeWei += gasLimit * applyFeeMultiplier(maxFeePerGas);
+        }
+      } catch {
+      }
+    }
+    if (totalFeeWei === 0n) {
+      return 0;
+    }
+    return Number(viem.formatUnits(totalFeeWei, 18));
+  }
   async executeSteps(steps, _context, onFirstHash) {
     if (!this.isConnected() || !this.walletClient) {
       throw new WalletNotConnectedError("evm");
@@ -5337,14 +5161,12 @@ class EvmChainStrategy {
         );
         if (step.type === "approve") {
           const hash = await this.approveTransaction(step);
-          console.log(`Approval transaction hash: ${hash}`);
           if (!firstTxHash) {
             firstTxHash = hash;
             onFirstHash?.(hash);
           }
         } else if (step.type === "bridge") {
           const hash = await this.executeTransaction(step);
-          console.log(`Bridge transaction hash: ${hash}`);
           if (!firstTxHash) {
             firstTxHash = hash;
             onFirstHash?.(hash);
@@ -5367,106 +5189,6 @@ class EvmChainStrategy {
       throw toChainStrategyError(error, "evm", "transaction");
     }
   }
-  async waitForCompletion(txHash) {
-    try {
-      const publicClient = this.publicClient;
-      if (!publicClient) {
-        throw new ProviderNotAvailableError("evm");
-      }
-      console.log(
-        `Waiting for ${EVM_CONFIG.requiredConfirmations} confirmations for tx: ${txHash}`
-      );
-      const receipt = await publicClient.waitForTransactionReceipt({
-        hash: txHash,
-        confirmations: EVM_CONFIG.requiredConfirmations,
-        timeout: EVM_CONFIG.timeout
-      });
-      if (!receipt) {
-        const error = new TransactionTimeoutError("evm", txHash);
-        return {
-          completed: false,
-          error: error.message
-        };
-      }
-      if (receipt.status !== "success") {
-        const error = new TransactionRevertedError("evm", txHash);
-        return {
-          completed: false,
-          error: error.message
-        };
-      }
-      console.log(
-        `EVM transaction confirmed in block ${receipt.blockNumber} with ${EVM_CONFIG.requiredConfirmations} confirmations`
-      );
-      let actualFeeValue;
-      try {
-        const gasUsed = receipt.gasUsed;
-        const effectiveGasPrice = receipt.effectiveGasPrice;
-        if (gasUsed && effectiveGasPrice) {
-          const feeWei = gasUsed * effectiveGasPrice;
-          const feeInNative = viem.formatUnits(feeWei, 18);
-          actualFeeValue = feeInNative;
-          console.log(`EVM transaction fee: ${feeInNative} (native token)`);
-        }
-      } catch (error) {
-        console.warn("Failed to calculate actual fee:", error);
-      }
-      return {
-        completed: true,
-        actualFeeValue
-        // Symbol will be determined by the caller based on chain info
-      };
-    } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "TRANSACTION_REPLACED") {
-        console.log(
-          `Transaction was replaced: ${"reason" in error ? String(error.reason) : "unknown"}`
-        );
-        if ("receipt" in error && error.receipt) {
-          const replacementReceipt = error.receipt;
-          if (replacementReceipt.status === 1) {
-            console.log(
-              `Replacement transaction succeeded in block ${replacementReceipt.blockNumber}`
-            );
-            let actualFeeValue;
-            try {
-              const receipt = error.receipt;
-              const gasUsed = receipt.gasUsed;
-              const effectiveGasPrice = receipt.effectiveGasPrice;
-              if (gasUsed && effectiveGasPrice) {
-                const feeWei = gasUsed * effectiveGasPrice;
-                const feeInNative = viem.formatUnits(feeWei, 18);
-                actualFeeValue = feeInNative;
-                console.log(
-                  `Replacement transaction fee: ${feeInNative} (native token)`
-                );
-              }
-            } catch (feeError) {
-              console.warn("Failed to calculate replacement transaction fee:", feeError);
-            }
-            return {
-              completed: true,
-              actualFeeValue
-            };
-          } else {
-            const chainError2 = new TransactionRevertedError("evm", txHash);
-            return {
-              completed: false,
-              error: chainError2.message
-            };
-          }
-        }
-      }
-      const chainError = toChainStrategyError(
-        error,
-        "evm",
-        "waitForCompletion"
-      );
-      return {
-        completed: false,
-        error: chainError.message
-      };
-    }
-  }
   async executeTransaction(step) {
     const walletClient = this.walletClient;
     if (!walletClient) {
@@ -5621,88 +5343,14 @@ class EvmChainStrategy {
         blockTag: "finalized"
       });
       if (!finalizedBlock) {
-        console.debug(
-          "Finalized block not available (pre-merge or unsupported)"
-        );
         return false;
       }
-      const isFinalized = blockNumber <= finalizedBlock.number;
-      if (isFinalized) {
-        console.log(
-          `Block ${blockNumber} has reached finality (finalized block: ${finalizedBlock.number})`
-        );
-      } else {
-        console.debug(
-          `Block ${blockNumber} not yet finalized (finalized block: ${finalizedBlock.number})`
-        );
-      }
-      return isFinalized;
-    } catch (error) {
-      console.debug("Error checking finality:", error);
+      return blockNumber <= finalizedBlock.number;
+    } catch {
       return false;
     }
   }
 }
-function getNormalizedExtMessageHash(message) {
-  if (message.info.type !== "external-in") {
-    throw new Error(`Expected external-in message, got ${message.info.type}`);
-  }
-  const normalizedInfo = {
-    ...message.info,
-    src: void 0,
-    importFee: 0n
-  };
-  const normalizedMessage = {
-    ...message,
-    info: normalizedInfo,
-    init: null
-  };
-  return core.beginCell().store(core.storeMessage(normalizedMessage, { forceRef: true })).endCell().hash();
-}
-async function getTonTransactionHash(messageHash, userAddress, searchLimit = 20, options) {
-  try {
-    const client = options?.client ?? new ton.TonClient({
-      endpoint: "https://toncenter.com/api/v2/jsonRPC",
-      apiKey: process.env.TONCENTER_API_KEY
-      // Optional: for rate limit increase
-    });
-    const messageHasher = options?.messageHasher ?? getNormalizedExtMessageHash;
-    const address = core.Address.parse(userAddress);
-    const transactions = await client.getTransactions(address, {
-      limit: searchLimit
-    });
-    for (const tx of transactions) {
-      const inMsg = tx.inMessage;
-      if (!inMsg) continue;
-      try {
-        const inMsgHash = messageHasher(inMsg).toString("hex");
-        if (inMsgHash === messageHash.replace("0x", "")) {
-          const txHash = tx.hash().toString("hex");
-          return {
-            transactionHash: `0x${txHash}`,
-            messageHash,
-            found: true
-          };
-        }
-      } catch {
-        continue;
-      }
-    }
-    console.warn(`TON transaction not found for message hash: ${messageHash}`);
-    return {
-      transactionHash: null,
-      messageHash,
-      found: false
-    };
-  } catch (error) {
-    console.error("Failed to get TON transaction hash:", error);
-    return {
-      transactionHash: null,
-      messageHash,
-      found: false
-    };
-  }
-}
 class TonChainStrategy {
   constructor(config) {
     __publicField(this, "config");
@@ -5815,40 +5463,17 @@ class TonChainStrategy {
         validUntil: Math.floor(Date.now() / 1e3) + TON_CONFIG.validUntil,
         messages: tonMessages
       };
-      const result = await this.config.tonConnectUI.sendTransaction(
-        transaction2
-      );
+      const result = await this.config.tonConnectUI.sendTransaction(transaction2);
       const bocBase64 = result.boc;
       try {
         const inMessage = core.loadMessage(core.Cell.fromBase64(bocBase64).beginParse());
         const messageHash = this.getNormalizedExtMessageHash(inMessage);
         const hexHash = messageHash.toString("hex");
         onFirstHash?.(hexHash);
-        let tonTransactionHash;
-        if (this.config.tonAddress) {
-          try {
-            const tonTxResult = await getTonTransactionHash(
-              hexHash,
-              this.config.tonAddress,
-              20
-            );
-            if (tonTxResult.found && tonTxResult.transactionHash) {
-              tonTransactionHash = tonTxResult.transactionHash;
-            } else {
-              console.warn(
-                `TON transaction hash not found for message hash: ${hexHash}`
-              );
-            }
-          } catch (error) {
-            console.error("Failed to convert TON message hash:", error);
-          }
-        }
         return {
           chainKey: "ton",
-          hash: hexHash,
-          // Message hash for TONScan
-          tonTransactionHash
-          // Transaction hash for LayerZero (if found)
+          hash: hexHash
+          // Message hash for TONScan and for finding tx later
         };
       } catch (error) {
         console.error("Error parsing BOC to hex hash:", error);
@@ -5862,39 +5487,45 @@ class TonChainStrategy {
       throw toChainStrategyError(error, "ton", "transaction");
     }
   }
-  async waitForCompletion(txHash) {
-    try {
-      const result = await this.checkTonTransaction(
-        txHash,
-        TON_CONFIG.timeout
-      );
-      if (!result.confirmed) {
-        const error = new TransactionFailedError(
-          "ton",
-          "Transaction not confirmed on-chain",
-          txHash
-        );
-        return {
-          completed: false,
-          error: error.message
-        };
+  /**
+   * Convert TON message hash to transaction hash.
+   * LayerZero uses transaction hash, but TonConnect returns message hash.
+   */
+  async convertMessageHashToTxHash(messageHash, timeoutMs = 6e4) {
+    const deadline = Date.now() + timeoutMs;
+    const client = getTonClient(this.config.tonClient, this.config.tonApiKey);
+    if (!this.config.tonAddress) {
+      return null;
+    }
+    const targetMessageHash = Buffer.from(messageHash, "hex");
+    const accountAddress = core.Address.parse(this.config.tonAddress);
+    while (Date.now() < deadline) {
+      try {
+        const transactions = await client.getTransactions(accountAddress, {
+          limit: 20,
+          archival: true
+        });
+        for (const tx of transactions) {
+          if (tx.inMessage?.info.type === "external-in") {
+            try {
+              const txInMessageHash = this.getNormalizedExtMessageHash(
+                tx.inMessage
+              );
+              if (txInMessageHash.equals(targetMessageHash)) {
+                const txHash = `0x${tx.hash().toString("hex")}`;
+                return txHash;
+              }
+            } catch {
+              continue;
+            }
+          }
+        }
+        await new Promise((r2) => setTimeout(r2, 3e3));
+      } catch {
+        await new Promise((r2) => setTimeout(r2, 3e3));
       }
-      return {
-        completed: true,
-        actualFeeValue: result.fee,
-        actualFeeSymbol: "TON"
-      };
-    } catch (error) {
-      const chainError = toChainStrategyError(
-        error,
-        "ton",
-        "waitForCompletion"
-      );
-      return {
-        completed: false,
-        error: chainError.message
-      };
     }
+    return null;
   }
   getNormalizedExtMessageHash(message) {
     if (message.info.type !== "external-in") {
@@ -5917,6 +5548,9 @@ class TonChainStrategy {
     if (typeof value === "number" && Number.isFinite(value)) {
       return BigInt(Math.trunc(value));
     }
+    if (typeof value === "object" && value !== null && "coins" in value) {
+      return this.toBigInt(value.coins);
+    }
     if (typeof value === "string" && value.trim() !== "") {
       try {
         return BigInt(value);
@@ -5930,12 +5564,16 @@ class TonChainStrategy {
     const candidate = tx.outMessages;
     if (!candidate) return [];
     if (Array.isArray(candidate)) return candidate;
-    if (candidate instanceof Map) return Array.from(candidate.values());
     if (typeof candidate === "object" && candidate !== null && "values" in candidate && typeof candidate.values === "function") {
-      return Array.from(
-        candidate.values()
-      );
+      const values = candidate.values();
+      if (Array.isArray(values)) {
+        return [...values];
+      }
+      if (values && typeof values === "object" && Symbol.iterator in values) {
+        return Array.from(values);
+      }
     }
+    if (candidate instanceof Map) return Array.from(candidate.values());
     return [];
   }
   getMessageValue(message) {
@@ -5947,27 +5585,49 @@ class TonChainStrategy {
     }
     return this.toBigInt(value);
   }
-  getFirstOutMessageValue(tx) {
+  getTotalOutMessageValue(tx) {
     const outMessages = this.getOutMessages(tx);
     if (!outMessages.length) return 0n;
-    const value = this.getMessageValue(outMessages[0]);
-    return value ?? 0n;
+    let total = 0n;
+    for (const message of outMessages) {
+      const value = this.getMessageValue(message);
+      if (value) {
+        total += value;
+      }
+    }
+    return total;
   }
-  async getSourceCost(txHash) {
-    const timeoutMs = Math.min(TON_CONFIG.timeout, 12e4);
-    const result = await this.checkTonTransaction(txHash, timeoutMs);
-    if (!result.confirmed) return null;
+  async getSourceCost(messageHash) {
+    const timeoutMs = 3e4;
+    const result = await this.checkTonTransaction(messageHash, timeoutMs);
+    if (!result.confirmed) {
+      console.warn("Transaction not found for source cost calculation");
+      return null;
+    }
     const totalFees = result.totalFees ?? 0n;
     const outValue = result.outValue ?? 0n;
     const totalNanotons = totalFees + outValue;
     const toTon = (value) => Number(value) / 1e9;
-    return {
+    const sourceCost = {
       totalNative: toTon(totalNanotons),
       breakdown: {
         gasFee: toTon(totalFees),
         layerZeroFee: toTon(outValue)
       }
     };
+    console.log("TON source cost:", {
+      gasFee: `${sourceCost.breakdown.gasFee} TON`,
+      layerZeroFee: `${sourceCost.breakdown.layerZeroFee} TON`,
+      total: `${sourceCost.totalNative} TON`
+    });
+    return sourceCost;
+  }
+  async estimateNetworkFee() {
+    const fee = Number(TON_CONFIG.estimatedNetworkFee);
+    if (!Number.isFinite(fee) || fee <= 0) {
+      return 0;
+    }
+    return fee / 1e9;
   }
   async checkTonTransaction(hashOrBoc, timeoutMs = 36e4) {
     const deadline = Date.now() + timeoutMs;
@@ -5978,10 +5638,6 @@ class TonChainStrategy {
       try {
         const inMessage = core.loadMessage(core.Cell.fromBase64(hashOrBoc).beginParse());
         if (inMessage.info.type !== "external-in") {
-          console.debug(
-            "Expected external-in message, got:",
-            inMessage.info.type
-          );
           return { confirmed: false };
         }
         accountAddress = inMessage.info.dest;
@@ -5989,63 +5645,50 @@ class TonChainStrategy {
       } catch {
         targetMessageHash = Buffer.from(hashOrBoc, "hex");
         if (!this.config.tonAddress) {
-          console.debug("No wallet address available for hex hash lookup");
           return { confirmed: false };
         }
         accountAddress = core.Address.parse(this.config.tonAddress);
       }
-      let lt2 = void 0;
-      let hash = void 0;
       while (Date.now() < deadline) {
         try {
           const transactions = await client.getTransactions(accountAddress, {
-            lt: lt2,
-            hash,
-            limit: 10,
+            limit: 20,
+            // Check last 20 transactions
             archival: true
           });
-          if (transactions.length === 0) {
-            await new Promise((r2) => setTimeout(r2, TON_CONFIG.pollingInterval));
-            lt2 = void 0;
-            hash = void 0;
-            continue;
-          }
           for (const tx of transactions) {
             if (tx.inMessage?.info.type === "external-in") {
-              const txInMessageHash = this.getNormalizedExtMessageHash(
-                tx.inMessage
-              );
-              if (txInMessageHash.equals(targetMessageHash)) {
-                console.debug("Transaction found by in-message hash");
-                const totalFees = this.toBigInt(
-                  tx.totalFees
-                ) ?? 0n;
-                const outValue = this.getFirstOutMessageValue(tx);
-                const feeInTon = Number(totalFees) / 1e9;
-                console.log(`TON transaction fee: ${feeInTon} TON`);
-                return {
-                  confirmed: true,
-                  fee: feeInTon.toString(),
-                  totalFees,
-                  outValue
-                };
+              try {
+                const txInMessageHash = this.getNormalizedExtMessageHash(
+                  tx.inMessage
+                );
+                if (txInMessageHash.equals(targetMessageHash)) {
+                  const totalFees = this.toBigInt(tx.totalFees) ?? this.toBigInt(
+                    tx.total_fees
+                  ) ?? 0n;
+                  const outValue = this.getTotalOutMessageValue(tx);
+                  const feeInTon = Number(totalFees) / 1e9;
+                  const transactionHash = tx.hash().toString("hex");
+                  return {
+                    confirmed: true,
+                    fee: feeInTon.toString(),
+                    totalFees,
+                    outValue,
+                    transactionHash
+                  };
+                }
+              } catch {
+                continue;
               }
             }
           }
-          const lastTx = transactions[transactions.length - 1];
-          lt2 = lastTx.lt.toString();
-          hash = lastTx.hash().toString("base64");
           await new Promise((r2) => setTimeout(r2, TON_CONFIG.pollingInterval));
-        } catch (error) {
-          console.debug("Error fetching transactions:", error);
+        } catch {
           await new Promise((r2) => setTimeout(r2, TON_CONFIG.pollingInterval));
-          lt2 = void 0;
-          hash = void 0;
         }
       }
       return { confirmed: false };
-    } catch (error) {
-      console.debug("Error parsing BOC or checking transaction:", error);
+    } catch {
       return { confirmed: false };
     }
   }
@@ -6055,6 +5698,7 @@ class TronChainStrategy {
   constructor(config) {
     __publicField(this, "config");
     __publicField(this, "fallbackClient");
+    __publicField(this, "apiKeyApplied", /* @__PURE__ */ new WeakSet());
     this.config = config;
   }
   canHandle(chainKey) {
@@ -6220,18 +5864,31 @@ class TronChainStrategy {
       const feeTrx = feeSun / 1e6;
       const lzFeeTrx = callValueSun / 1e6;
       const totalTrx = (feeSun + callValueSun) / 1e6;
-      return {
+      const sourceCost = {
         totalNative: totalTrx,
         breakdown: {
           gasFee: feeTrx,
           layerZeroFee: lzFeeTrx
         }
       };
+      console.log("TRON source cost:", {
+        gasFee: `${sourceCost.breakdown.gasFee} TRX`,
+        layerZeroFee: `${sourceCost.breakdown.layerZeroFee} TRX`,
+        total: `${sourceCost.totalNative} TRX`
+      });
+      return sourceCost;
     } catch (error) {
       console.warn("Failed to compute TRON source cost:", error);
       return null;
     }
   }
+  async estimateNetworkFee() {
+    const fee = Number(TRON_CONFIG.estimatedNetworkFee);
+    if (!Number.isFinite(fee) || fee <= 0) {
+      return 0;
+    }
+    return fee / 1e6;
+  }
   async executeSteps(steps, _context, onFirstHash) {
     const tronWeb = this.getClient();
     if (!tronWeb) {
@@ -6328,137 +5985,59 @@ class TronChainStrategy {
     }
     return { hash: lastTxId, chainKey: "tron" };
   }
-  async waitForCompletion(txHash) {
-    try {
-      const tronWeb = this.getClient();
-      if (!tronWeb) {
-        throw new ProviderNotAvailableError("tron");
-      }
-      console.log(
-        `Waiting for ${TRON_CONFIG.requiredConfirmations} confirmations for TRON tx: ${txHash}`
-      );
-      const deadline = Date.now() + TRON_CONFIG.timeout;
-      let txBlockNumber = null;
-      let actualFeeTrx = null;
-      while (Date.now() < deadline && !txBlockNumber) {
-        try {
-          const info = await tronWeb.trx.getTransactionInfo(txHash);
-          if (info && info.blockNumber) {
-            const result = info.receipt?.result;
-            if (result !== "SUCCESS") {
-              const msg = this.hexToAscii(info.resMessage) || null;
-              let reason = msg;
-              const cr2 = info.contractResult?.[0];
-              if (cr2 && /^0x?08c379a0/i.test(cr2)) {
-                try {
-                  const clean2 = cr2.replace(/^0x/, "");
-                  const len = parseInt(clean2.slice(8 + 64, 8 + 64 + 64), 16);
-                  const strHex = clean2.slice(
-                    8 + 64 + 64,
-                    8 + 64 + 64 + len * 2
-                  );
-                  const str = this.hexToAscii("0x" + strHex);
-                  if (str) reason = str;
-                } catch (e2) {
-                  console.debug("TRON revert string decode error", e2);
-                }
-              }
-              const error2 = new TransactionRevertedError(
-                "tron",
-                txHash,
-                reason || "Unknown error"
-              );
-              return {
-                completed: false,
-                error: error2.message
-              };
-            }
-            txBlockNumber = info.blockNumber;
-            const feeSun = info.fee || 0;
-            actualFeeTrx = feeSun / 1e6;
-            console.log(
-              `TRON transaction found in block ${txBlockNumber}, fee: ${actualFeeTrx} TRX`
-            );
-          }
-        } catch (e2) {
-          console.debug("TRON getTransactionInfo error:", e2);
-        }
-        if (!txBlockNumber) {
-          await new Promise((r2) => setTimeout(r2, TRON_CONFIG.pollingInterval));
-        }
-      }
-      if (!txBlockNumber) {
-        const error2 = new TransactionTimeoutError("tron", txHash);
-        return {
-          completed: false,
-          error: error2.message
-        };
-      }
-      let confirmations = 0;
-      while (Date.now() < deadline) {
-        try {
-          const currentBlock = await tronWeb.trx.getCurrentBlock();
-          const currentBlockNumber = currentBlock?.block_header?.raw_data?.number;
-          if (currentBlockNumber) {
-            confirmations = currentBlockNumber - txBlockNumber;
-            if (confirmations >= TRON_CONFIG.requiredConfirmations) {
-              console.log(
-                `TRON transaction confirmed in block ${txBlockNumber} with ${confirmations} confirmations`
-              );
-              return {
-                completed: true,
-                actualFeeValue: actualFeeTrx?.toString(),
-                actualFeeSymbol: "TRX"
-              };
-            }
-            console.log(
-              `TRON transaction confirmations: ${confirmations}/${TRON_CONFIG.requiredConfirmations}`
-            );
-          }
-        } catch (e2) {
-          console.debug("TRON getCurrentBlock error:", e2);
-        }
-        await new Promise((r2) => setTimeout(r2, TRON_CONFIG.pollingInterval));
-      }
-      const error = new TransactionTimeoutError("tron", txHash);
-      return {
-        completed: false,
-        error: error.message
-      };
-    } catch (error) {
-      const chainError = toChainStrategyError(
-        error,
-        "tron",
-        "waitForCompletion"
-      );
-      return {
-        completed: false,
-        error: chainError.message
-      };
-    }
-  }
   getClient() {
     if (typeof window !== "undefined" && window.tronWeb) {
+      this.applyTronApiKey(window.tronWeb);
       return window.tronWeb;
     }
     if (!this.fallbackClient) {
       this.fallbackClient = this.createFallbackClient();
     }
+    if (this.fallbackClient) {
+      this.applyTronApiKey(this.fallbackClient);
+    }
     return this.fallbackClient;
   }
   createFallbackClient() {
     try {
-      const tronWeb = new tronweb.TronWeb(
-        DEFAULT_TRON_NODE,
-        DEFAULT_TRON_NODE,
-        DEFAULT_TRON_NODE
-      );
+      if (!this.config.apiKey) {
+        throw new Error("TRON API key is required");
+      }
+      const headers = { "TRON-PRO-API-KEY": this.config.apiKey };
+      const tronWeb = new tronweb.TronWeb({
+        fullHost: DEFAULT_TRON_NODE,
+        headers
+      });
       return tronWeb;
     } catch (error) {
       console.warn("Failed to create fallback TronWeb client", error);
       return void 0;
     }
   }
+  applyTronApiKey(tronWeb) {
+    if (!this.config.apiKey) {
+      return;
+    }
+    const target = tronWeb;
+    if (this.apiKeyApplied.has(target)) {
+      return;
+    }
+    try {
+      const headers = { "TRON-PRO-API-KEY": this.config.apiKey };
+      if (typeof target.setHeader === "function") {
+        target.setHeader(headers);
+      } else {
+        if (typeof target.setFullNodeHeader === "function") {
+          target.setFullNodeHeader(headers);
+        }
+        if (typeof target.setEventHeader === "function") {
+          target.setEventHeader(headers);
+        }
+      }
+      this.apiKeyApplied.add(target);
+    } catch {
+    }
+  }
   /**
    * Check if TronLink wallet is actually installed
    * This excludes Bybit Wallet which also injects tronLink for compatibility
@@ -6467,14 +6046,8 @@ class TronChainStrategy {
     if (typeof window === "undefined") {
       return false;
     }
-    const hasBybitWallet = typeof window.bybitWallet !== "undefined" && typeof window.bybitWallet.tronLink !== "undefined";
-    if (hasBybitWallet && !window.tronLink) {
-      return false;
-    }
-    if (!window.tronLink) {
-      return false;
-    }
-    return true;
+    const win = window;
+    return !!(win.tronLink || win.tronWeb || win.tron);
   }
   ensureDefaultAddress(tronWeb, address) {
     if (!address) return;
@@ -6487,18 +6060,7 @@ class TronChainStrategy {
           hex
         };
       }
-    } catch (error) {
-      console.debug("Failed to set TronWeb default address:", error);
-    }
-  }
-  hexToAscii(h4) {
-    if (!h4) return null;
-    const clean2 = h4.replace(/^0x/, "");
-    const bytes = clean2.match(/.{1,2}/g) || [];
-    try {
-      return bytes.map((b2) => String.fromCharCode(parseInt(b2, 16))).join("");
     } catch {
-      return null;
     }
   }
   toBase58(addr, tronWeb) {
@@ -6805,22 +6367,14 @@ class TronChainStrategy {
       }
       const info = await tronWeb.trx.getTransactionInfo(txHash);
       if (!info || !info.blockNumber) {
-        console.debug(
-          "Transaction not yet solidified (no blockNumber in info)"
-        );
         return false;
       }
       const result = info.receipt?.result;
       if (result === "SUCCESS") {
-        console.log(
-          `Transaction ${txHash} is solidified in block ${info.blockNumber}`
-        );
         return true;
       }
-      console.debug(`Transaction solidified but result is: ${result}`);
       return false;
-    } catch (error) {
-      console.debug("Error checking solidified status:", error);
+    } catch {
       return false;
     }
   }
@@ -6831,7 +6385,8 @@ function ChainStrategyProvider({
   tonWallet,
   tronWallet,
   tonClient,
-  tonApiKey
+  tonApiKey,
+  tronApiKey
 }) {
   const evmStrategy = react.useMemo(
     () => new EvmChainStrategy({
@@ -6874,7 +6429,8 @@ function ChainStrategyProvider({
         connect: tronWallet.walletConnect.connect,
         disconnect: tronWallet.walletConnect.disconnect,
         signTransaction: tronWallet.walletConnect.signTransaction
-      } : void 0
+      } : void 0,
+      apiKey: tronApiKey
     }),
     [
       tronWallet.tronLink.address,
@@ -6882,7 +6438,8 @@ function ChainStrategyProvider({
       tronWallet.tronLink.select,
       tronWallet.tronLink.connect,
       tronWallet.tronLink.disconnect,
-      tronWallet.walletConnect
+      tronWallet.walletConnect,
+      tronApiKey
     ]
   );
   const chainRegistry = react.useMemo(
@@ -26237,7 +25794,7 @@ class WalletConnectModal {
   }
   async initUi() {
     if (typeof window !== "undefined") {
-      await Promise.resolve().then(() => require("./index-BTwKvCVG.cjs"));
+      await Promise.resolve().then(() => require("./index-BLC0Ys74.cjs"));
       const modal = document.createElement("wcm-modal");
       document.body.insertAdjacentElement("beforeend", modal);
       OptionsCtrl.setIsUiLoaded(true);
@@ -26730,6 +26287,7 @@ const EvaaBridgeWithProviders = (props) => {
       },
       tonClient: props.tonClient,
       tonApiKey: props.tonApiKey,
+      tronApiKey: props.tronApiKey,
       children: /* @__PURE__ */ jsxRuntime.jsx(EvaaBridgeContent, { ...props })
     }
   ) });
@@ -26955,16 +26513,10 @@ exports.RouteType = RouteType;
 exports.RouterCtrl = RouterCtrl;
 exports.ThemeCtrl = ThemeCtrl;
 exports.ToastCtrl = ToastCtrl;
-exports.addEvmNetworkFee = addEvmNetworkFee;
-exports.addTonNetworkFee = addTonNetworkFee;
-exports.addTronNetworkFee = addTronNetworkFee;
 exports.addrForApi = addrForApi;
 exports.buildAssetMatrix = buildAssetMatrix;
 exports.calculateMinReceived = calculateMinReceived;
 exports.computeFeesUsdFromArray = computeFeesUsdFromArray;
-exports.estimateEvmNetworkFee = estimateEvmNetworkFee;
-exports.estimateTonNetworkFee = estimateTonNetworkFee;
-exports.estimateTronNetworkFee = estimateTronNetworkFee;
 exports.findNativeMeta = findNativeMeta;
 exports.formatAddress = formatAddress;
 exports.formatBalance = formatBalance;
@@ -27008,4 +26560,4 @@ exports.useSettingsStore = useSettingsStore;
 exports.useSwapModel = useSwapModel;
 exports.useTokensStore = useTokensStore;
 exports.useTransactionStore = useTransactionStore;
-//# sourceMappingURL=index-CTtu-a2U.cjs.map
+//# sourceMappingURL=index-DiF0Z4eu.cjs.map