@rash2x/bridge-widget 0.2.11 → 0.3.0

package/dist/evaa-bridge.cjs

@@ -34,6 +34,7 @@ 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 = require("@/lib/utils");
 const skeleton = require("@/components/ui/skeleton");
@@ -44,7 +45,6 @@ const lucideReact = require("lucide-react");
 const framerMotion = require("framer-motion");
 const accordion = require("@/components/ui/accordion");
 const tooltip = require("@/components/ui/tooltip");
-const ton = require("@ton/ton");
 const sonner = require("sonner");
 const reactDialog = require("@radix-ui/react-dialog");
 const ethers = require("ethers");
@@ -53,8 +53,8 @@ const tronwalletAdapters = require("@tronweb3/tronwallet-adapters");
 const card = require("@/components/ui/card");
 const badge = require("@/components/ui/badge");
 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", "tonKeeper": "TonKeeper", "metaMask": "WalletConnect", "tronLink": "TronLink", "addTronWallet": "Add Tron wallet", "comingSoon": "Coming Soon", "connected": "CONNECTED", "disconnect": "Disconnect", "chooseWallet": "Choose 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", "searchToken": "Search token", "searchDestinationChain": "Search destination chain", "myTokens": "My tokens", "allTokens": "All tokens", "willChangeSourceChain": "Will Change Source Chain", "noBalancesFound": "No balances found.", "noResults": "No results", "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 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", "tronLink": "TronLink", "addTronWallet": "Add Tron wallet", "comingSoon": "Coming Soon", "connected": "CONNECTED", "disconnect": "Disconnect", "chooseWallet": "Choose 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", "searchToken": "Search token", "searchDestinationChain": "Search destination chain", "myTokens": "My tokens", "allTokens": "All tokens", "willChangeSourceChain": "Will change source network", "willChangeSourceNetworkAndToken": "Will change source network and token", "noBalancesFound": "No balances found.", "noResults": "No results", "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": "Processing...", "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", "finalFee": "Final Fee", "route": "Route", "estTime": "Est. Time", "slippage": "Slippage", "minimumReceived": "Minimum received", "totalFee": "Total Fee", "noRouteFound": "No route found", "notEnoughGas": "Not enough gas", "noRouteFoundForSettings": "No route found for current settings.", "tryAdjustSettings": "Try disabling Gas on Destination, or adjust amount/networks.", "quoteError": "Quote error" };
 const app$1 = { "stargateWidgetName": "Stargate Bridge Widget", "liveWidget": "Live Widget", "getStarted": "Get Started" };
 const settings$1 = { "title": "Settings", "gasOnDestination": "Gas on destination", "slippageTolerance": "Slippage tolerance", "routePriority": "Route Priority", "highSlippageWarning": "High slippage warning", "gasPresets": { "auto": "Auto", "none": "None", "medium": "Medium", "max": "Max" }, "routePresets": { "fastest": "Fastest", "cheapest": "Cheapest", "recommended": "Recommended" } };
@@ -69,8 +69,8 @@ const en = {
   errors: errors$1
 };
 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", "tonKeeper": "TonKeeper", "metaMask": "WalletConnect", "tronLink": "TronLink", "addTronWallet": "Добавить Tron кошелёк", "comingSoon": "Скоро", "connected": "ПОДКЛЮЧЕНО", "disconnect": "Отключить", "chooseWallet": "Выберите кошелёк", "oneWalletPerEnv": "Можно подключить только один кошелёк на окружение.", "connect": "Подключить", "connectTronWallet": "Подключить Tron кошелёк", "connectWallet": "Подключить кошелёк" };
-const bridge = { "max": "Макс", "sourceNetwork": "Исходная сеть", "destinationNetwork": "Целевая сеть", "selectToken": "Выбрать токен", "selectNetwork": "Выбрать сеть", "searchToken": "Поиск токена", "searchDestinationChain": "Поиск целевой сети", "myTokens": "Мои токены", "allTokens": "Все токены", "willChangeSourceChain": "Сменит исходную сеть", "noBalancesFound": "Балансы не найдены.", "noResults": "Нет результатов", "sendToAnotherAddress": "Отправить на другой адрес", "youWillReceive": "Вы получите", "anotherAddressPlaceholder": "Адрес", "addressDoesntMatch": "Адрес не соответствует сети {{network}}", "checkBeforeTransfer": "Проверьте корректность перед переводом" };
+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", "tronLink": "TronLink", "addTronWallet": "Добавить Tron кошелёк", "comingSoon": "Скоро", "connected": "ПОДКЛЮЧЕНО", "disconnect": "Отключить", "chooseWallet": "Выберите кошелёк", "oneWalletPerEnv": "Можно подключить только один кошелёк на окружение.", "connect": "Подключить", "connectTronWallet": "Подключить Tron кошелёк", "connectWallet": "Подключить кошелёк" };
+const bridge = { "max": "Макс", "sourceNetwork": "Исходная сеть", "destinationNetwork": "Целевая сеть", "selectToken": "Выбрать токен", "selectNetwork": "Выбрать сеть", "searchToken": "Поиск токена", "searchDestinationChain": "Поиск целевой сети", "myTokens": "Мои токены", "allTokens": "Все токены", "willChangeSourceChain": "Сменит исходную сеть", "willChangeSourceNetworkAndToken": "Сменит исходную сеть и токен", "noBalancesFound": "Балансы не найдены.", "noResults": "Нет результатов", "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": "Хэш", "finalFee": "Итоговая комиссия", "route": "Маршрут", "estTime": "Время", "slippage": "Проскальзывание", "minimumReceived": "Минимум к получению", "totalFee": "Общая комиссия", "noRouteFound": "Маршрут не найден", "notEnoughGas": "Недостаточно газа", "noRouteFoundForSettings": "Маршрут не найден для текущих настроек.", "tryAdjustSettings": "Попробуйте отключить Gas on Destination или измените сумму/сети.", "quoteError": "Ошибка котировки" };
 const app = { "stargateWidgetName": "Виджет Stargate Bridge", "liveWidget": "Живой виджет", "getStarted": "Начало работы" };
 const settings = { "title": "Настройки", "gasOnDestination": "Газ на назначении", "slippageTolerance": "Толерантность к проскальзыванию", "routePriority": "Приоритет маршрута", "highSlippageWarning": "Высокое проскальзывание", "gasPresets": { "auto": "Авто", "none": "Нет", "medium": "Средний", "max": "Макс" }, "routePresets": { "fastest": "Быстрейший", "cheapest": "Дешевейший", "recommended": "Рекомендуемый" } };
@@ -121,72 +121,282 @@ function BridgeI18nProvider({
 function useBridgeTranslation() {
   return reactI18next.useTranslation("evaa-bridge", { i18n: bridgeI18n });
 }
-const useChainsStore = zustand.create((set, get) => ({
-  chains: void 0,
-  fromChain: void 0,
-  toChain: void 0,
-  allowedFromChains: void 0,
-  allowedToChains: void 0,
-  isLoadingToChains: false,
-  setChains: async (data) => {
-    const prev = get().chains;
-    const same = (() => {
-      if (!prev && !data) return true;
-      if (!prev || !data) return false;
-      if (prev.length !== data.length) return false;
-      for (let i = 0; i < prev.length; i++) {
-        if (prev[i]?.chainKey !== data[i]?.chainKey) return false;
+function createJSONStorage(getStorage, options) {
+  let storage;
+  try {
+    storage = getStorage();
+  } catch (e) {
+    return;
+  }
+  const persistStorage = {
+    getItem: (name) => {
+      var _a;
+      const parse = (str2) => {
+        if (str2 === null) {
+          return null;
+        }
+        return JSON.parse(str2, void 0);
+      };
+      const str = (_a = storage.getItem(name)) != null ? _a : null;
+      if (str instanceof Promise) {
+        return str.then(parse);
       }
-      return true;
-    })();
-    if (same) return;
-    set({ chains: data });
-  },
-  setFromChain: (data) => {
-    const prev = get().fromChain;
-    if ((prev?.chainKey ?? null) === (data?.chainKey ?? null)) return;
-    set({ fromChain: data });
-  },
-  setToChain: (data) => {
-    const prev = get().toChain;
-    if ((prev?.chainKey ?? null) === (data?.chainKey ?? null)) return;
-    set({ toChain: data });
-  },
-  setAllowedFromChains: (data) => {
-    const prev = get().allowedFromChains;
-    const same = (() => {
-      if (!prev && !data) return true;
-      if (!prev || !data) return false;
-      if (prev.length !== data.length) return false;
-      for (let i = 0; i < prev.length; i++) {
-        if (prev[i]?.chainKey !== data[i]?.chainKey) return false;
+      return parse(str);
+    },
+    setItem: (name, newValue) => storage.setItem(name, JSON.stringify(newValue, void 0)),
+    removeItem: (name) => storage.removeItem(name)
+  };
+  return persistStorage;
+}
+const toThenable = (fn) => (input2) => {
+  try {
+    const result = fn(input2);
+    if (result instanceof Promise) {
+      return result;
+    }
+    return {
+      then(onFulfilled) {
+        return toThenable(onFulfilled)(result);
+      },
+      catch(_onRejected) {
+        return this;
       }
-      return true;
-    })();
-    if (same) return;
-    set({ allowedFromChains: data });
-  },
-  setAllowedToChains: (data) => {
-    const prev = get().allowedToChains;
-    const same = (() => {
-      if (!prev && !data) return true;
-      if (!prev || !data) return false;
-      if (prev.length !== data.length) return false;
-      for (let i = 0; i < prev.length; i++) {
-        if (prev[i]?.chainKey !== data[i]?.chainKey) return false;
+    };
+  } catch (e) {
+    return {
+      then(_onFulfilled) {
+        return this;
+      },
+      catch(onRejected) {
+        return toThenable(onRejected)(e);
       }
-      return true;
-    })();
-    if (same) return;
-    set({ allowedToChains: data });
-  },
-  setIsLoadingToChains: (v) => set({ isLoadingToChains: v }),
-  swapChains: () => set((state) => ({
-    fromChain: state.toChain,
-    toChain: state.fromChain
-  }))
-}));
-const norm = (s) => (s ?? "").toUpperCase().replace(/₮/g, "T").replace(/[^A-Z0-9]/g, "");
+    };
+  }
+};
+const persistImpl = (config, baseOptions) => (set, get, api) => {
+  let options = {
+    storage: createJSONStorage(() => localStorage),
+    partialize: (state) => state,
+    version: 0,
+    merge: (persistedState, currentState) => ({
+      ...currentState,
+      ...persistedState
+    }),
+    ...baseOptions
+  };
+  let hasHydrated = false;
+  const hydrationListeners = /* @__PURE__ */ new Set();
+  const finishHydrationListeners = /* @__PURE__ */ new Set();
+  let storage = options.storage;
+  if (!storage) {
+    return config(
+      (...args) => {
+        console.warn(
+          `[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
+        );
+        set(...args);
+      },
+      get,
+      api
+    );
+  }
+  const setItem = () => {
+    const state = options.partialize({ ...get() });
+    return storage.setItem(options.name, {
+      state,
+      version: options.version
+    });
+  };
+  const savedSetState = api.setState;
+  api.setState = (state, replace) => {
+    savedSetState(state, replace);
+    return setItem();
+  };
+  const configResult = config(
+    (...args) => {
+      set(...args);
+      return setItem();
+    },
+    get,
+    api
+  );
+  api.getInitialState = () => configResult;
+  let stateFromStorage;
+  const hydrate = () => {
+    var _a, _b;
+    if (!storage) return;
+    hasHydrated = false;
+    hydrationListeners.forEach((cb) => {
+      var _a2;
+      return cb((_a2 = get()) != null ? _a2 : configResult);
+    });
+    const postRehydrationCallback = ((_b = options.onRehydrateStorage) == null ? void 0 : _b.call(options, (_a = get()) != null ? _a : configResult)) || void 0;
+    return toThenable(storage.getItem.bind(storage))(options.name).then((deserializedStorageValue) => {
+      if (deserializedStorageValue) {
+        if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
+          if (options.migrate) {
+            const migration = options.migrate(
+              deserializedStorageValue.state,
+              deserializedStorageValue.version
+            );
+            if (migration instanceof Promise) {
+              return migration.then((result) => [true, result]);
+            }
+            return [true, migration];
+          }
+          console.error(
+            `State loaded from storage couldn't be migrated since no migrate function was provided`
+          );
+        } else {
+          return [false, deserializedStorageValue.state];
+        }
+      }
+      return [false, void 0];
+    }).then((migrationResult) => {
+      var _a2;
+      const [migrated, migratedState] = migrationResult;
+      stateFromStorage = options.merge(
+        migratedState,
+        (_a2 = get()) != null ? _a2 : configResult
+      );
+      set(stateFromStorage, true);
+      if (migrated) {
+        return setItem();
+      }
+    }).then(() => {
+      postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0);
+      stateFromStorage = get();
+      hasHydrated = true;
+      finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
+    }).catch((e) => {
+      postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e);
+    });
+  };
+  api.persist = {
+    setOptions: (newOptions) => {
+      options = {
+        ...options,
+        ...newOptions
+      };
+      if (newOptions.storage) {
+        storage = newOptions.storage;
+      }
+    },
+    clearStorage: () => {
+      storage == null ? void 0 : storage.removeItem(options.name);
+    },
+    getOptions: () => options,
+    rehydrate: () => hydrate(),
+    hasHydrated: () => hasHydrated,
+    onHydrate: (cb) => {
+      hydrationListeners.add(cb);
+      return () => {
+        hydrationListeners.delete(cb);
+      };
+    },
+    onFinishHydration: (cb) => {
+      finishHydrationListeners.add(cb);
+      return () => {
+        finishHydrationListeners.delete(cb);
+      };
+    }
+  };
+  if (!options.skipHydration) {
+    hydrate();
+  }
+  return stateFromStorage || configResult;
+};
+const persist = persistImpl;
+const useChainsStore = zustand.create()(
+  persist(
+    (set, get) => ({
+      chains: void 0,
+      fromChain: void 0,
+      toChain: void 0,
+      allowedFromChains: void 0,
+      allowedToChains: void 0,
+      isLoadingToChains: false,
+      setChains: async (data) => {
+        const prev = get().chains;
+        const same = (() => {
+          if (!prev && !data) return true;
+          if (!prev || !data) return false;
+          if (prev.length !== data.length) return false;
+          for (let i = 0; i < prev.length; i++) {
+            if (prev[i]?.chainKey !== data[i]?.chainKey) return false;
+          }
+          return true;
+        })();
+        if (same) return;
+        set({ chains: data });
+      },
+      setFromChain: (data) => {
+        const prev = get().fromChain;
+        if ((prev?.chainKey ?? null) === (data?.chainKey ?? null)) return;
+        set({ fromChain: data });
+      },
+      setToChain: (data) => {
+        const prev = get().toChain;
+        if ((prev?.chainKey ?? null) === (data?.chainKey ?? null)) return;
+        set({ toChain: data });
+      },
+      setAllowedFromChains: (data) => {
+        const prev = get().allowedFromChains;
+        const same = (() => {
+          if (!prev && !data) return true;
+          if (!prev || !data) return false;
+          if (prev.length !== data.length) return false;
+          for (let i = 0; i < prev.length; i++) {
+            if (prev[i]?.chainKey !== data[i]?.chainKey) return false;
+          }
+          return true;
+        })();
+        if (same) return;
+        set({ allowedFromChains: data });
+      },
+      setAllowedToChains: (data) => {
+        const prev = get().allowedToChains;
+        const same = (() => {
+          if (!prev && !data) return true;
+          if (!prev || !data) return false;
+          if (prev.length !== data.length) return false;
+          for (let i = 0; i < prev.length; i++) {
+            if (prev[i]?.chainKey !== data[i]?.chainKey) return false;
+          }
+          return true;
+        })();
+        if (same) return;
+        set({ allowedToChains: data });
+      },
+      setIsLoadingToChains: (v) => set({ isLoadingToChains: v }),
+      swapChains: () => set((state) => ({
+        fromChain: state.toChain,
+        toChain: state.fromChain
+      }))
+    }),
+    {
+      name: "evaa-bridge-chains",
+      storage: createJSONStorage(() => sessionStorage),
+      partialize: (state) => ({
+        fromChain: state.fromChain,
+        toChain: state.toChain
+      })
+    }
+  )
+);
+function normalizeTickerSymbol$1(s) {
+  return s.toUpperCase().replace(/₮/g, "T").replace(/[^A-Z0-9]/g, "");
+}
+function normalizeTokenSymbol(token) {
+  let normalizedSymbol = token.symbol.toUpperCase().replace(/₮/g, "T");
+  normalizedSymbol = normalizedSymbol.replace(/^S\*/, "");
+  normalizedSymbol = normalizedSymbol.replace(/0\.S$/i, "").replace(/0$/, "").replace(/\.S$/i, "");
+  normalizedSymbol = normalizedSymbol.replace(/\.E$/i, "").replace(/\.N$/i, "");
+  return {
+    ...token,
+    symbol: normalizedSymbol
+  };
+}
 const POPULAR_ORDER = [
   "USDT",
   "USDC",
@@ -222,6 +432,16 @@ function buildAssetMatrix(tokens) {
     if (!symbol) continue;
     (m[symbol] || (m[symbol] = {}))[t.chainKey] = t;
   }
+  const chainStats = {};
+  Object.values(m).forEach((byChain) => {
+    Object.keys(byChain).forEach((chainKey) => {
+      chainStats[chainKey] = (chainStats[chainKey] || 0) + 1;
+    });
+  });
+  console.log(
+    `[DEBUG] Asset matrix built: ${Object.keys(m).length} assets across chains:`,
+    chainStats
+  );
   return m;
 }
 function listAssetsForSelect(tokens) {
@@ -231,11 +451,11 @@ function listAssetsForSelect(tokens) {
     const preferred = pickOrder.map((k) => byChain[k]).find(Boolean) ?? Object.values(byChain)[0];
     return preferred;
   });
-  const byNorm = new Map(base.map((e) => [norm(e.symbol), e]));
+  const byNorm = new Map(base.map((e) => [normalizeTickerSymbol$1(e.symbol), e]));
   const used = /* @__PURE__ */ new Set();
   const popular = [];
   for (const s of POPULAR_ORDER) {
-    const key = norm(s);
+    const key = normalizeTickerSymbol$1(s);
     const item = byNorm.get(key);
     if (item && !used.has(key)) {
       popular.push(item);
@@ -243,11 +463,11 @@ function listAssetsForSelect(tokens) {
     }
   }
   const stable = base.filter((e) => {
-    const k = norm(e.symbol);
+    const k = normalizeTickerSymbol$1(e.symbol);
     return !used.has(k) && STABLES.has(k);
   }).sort((a, b) => a.symbol.localeCompare(b.symbol));
-  for (const e of stable) used.add(norm(e.symbol));
-  const other = base.filter((e) => !used.has(norm(e.symbol))).sort((a, b) => a.symbol.localeCompare(b.symbol));
+  for (const e of stable) used.add(normalizeTickerSymbol$1(e.symbol));
+  const other = base.filter((e) => !used.has(normalizeTickerSymbol$1(e.symbol))).sort((a, b) => a.symbol.localeCompare(b.symbol));
   return [...popular, ...stable, ...other];
 }
 function resolveTokenOnChain(tokens, assetSymbol, chainKey) {
@@ -652,163 +872,636 @@ function isAddressValidForChain(chainKey, addr) {
   if (chainKey === "tron") return isTronAddress(addr);
   return isEvmAddress(addr);
 }
-function useBridgeQuote() {
-  const { assetMatrix, selectedAssetSymbol } = useTokensStore();
-  const { fromChain, toChain } = useChainsStore();
-  const { srcAddress, dstAddress } = useAddresses();
-  const { slippageBps, routePriority, getDstNativeAmount, getSlippageDecimal } = useSettingsStore();
-  const {
-    inputAmount,
-    refetchTrigger,
-    setLoading: setQuoteLoading,
-    setQuote,
-    setError: setQError,
-    setNoRoute,
-    resetWithIdle
-  } = useBridgeQuoteStore();
-  const input2 = inputAmount;
-  const srcTokenOnFrom = react.useMemo(
-    () => resolveTokenOnChainFromMatrix$2(
-      assetMatrix,
-      selectedAssetSymbol,
-      fromChain?.chainKey
-    ),
-    [assetMatrix, selectedAssetSymbol, fromChain?.chainKey]
-  );
-  const dstTokenOnTo = react.useMemo(
-    () => resolveTokenOnChainFromMatrix$2(
-      assetMatrix,
-      selectedAssetSymbol,
-      toChain?.chainKey
-    ),
-    [assetMatrix, selectedAssetSymbol, toChain?.chainKey]
-  );
-  const [loading, setLoading] = react.useState(false);
-  react.useEffect(() => {
-    if (!input2 || input2 === "") {
-      setLoading(false);
-      resetWithIdle();
-    }
-  }, [input2, resetWithIdle]);
-  react.useEffect(() => {
-    const resetUi = (withError) => {
-      setLoading(false);
-      {
-        resetWithIdle();
-      }
-    };
-    if (!input2 || Number(input2) <= 0 || !fromChain?.chainKey || !toChain?.chainKey || !srcTokenOnFrom || !dstTokenOnTo || !srcAddress || !dstAddress) {
-      resetUi();
-      return;
-    }
-    if (!isAddressValidForChain(fromChain.chainKey, srcAddress) || !isAddressValidForChain(toChain.chainKey, dstAddress)) {
-      resetUi();
-      return;
-    }
-    if (fromChain.chainKey === toChain.chainKey) {
-      resetUi();
-      return;
-    }
-    let cancelled = false;
-    const run = async () => {
-      try {
-        setLoading(true);
-        setQuoteLoading?.();
-        if (assetMatrix && selectedAssetSymbol) {
-          const tokenMatrix = assetMatrix[selectedAssetSymbol.toUpperCase()];
-          if (!tokenMatrix || !tokenMatrix[fromChain.chainKey] || !tokenMatrix[toChain.chainKey]) {
-            if (!cancelled) {
-              resetUi();
-            }
-            return;
-          }
-        }
-        const srcAmountLD = toLD(input2, srcTokenOnFrom.decimals);
-        const srcAddrApi = addrForApi(fromChain.chainKey, srcAddress);
-        const dstAddrApi = addrForApi(toChain.chainKey, dstAddress);
-        const dstNativeAmount = getDstNativeAmount(toChain.chainKey);
-        const slippageDecimal = getSlippageDecimal();
-        const approximateMinLD = BigInt(srcAmountLD) * BigInt(9500) / BigInt(1e4);
-        const quoteRoute = await getQuotesByPriority({
-          srcChainKey: fromChain.chainKey,
-          dstChainKey: toChain.chainKey,
-          srcToken: srcTokenOnFrom.address,
-          dstToken: dstTokenOnTo.address,
-          srcAmountLD,
-          dstAmountMinLD: approximateMinLD.toString(),
-          srcAddress: srcAddrApi,
-          dstAddress: dstAddrApi,
-          dstNativeAmount,
-          slippage: slippageDecimal,
-          routePriority
-        });
-        if (quoteRoute?.route === null) {
-          setNoRoute(true);
-          if (!cancelled) resetUi();
-          return;
-        } else {
-          setNoRoute(false);
-        }
-        if (!quoteRoute || !quoteRoute.dstAmount || BigInt(quoteRoute.dstAmount) === BigInt(0)) {
-          if (!cancelled) resetUi();
-          return;
-        }
-        if (cancelled) return;
-        setQuote(quoteRoute);
-      } catch {
-        if (!cancelled) {
-          resetUi();
-        }
-      } finally {
-        if (!cancelled) setLoading(false);
-      }
-    };
-    run();
-    return () => {
-      cancelled = true;
-    };
-  }, [
-    input2,
-    fromChain?.chainKey,
-    toChain?.chainKey,
-    srcTokenOnFrom,
-    dstTokenOnTo,
-    srcAddress,
-    dstAddress,
-    setQuoteLoading,
-    setQuote,
-    setQError,
-    slippageBps,
-    routePriority,
-    refetchTrigger
-  ]);
-  return { loading };
-}
-async function getChains() {
-  const res = await fetch("https://stargate.finance/api/v1/chains", {
-    credentials: "same-origin"
-  });
-  if (!res.ok) {
-    throw new Error(`Failed to load chains: ${res.status}`);
+const ChainStrategyContext = react.createContext(void 0);
+function useChainStrategies() {
+  const context = react.useContext(ChainStrategyContext);
+  if (!context) {
+    throw new Error(
+      "useChainStrategies must be used within ChainStrategyProvider"
+    );
   }
-  const data = await res.json();
-  return Array.isArray(data) ? data : data.chains ?? [];
+  return context;
 }
-async function getTokens() {
-  const res = await fetch("https://stargate.finance/api/v1/tokens", {
-    credentials: "same-origin"
-  });
-  if (!res.ok) {
-    throw new Error(`Failed to load chains: ${res.status}`);
+const truncateToDecimals = (num, decimals) => {
+  if (!isFinite(num) || isNaN(num)) return "0.00";
+  const multiplier = Math.pow(10, decimals);
+  const truncated = Math.floor(num * multiplier) / multiplier;
+  return truncated.toFixed(decimals);
+};
+const formatTokenAmount = (amount, symbol, options) => {
+  const normalizedSymbol = (symbol ?? "").toUpperCase();
+  if (["USDT", "USDC", "DAI", "BUSD"].includes(normalizedSymbol) && amount >= 1) {
+    return `${Math.floor(amount)} ${normalizedSymbol}`;
   }
-  const data = await res.json();
-  return Array.isArray(data) ? data : data.tokens ?? [];
-}
-async function getDestTokens(srcChainKey, srcTokenAddr) {
-  const url = new URL("https://stargate.finance/api/v1/tokens");
-  url.searchParams.set("srcChainKey", srcChainKey);
-  url.searchParams.set("srcToken", srcTokenAddr);
-  const res = await fetch(url.toString(), { credentials: "omit" });
+  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)}%`;
+};
+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 {
+      totalUsd: 0,
+      protocolFeeUsd: void 0,
+      messageFeeUsd: void 0,
+      serviceUsd: void 0,
+      blockchainUsd: void 0,
+      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.totalUsd > 0 && srcToken.price?.usd) {
+      const feeInSrcApprox = feeData.totalUsd / 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 {
+    totalUsd: feeData.totalUsd,
+    protocolFeeUsd: feeData.protocolFeeUsd,
+    messageFeeUsd: feeData.messageFeeUsd,
+    serviceUsd: feeData.serviceUsd,
+    blockchainUsd: feeData.blockchainUsd,
+    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(
+      (s) => s.chainKey.toLowerCase() === "ton" && s.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(
+    (c) => c.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(
+      (s) => s.chainKey.toLowerCase() === "tron" && s.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(
+    (c) => c.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;
+    console.log(
+      `EVM gas estimate: ${totalGasLimit} gas × ${gasPrice} Wei/gas = ${totalCostWei} Wei`
+    );
+    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(
+    (c) => c.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",
+    // 0.01 ETH fallback
+    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 useBridgeQuote() {
+  const { assetMatrix, selectedAssetSymbol } = useTokensStore();
+  const { fromChain, toChain, chains } = useChainsStore();
+  const { srcAddress, dstAddress } = useAddresses();
+  const { slippageBps, routePriority, getDstNativeAmount, getSlippageDecimal } = useSettingsStore();
+  const {
+    inputAmount,
+    refetchTrigger,
+    setLoading: setQuoteLoading,
+    setQuote,
+    setError: setQError,
+    setNoRoute,
+    resetWithIdle
+  } = useBridgeQuoteStore();
+  const { chainRegistry } = useChainStrategies();
+  const publicClient = wagmi.usePublicClient();
+  const input2 = inputAmount;
+  const srcTokenOnFrom = react.useMemo(
+    () => resolveTokenOnChainFromMatrix$2(
+      assetMatrix,
+      selectedAssetSymbol,
+      fromChain?.chainKey
+    ),
+    [assetMatrix, selectedAssetSymbol, fromChain?.chainKey]
+  );
+  const dstTokenOnTo = react.useMemo(
+    () => resolveTokenOnChainFromMatrix$2(
+      assetMatrix,
+      selectedAssetSymbol,
+      toChain?.chainKey
+    ),
+    [assetMatrix, selectedAssetSymbol, toChain?.chainKey]
+  );
+  const [loading, setLoading] = react.useState(false);
+  react.useEffect(() => {
+    if (!input2 || input2 === "") {
+      setLoading(false);
+      resetWithIdle();
+    }
+  }, [input2, resetWithIdle]);
+  react.useEffect(() => {
+    const resetUi = (withError) => {
+      setLoading(false);
+      {
+        resetWithIdle();
+      }
+    };
+    if (!input2 || Number(input2) <= 0 || !fromChain?.chainKey || !toChain?.chainKey || !srcTokenOnFrom || !dstTokenOnTo || !srcAddress || !dstAddress) {
+      resetUi();
+      return;
+    }
+    if (!isAddressValidForChain(fromChain.chainKey, srcAddress) || !isAddressValidForChain(toChain.chainKey, dstAddress)) {
+      resetUi();
+      return;
+    }
+    if (fromChain.chainKey === toChain.chainKey) {
+      resetUi();
+      return;
+    }
+    let cancelled = false;
+    const run = async () => {
+      try {
+        setLoading(true);
+        setQuoteLoading?.();
+        if (assetMatrix && selectedAssetSymbol) {
+          const tokenMatrix = assetMatrix[selectedAssetSymbol.toUpperCase()];
+          if (!tokenMatrix || !tokenMatrix[fromChain.chainKey] || !tokenMatrix[toChain.chainKey]) {
+            if (!cancelled) {
+              resetUi();
+            }
+            return;
+          }
+        }
+        const srcAmountLD = toLD(input2, srcTokenOnFrom.decimals);
+        const srcAddrApi = addrForApi(fromChain.chainKey, srcAddress);
+        const dstAddrApi = addrForApi(toChain.chainKey, dstAddress);
+        const dstNativeAmount = getDstNativeAmount(toChain.chainKey);
+        const slippageDecimal = getSlippageDecimal();
+        const approximateMinLD = BigInt(srcAmountLD) * BigInt(9500) / BigInt(1e4);
+        const quoteRoute = await getQuotesByPriority({
+          srcChainKey: fromChain.chainKey,
+          dstChainKey: toChain.chainKey,
+          srcToken: srcTokenOnFrom.address,
+          dstToken: dstTokenOnTo.address,
+          srcAmountLD,
+          dstAmountMinLD: approximateMinLD.toString(),
+          srcAddress: srcAddrApi,
+          dstAddress: dstAddrApi,
+          dstNativeAmount,
+          slippage: slippageDecimal,
+          routePriority
+        });
+        if (quoteRoute?.route === null) {
+          setNoRoute(true);
+          if (!cancelled) resetUi();
+          return;
+        } else {
+          setNoRoute(false);
+        }
+        if (!quoteRoute || !quoteRoute.dstAmount || BigInt(quoteRoute.dstAmount) === BigInt(0)) {
+          if (!cancelled) resetUi();
+          return;
+        }
+        if (cancelled) return;
+        let quoteWithFees = quoteRoute;
+        if (quoteRoute.srcChainKey.toLowerCase() === "ton") {
+          try {
+            const estimatedFee = estimateTonNetworkFee(quoteRoute);
+            quoteWithFees = addTonNetworkFee(quoteRoute, chains, estimatedFee);
+            console.log("TON network fee estimated for quote:", 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
+                );
+                console.log("TRON network fee estimated for quote:", 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
+              );
+              console.log("EVM network fee estimated for quote:", 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);
+      } catch {
+        if (!cancelled) {
+          resetUi();
+        }
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    };
+    run();
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    input2,
+    fromChain?.chainKey,
+    toChain?.chainKey,
+    srcTokenOnFrom,
+    dstTokenOnTo,
+    srcAddress,
+    dstAddress,
+    setQuoteLoading,
+    setQuote,
+    setQError,
+    slippageBps,
+    routePriority,
+    refetchTrigger,
+    chainRegistry,
+    chains,
+    publicClient
+  ]);
+  return { loading };
+}
+async function getChains() {
+  const res = await fetch("https://stargate.finance/api/v1/chains", {
+    credentials: "same-origin"
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to load chains: ${res.status}`);
+  }
+  const data = await res.json();
+  return Array.isArray(data) ? data : data.chains ?? [];
+}
+async function getTokens() {
+  const res = await fetch("https://stargate.finance/api/v1/tokens", {
+    credentials: "same-origin"
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to load chains: ${res.status}`);
+  }
+  const data = await res.json();
+  const tokens = Array.isArray(data) ? data : data.tokens ?? [];
+  return tokens.map(normalizeTokenSymbol);
+}
+async function getDestTokens(srcChainKey, srcTokenAddr) {
+  const url = new URL("https://stargate.finance/api/v1/tokens");
+  url.searchParams.set("srcChainKey", srcChainKey);
+  url.searchParams.set("srcToken", srcTokenAddr);
+  const res = await fetch(url.toString(), { credentials: "omit" });
   if (!res.ok) throw new Error(`Failed to load dest tokens: ${res.status}`);
   const data = await res.json();
   const raw = data.tokens ?? [];
@@ -829,10 +1522,7 @@ async function getDestTokens(srcChainKey, srcTokenAddr) {
     if (sa === sb) return (a.name ?? "").localeCompare(b.name ?? "");
     return sa.localeCompare(sb);
   });
-  return unique;
-}
-function normalizeTickerSymbol$1(s) {
-  return s.toUpperCase().replace(/₮/g, "T").replace(/[^A-Z0-9]/g, "");
+  return unique.map(normalizeTokenSymbol);
 }
 function resolveTokenOnChainFromMatrix$1(assetMatrix, assetSymbol, chainKey) {
   if (!assetMatrix || !assetSymbol || !chainKey) return void 0;
@@ -859,7 +1549,14 @@ const useChainDerivations = () => {
       return [];
     const byChain = assetMatrix[selectedAssetSymbol.toUpperCase()];
     const keys = new Set(Object.keys(byChain ?? {}));
-    return chains.filter((c) => keys.has(c.chainKey));
+    const result = chains.filter((c) => keys.has(c.chainKey));
+    console.log(
+      `[DEBUG] supportedFrom for ${selectedAssetSymbol}:`,
+      `${result.length} of ${chains.length} chains`,
+      result.map((c) => c.chainKey),
+      `| Has Arbitrum: ${result.some((c) => c.chainKey === "arbitrum")}`
+    );
+    return result;
   }, [selectedAssetSymbol, assetMatrix, chains]);
   react.useEffect(() => {
     setAllowedFromChains(supportedFrom);
@@ -927,6 +1624,13 @@ const useChainDerivations = () => {
         if (fromChain?.chainKey) {
           list = list.filter((c) => c.chainKey !== fromChain.chainKey);
         }
+        console.log(
+          `[DEBUG] allowedToChains from ${fromChain?.chainKey}:`,
+          `${list.length} destinations`,
+          list.map((c) => c.chainKey),
+          `| Has Arbitrum: ${list.some((c) => c.chainKey === "arbitrum")}`,
+          `| API returned ${dest.length} tokens, filtered to ${filteredDest.length}`
+        );
         setAllowedToChains(list);
         if (!toChain || !list.some((c) => c.chainKey === toChain.chainKey)) {
           setToChain(list[0]);
@@ -961,16 +1665,6 @@ const useChainDerivations = () => {
     isLoadingToChains
   };
 };
-const ChainStrategyContext = react.createContext(void 0);
-function useChainStrategies() {
-  const context = react.useContext(ChainStrategyContext);
-  if (!context) {
-    throw new Error(
-      "useChainStrategies must be used within ChainStrategyProvider"
-    );
-  }
-  return context;
-}
 function useBalances(chainKey, address, priorityTokenSymbol) {
   const { chainRegistry } = useChainStrategies();
   const { assetMatrix } = useTokensStore();
@@ -1334,7 +2028,7 @@ const StargateIcon = (props) => {
             "path",
             {
               d: "M4.37473 7.21715L4.86639 7.00685C5.83193 6.59514 6.59903 5.82804 7.01074 4.86248L7.22104 4.37082C7.51425 3.68368 8.49163 3.68368 8.78489 4.37082L8.99514 4.86248C9.40685 5.82804 10.1739 6.59514 11.1395 7.00685L11.6312 7.21715C12.3183 7.51036 12.3183 8.4848 11.6312 8.78095L11.1395 8.99125C10.1739 9.40296 9.40685 10.1701 8.99514 11.1356L8.78489 11.6273C8.49163 12.3144 7.51425 12.3144 7.22104 11.6273L7.01074 11.1356C6.59903 10.1701 5.83193 9.40296 4.86639 8.99125L4.37473 8.78095C3.68759 8.48774 3.68759 7.5133 4.37473 7.21715Z",
-              fill: "#FAFAFA"
+              fill: "currentColor"
             }
           )
         ] }),
@@ -1470,7 +2164,7 @@ const WalletConnectIcon = (props) => {
     }
   );
 };
-const TonKeeperIcon = (props) => {
+const TonConnectIcon = (props) => {
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "svg",
     {
@@ -1660,7 +2354,7 @@ const SelectNetworkButton = ({
       size: "sm",
       variant: "secondary",
       type: "button",
-      className: "shrink-0 gap-2 bg-card text-card-foreground hover:text-card-foreground h-9",
+      className: "shrink-0 gap-2 h-9 !pl-2",
       "aria-label": label,
       children: [
         /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2 items-center", children: [
@@ -1751,49 +2445,37 @@ const SearchInput = ({
   placeholder,
   value,
   onChange,
-  className,
-  containerClassName
+  className
 }) => {
-  const [isFocused, setIsFocused] = react.useState(false);
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    "div",
-    {
-      className: utils.cn(
-        "flex items-center gap-3 px-5 py-4 bg-input rounded-md h-13 transition-all duration-200",
-        isFocused ? "border border-ring" : "border border-transparent",
-        containerClassName
-      ),
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx(SearchIcon, { className: "w-6 h-6 text-input-icon" }),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          input.Input,
-          {
-            placeholder,
-            className: utils.cn(
-              "w-full outline-none bg-transparent border-none ring-0 leading-0 p-0 h-6 text-base text-input-text placeholder:text-input-placeholder bg-none dark:bg-transparent focus-visible:ring-0 focus-visible:ring-offset-0",
-              className
-            ),
-            value,
-            onChange: (e) => onChange(e.target.value),
-            onFocus: () => setIsFocused(true),
-            onBlur: () => setIsFocused(false)
-          }
-        )
-      ]
-    }
-  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: utils.cn("rounded-xs relative"), children: [
+    /* @__PURE__ */ jsxRuntime.jsx(SearchIcon, { className: "w-6 h-6 absolute left-5 top-0 bottom-0 my-auto" }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      input.Input,
+      {
+        placeholder,
+        className: utils.cn(
+          "w-full outline-none px-5 py-4 relative z-10 pl-16 bg-input border-none rounded-xs ring-0 leading-0 h-13 text-base focus-visible:border focus-visible:border-ring",
+          className
+        ),
+        value,
+        onChange: (e) => onChange(e.target.value)
+      }
+    )
+  ] });
 };
 const ChainSelectModal = ({
   isOpen,
   onClose,
   items,
   allowedItems,
-  onChangeChain
+  onChangeChain,
+  isSource
 }) => {
   const { t } = useBridgeTranslation();
   const [query, setQuery] = react.useState("");
   const { setFromChain, chains, fromChain, toChain } = useChainsStore();
-  const { assetMatrix, selectedAssetSymbol } = useTokensStore();
+  const { assetMatrix, selectedAssetSymbol, setSelectedAssetSymbol } = useTokensStore();
+  console.log("allowedItems", allowedItems);
   const handleClose = react.useCallback(() => {
     setQuery("");
     onClose();
@@ -1822,40 +2504,84 @@ const ChainSelectModal = ({
     },
     [chains, selectedAssetSymbol, assetMatrix]
   );
+  const findCompatibleTokenAndSrcChain = react.useCallback(
+    (dstChain) => {
+      if (!chains || !assetMatrix) return void 0;
+      const PRIORITY_CHAINS = [
+        "ethereum",
+        "arbitrum",
+        "bsc",
+        "polygon",
+        "optimism",
+        "base"
+      ];
+      for (const tokenSymbol of Object.keys(assetMatrix)) {
+        const assetByChain = assetMatrix[tokenSymbol];
+        if (!assetByChain[dstChain.chainKey]) continue;
+        const availableChains = chains.filter(
+          (c) => assetByChain[c.chainKey] && c.chainKey !== dstChain.chainKey
+        );
+        if (availableChains.length === 0) continue;
+        let sourceChain;
+        for (const chainKey of PRIORITY_CHAINS) {
+          sourceChain = availableChains.find((c) => c.chainKey === chainKey);
+          if (sourceChain) break;
+        }
+        if (!sourceChain) sourceChain = availableChains[0];
+        return { tokenSymbol, sourceChain };
+      }
+      return void 0;
+    },
+    [chains, assetMatrix]
+  );
   const groupedChains = react.useMemo(() => {
     const q = query.trim().toLowerCase();
     const filtered = q ? (items ?? []).filter(
       (c) => c.name.toLowerCase().includes(q) || c.chainKey.toLowerCase().includes(q)
     ) : items ?? [];
-    const groups = { available: [], willChangeSrc: [] };
+    const groups = { available: [], willChangeSrc: [], willChangeTokenAndSrc: [] };
     for (const chain of filtered) {
       const isAllowed = allowedItems?.some((c) => c.chainKey === chain.chainKey) || false;
       if (isAllowed) {
         groups.available.push(chain);
       } else {
         const compatibleSrc = findCompatibleSrcChain(chain);
-        if (compatibleSrc) groups.willChangeSrc.push(chain);
+        if (compatibleSrc) {
+          groups.willChangeSrc.push(chain);
+        } else {
+          const compatibleTokenAndSrc = findCompatibleTokenAndSrcChain(chain);
+          if (compatibleTokenAndSrc) {
+            groups.willChangeTokenAndSrc.push(chain);
+          }
+        }
       }
     }
     groups.available.sort((a, b) => a.name.localeCompare(b.name));
     groups.willChangeSrc.sort((a, b) => a.name.localeCompare(b.name));
+    groups.willChangeTokenAndSrc.sort((a, b) => a.name.localeCompare(b.name));
     return groups;
-  }, [items, query, allowedItems, findCompatibleSrcChain]);
-  const onChainPick = (chain, willChangeSrc = false) => {
-    if (willChangeSrc) {
+  }, [items, query, allowedItems, findCompatibleSrcChain, findCompatibleTokenAndSrcChain]);
+  const onChainPick = (chain, willChangeSrc = false, willChangeTokenAndSrc = false) => {
+    if (willChangeTokenAndSrc) {
+      const result = findCompatibleTokenAndSrcChain(chain);
+      if (result) {
+        setSelectedAssetSymbol(result.tokenSymbol);
+        if (setFromChain) setFromChain(result.sourceChain);
+      }
+    } else if (willChangeSrc) {
       const newSrcChain = findCompatibleSrcChain(chain);
       if (newSrcChain && setFromChain) setFromChain(newSrcChain);
     }
     onChangeChain(chain);
     handleClose();
   };
-  const renderChainItem = (chain, willChangeSrc) => {
-    const isSelected = fromChain?.chainKey === chain.chainKey || toChain?.chainKey === chain.chainKey;
+  const renderChainItem = (chain, willChangeSrc, willChangeTokenAndSrc = false) => {
+    const isSelected = isSource ? fromChain?.chainKey === chain.chainKey : toChain?.chainKey === chain.chainKey;
     return /* @__PURE__ */ jsxRuntime.jsx(
       button.Button,
       {
-        onClick: () => onChainPick(chain, willChangeSrc),
-        className: `w-full cursor-pointer flex shadow-none rounded-sm items-center justify-between gap-3 px-5 py-4 h-13 font-semibold capitalize bg-transparent hover:scale-100 hover:bg-accent ${isSelected ? "border border-ring" : ""}`,
+        onClick: () => onChainPick(chain, willChangeSrc, willChangeTokenAndSrc),
+        className: `w-full cursor-pointer flex shadow-none rounded-xs items-center justify-between gap-3 px-5 py-4 h-13 font-semibold capitalize bg-transparent hover:scale-100 hover:bg-accent ${isSelected ? "border border-ring" : ""}`,
         children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
           /* @__PURE__ */ jsxRuntime.jsx(
             NetworkSymbol,
@@ -1871,7 +2597,7 @@ const ChainSelectModal = ({
       chain.chainKey
     );
   };
-  return /* @__PURE__ */ jsxRuntime.jsx(dialog.Dialog, { open: isOpen, onOpenChange: (open) => !open && handleClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(dialog.DialogContent, { className: "max-h-[90dvh] h-[90dvh] overflow-hidden flex flex-col", children: [
+  return /* @__PURE__ */ jsxRuntime.jsx(dialog.Dialog, { open: isOpen, onOpenChange: (open) => !open && handleClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(dialog.DialogContent, { className: "md:max-h-[90dvh] md:h-[90dvh] overflow-hidden flex flex-col", children: [
     /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogHeader, { className: "text-left", children: /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogTitle, { children: t("bridge.selectNetwork") }) }),
     /* @__PURE__ */ jsxRuntime.jsx(
       SearchInput,
@@ -1879,19 +2605,24 @@ const ChainSelectModal = ({
         placeholder: t("bridge.searchDestinationChain"),
         value: query,
         onChange: setQuery,
-        containerClassName: "rounded-md",
         className: "text-foreground placeholder:text-muted-foreground"
       }
     ),
     /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex-1 overflow-y-auto", children: [
       groupedChains.available.length > 0 && groupedChains.available.map((c) => renderChainItem(c, false)),
-      groupedChains.available.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mb-4", children: [
-        groupedChains.willChangeSrc.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "px-5 py-2 leading-4 text-base font-semibold text-muted-foreground uppercase", children: t("bridge.willChangeSourceChain") }),
-        groupedChains.willChangeSrc.length > 0 && groupedChains.willChangeSrc.map(
-          (c) => renderChainItem(c, true)
+      groupedChains.willChangeSrc.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: `px-5 py-2 leading-4 text-base font-semibold text-muted-foreground uppercase ${groupedChains.available.length > 0 ? "mt-10" : ""}`, children: t("bridge.willChangeSourceChain") }),
+        groupedChains.willChangeSrc.map(
+          (c) => renderChainItem(c, true, false)
         )
       ] }),
-      groupedChains.available.length === 0 && groupedChains.willChangeSrc.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-5 py-4 text-sm text-muted-foreground", children: t("bridge.noResults") })
+      groupedChains.willChangeTokenAndSrc.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("p", { className: `px-5 py-2 leading-4 text-base font-semibold text-muted-foreground uppercase ${groupedChains.available.length > 0 || groupedChains.willChangeSrc.length > 0 ? "mt-10" : ""}`, children: t("bridge.willChangeSourceNetworkAndToken") }),
+        groupedChains.willChangeTokenAndSrc.map(
+          (c) => renderChainItem(c, false, true)
+        )
+      ] }),
+      groupedChains.available.length === 0 && groupedChains.willChangeSrc.length === 0 && groupedChains.willChangeTokenAndSrc.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-5 py-4 text-sm text-muted-foreground", children: t("bridge.noResults") })
     ] })
   ] }) });
 };
@@ -1901,52 +2632,10 @@ const useWalletSelectModal = zustand.create((set) => ({
   onOpen: (addressType) => set({ isOpen: true, addressType }),
   onClose: () => set({ isOpen: false, addressType: void 0 })
 }));
-const truncateToDecimals = (num, decimals) => {
-  if (!isFinite(num) || isNaN(num)) return "0.00";
-  const multiplier = Math.pow(10, decimals);
-  const truncated = Math.floor(num * multiplier) / multiplier;
-  return truncated.toFixed(decimals);
-};
-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)}%`;
-};
-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 prefixIcons = {
   tronlink: /* @__PURE__ */ jsxRuntime.jsx(TronLinkIcon, { className: "w-5 h-5" }),
   metamask: /* @__PURE__ */ jsxRuntime.jsx(MetaMaskIcon, { className: "w-5 h-5" }),
-  ton: /* @__PURE__ */ jsxRuntime.jsx(TonKeeperIcon, { className: "w-5 h-5" })
+  ton: /* @__PURE__ */ jsxRuntime.jsx(TonConnectIcon, { className: "w-5 h-5" })
 };
 const mapWalletToType = (wallet) => {
   switch (wallet) {
@@ -1997,7 +2686,7 @@ const WalletInlineButton = ({
         disabled: isButtonDisabled,
         variant: "ghost",
         size: "sm",
-        className: "flex gap-1 cursor-pointer !px-0 pr-1 h-5",
+        className: "flex gap-1 cursor-pointer hover:opacity-60 hover:bg-transparent !px-0 pr-1 h-5",
         children: [
           /* @__PURE__ */ jsxRuntime.jsx("span", { children: isConnected ? prefixIcons[wallet] : null }),
           /* @__PURE__ */ jsxRuntime.jsx("span", { className: "leading-3 text-sm border-b border-dotted border-link text-link", children: buttonText })
@@ -2133,7 +2822,8 @@ const SwapSection = ({
         onClose,
         items: chains,
         allowedItems: allowedChains,
-        onChangeChain
+        onChangeChain,
+        isSource
       }
     )
   ] });
@@ -2187,7 +2877,6 @@ const AnotherAddress = () => {
       /* @__PURE__ */ jsxRuntime.jsx(
         _switch.Switch,
         {
-          className: "data-[state=unchecked]:bg-switch-inactive data-[state=checked]:bg-switch-active",
           "aria-pressed": enabled,
           checked: enabled,
           onClick: () => setEnabled((v) => !v)
@@ -2206,7 +2895,7 @@ const AnotherAddress = () => {
           "div",
           {
             className: utils.cn(
-              "bg-input py-2 px-4 mt-2 w-full flex items-center gap-4 rounded-md justify-between border border-transparent transition-all",
+              "bg-input px-4 py-2 pr-2 mt-4 w-full flex items-center gap-3 rounded-xs justify-between border border-transparent transition-all",
               {
                 "py-4": value,
                 "border border-ring": isFocused,
@@ -2216,13 +2905,13 @@ const AnotherAddress = () => {
             children: [
               /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-2 w-full", children: [
                 /* @__PURE__ */ jsxRuntime.jsx(
-                  input.Input,
+                  "textarea",
                   {
                     className: utils.cn(
-                      "p-0 h-auto text-base leading-5 font-semibold w-full bg-transparent dark:bg-transparent placeholder:text-muted-foreground/50 border-none focus:outline-none focus:ring-0"
+                      "h-auto text-base leading-5 font-semibold w-full bg-transparent dark:bg-transparent placeholder:text-muted-foreground/50 border-none focus:outline-none focus:ring-0 resize-none transition-all"
                     ),
                     placeholder: t("bridge.anotherAddressPlaceholder"),
-                    type: "text",
+                    rows: value.length >= 32 ? 2 : 1,
                     value,
                     onFocus: () => setIsFocused(true),
                     onBlur: () => setIsFocused(false),
@@ -2239,7 +2928,7 @@ const AnotherAddress = () => {
                 button.Button,
                 {
                   variant: "secondary",
-                  className: "bg-card text-card-foreground",
+                  className: "bg-accent text-card-foreground uppercase text-xs",
                   size: "sm",
                   onClick: onPaste,
                   children: t("common.paste")
@@ -2249,258 +2938,136 @@ const AnotherAddress = () => {
                 {
                   variant: "ghost",
                   size: "sm",
-                  className: "rounded-full p-0 w-5 h-5 self-start",
-                  onClick: () => setValue(""),
-                  children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, { className: "w-4 h-4" })
-                }
-              )
-            ]
-          }
-        )
-      },
-      "custom-address-block"
-    ) })
-  ] });
-};
-const TipIcon = (props) => {
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    "svg",
-    {
-      width: "16",
-      height: "16",
-      viewBox: "0 0 16 16",
-      fill: "none",
-      xmlns: "http://www.w3.org/2000/svg",
-      ...props,
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx("foreignObject", { x: "-4.4893", y: "-4.4893", width: "24.9786", height: "24.9786", children: /* @__PURE__ */ jsxRuntime.jsx(
-          "div",
-          {
-            style: {
-              backdropFilter: "blur(2.24px)",
-              WebkitBackdropFilter: "blur(2.24px)",
-              clipPath: "url(#bgblur_0_13066_11660_clip_path)",
-              height: "100%",
-              width: "100%"
-            }
-          }
-        ) }),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          "circle",
-          {
-            "data-figma-bg-blur-radius": "4.4893",
-            cx: "8",
-            cy: "8",
-            r: "8",
-            fill: "currentColor",
-            fillOpacity: "0.2"
-          }
-        ),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          "path",
-          {
-            d: "M6.57031 5.85386C6.57031 5.063 7.21143 4.42188 8.00229 4.42188C8.79316 4.42188 9.43428 5.063 9.43428 5.85386C9.43428 6.13893 9.35098 6.40455 9.20739 6.62769C8.77944 7.29276 8.00229 7.92696 8.00229 8.71782V9.07582M8.00229 11.3178V11.5818",
-            stroke: "currentColor",
-            strokeOpacity: "0.5",
-            strokeWidth: "1.68349",
-            strokeLinecap: "round"
-          }
-        ),
-        /* @__PURE__ */ jsxRuntime.jsx("defs", { children: /* @__PURE__ */ jsxRuntime.jsx(
-          "clipPath",
-          {
-            id: "bgblur_0_13066_11660_clip_path",
-            transform: "translate(4.4893 4.4893)",
-            children: /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "8", cy: "8", r: "8" })
-          }
-        ) })
-      ]
-    }
-  );
-};
-const Tip = (props) => {
-  const { children, text } = props;
-  return /* @__PURE__ */ jsxRuntime.jsxs(tooltip.Tooltip, { children: [
-    /* @__PURE__ */ jsxRuntime.jsx(tooltip.TooltipTrigger, { children }),
-    /* @__PURE__ */ jsxRuntime.jsx(tooltip.TooltipContent, { children: /* @__PURE__ */ jsxRuntime.jsx("p", { children: text }) })
-  ] });
-};
-const BASE_URL = "https://icons-ckg.pages.dev/stargate-light/tokens";
-const TokenSymbol = ({
-  symbol,
-  className = "w-4 h-4",
-  alt
-}) => {
-  const normalizedSymbol = normalizeTickerSymbol$1(symbol).toLowerCase();
-  const src = `${BASE_URL}/${normalizedSymbol}.svg`;
-  return /* @__PURE__ */ jsxRuntime.jsx("img", { src, alt: alt ?? symbol, className });
-};
-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
-};
-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 {
-      totalUsd: 0,
-      protocolFeeUsd: void 0,
-      messageFeeUsd: void 0,
-      serviceUsd: void 0,
-      blockchainUsd: void 0,
-      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.totalUsd > 0 && srcToken.price?.usd) {
-      const feeInSrcApprox = feeData.totalUsd / 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));
+                  className: "rounded-full p-0 w-5 h-5 self-start",
+                  onClick: () => setValue(""),
+                  children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.X, { className: "w-4 h-4" })
+                }
+              )
+            ]
+          }
+        )
+      },
+      "custom-address-block"
+    ) })
+  ] });
+};
+const InfoIcon = (props) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      width: "16",
+      height: "16",
+      viewBox: "0 0 16 16",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      ...props,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        "path",
+        {
+          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"
+        }
+      )
     }
-  }
-  return {
-    totalUsd: feeData.totalUsd,
-    protocolFeeUsd: feeData.protocolFeeUsd,
-    messageFeeUsd: feeData.messageFeeUsd,
-    serviceUsd: feeData.serviceUsd,
-    blockchainUsd: feeData.blockchainUsd,
-    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 addTonNetworkFee(quote, chains) {
-  if (!quote || quote.srcChainKey.toLowerCase() !== "ton") {
-    return quote;
-  }
-  const tonChain = chains?.find(
-    (c) => c.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: 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]
-  };
+};
+const Tip = (props) => {
+  const { children, text } = props;
+  return /* @__PURE__ */ jsxRuntime.jsxs(tooltip.Tooltip, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(tooltip.TooltipTrigger, { className: "w-4 h-4 rounded-full bg-muted text-muted-foreground", children }),
+    /* @__PURE__ */ jsxRuntime.jsx(tooltip.TooltipContent, { children: /* @__PURE__ */ jsxRuntime.jsx("p", { children: text }) })
+  ] });
+};
+const BASE_URL = "https://icons-ckg.pages.dev/stargate-light/tokens";
+const TokenSymbol = ({
+  symbol,
+  className = "w-4 h-4",
+  alt
+}) => {
+  const normalizedSymbol = normalizeTickerSymbol$1(symbol).toLowerCase();
+  const src = `${BASE_URL}/${normalizedSymbol}.svg`;
+  return /* @__PURE__ */ jsxRuntime.jsx("img", { src, alt: alt ?? symbol, className });
+};
+function getSimpleFallback(chainKey) {
+  const key = chainKey.toLowerCase();
+  if (key === "ton") return 0.15;
+  if (key === "tron") return 10;
+  return 0.01;
 }
-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 useGasEstimate(amountNum) {
+  const { fromChain } = useChainsStore();
+  const { selectedAssetSymbol } = useTokensStore();
+  const { srcAddress } = useAddresses();
+  const { balances, isLoading: balancesLoading } = useBalances(
+    fromChain?.chainKey,
+    srcAddress
+  );
+  const { quote } = useBridgeQuoteStore();
+  const balancesKnown = !balancesLoading;
+  const chainKey = fromChain?.chainKey;
+  const nativeCurrencySymbol = fromChain?.nativeCurrency?.symbol;
+  const nativeCurrencyAddress = fromChain?.nativeCurrency?.address;
+  const nativeCurrencyDecimals = fromChain?.nativeCurrency?.decimals;
+  const quoteFees = quote?.fees ? JSON.stringify(quote.fees) : null;
+  const quoteSrcChainKey = quote?.srcChainKey;
+  const nativeBalanceValue = nativeCurrencySymbol ? Number(balances[nativeCurrencySymbol.toUpperCase()]?.balance ?? 0) : 0;
+  const result = react.useMemo(() => {
+    if (!chainKey || !nativeCurrencySymbol) {
+      return {
+        nativeSym: "",
+        nativeBalance: 0,
+        requiredNative: 0,
+        balancesKnown,
+        isNativeSelected: false,
+        hasEnoughGas: true
+      };
+    }
+    const nativeSym = nativeCurrencySymbol.toUpperCase();
+    const nativeBalance = nativeBalanceValue;
+    const isNativeSelected = nativeSym === (selectedAssetSymbol || "").toUpperCase();
+    let requiredNative = 0;
+    if (quoteFees && quoteSrcChainKey === chainKey) {
+      const fees = JSON.parse(quoteFees);
+      const feesInNative = fees.filter(
+        (f) => f.chainKey === chainKey && f.token === nativeCurrencyAddress
+      ).reduce(
+        (sum, f) => sum + BigInt(f.amount || "0"),
+        0n
+      );
+      const decimals = nativeCurrencyDecimals || 18;
+      requiredNative = Number(feesInNative) / Math.pow(10, decimals);
+    } else {
+      requiredNative = getSimpleFallback(chainKey);
+    }
+    let hasEnoughGas = true;
+    if (isNativeSelected) {
+      hasEnoughGas = nativeBalance - (amountNum ?? 0) >= requiredNative;
+    } else {
+      hasEnoughGas = nativeBalance >= requiredNative;
+    }
+    return {
+      nativeSym,
+      nativeBalance,
+      requiredNative,
+      balancesKnown,
+      isNativeSelected,
+      hasEnoughGas: balancesKnown ? hasEnoughGas : true
+    };
+  }, [
+    chainKey,
+    nativeCurrencySymbol,
+    nativeCurrencyAddress,
+    nativeCurrencyDecimals,
+    selectedAssetSymbol,
+    quoteFees,
+    quoteSrcChainKey,
+    amountNum,
+    balancesKnown,
+    nativeBalanceValue
+  ]);
+  return result;
 }
 function getRouteDisplayName(route) {
   if (!route) return "Stargate Bridge";
@@ -2517,6 +3084,7 @@ const Details = () => {
   const { toChain, fromChain, chains } = useChainsStore();
   const { quote, status } = useBridgeQuoteStore();
   const { slippageBps, routePriority } = useSettingsStore();
+  const gas = useGasEstimate();
   const dstToken = resolveTokenOnChainFromMatrix$2(
     assetMatrix,
     selectedAssetSymbol,
@@ -2527,9 +3095,8 @@ const Details = () => {
     selectedAssetSymbol,
     fromChain?.chainKey
   );
-  const quoteWithFees = addTonNetworkFee(quote, chains);
   const quoteDetails = getQuoteDetails(
-    quoteWithFees || quote,
+    quote,
     srcToken,
     dstToken,
     tokens,
@@ -2540,21 +3107,7 @@ const Details = () => {
   const isLoading = status === "loading";
   const receiveText = quoteDetails.outputAmount != null ? Number(quoteDetails.outputAmount).toFixed(6) : "0.00";
   const etaText = quoteDetails.etaSeconds != null ? `≈ ${Math.max(1, Math.round(quoteDetails.etaSeconds / 60))}m` : "—";
-  const feeInSrc = quoteDetails.fees?.inSrcToken;
-  const feeInDst = quoteDetails.fees?.inDstToken;
-  const totalFeeUsd = quoteDetails.fees?.totalUsd;
-  const totalFeeDisplay = (() => {
-    if (feeInSrc != null && srcToken?.symbol) {
-      return `${Number(feeInSrc).toFixed(6)} ${srcToken.symbol.toUpperCase()}`;
-    }
-    if (feeInDst != null && dstToken?.symbol) {
-      return `${Number(feeInDst).toFixed(6)} ${dstToken.symbol.toUpperCase()}`;
-    }
-    if (totalFeeUsd != null) {
-      return formatUsd(totalFeeUsd);
-    }
-    return "—";
-  })();
+  const totalFeeDisplay = gas.requiredNative > 0 ? `${gas.requiredNative.toFixed(6)} ${gas.nativeSym}` : "—";
   const currentSlippageText = formatPercentage(slippageBps);
   const routeText = quote?.route ? getRouteDisplayName(quote.route) : t(`settings.routePresets.${routePriority}`);
   return /* @__PURE__ */ jsxRuntime.jsx(accordion.Accordion, { type: "single", collapsible: true, className: "w-full", children: /* @__PURE__ */ jsxRuntime.jsxs(accordion.AccordionItem, { value: "item-1", className: "bg-muted/50 rounded-sm", children: [
@@ -2574,7 +3127,7 @@ const Details = () => {
         DetailsRow,
         {
           label: t("transaction.route"),
-          value: /* @__PURE__ */ jsxRuntime.jsxs("strong", { className: "flex items-center font-semibold gap-2", children: [
+          value: /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "flex items-center gap-2", children: [
             /* @__PURE__ */ jsxRuntime.jsx(StargateIcon, { className: "w-4 h-4" }),
             /* @__PURE__ */ jsxRuntime.jsx("p", { className: "", children: routeText })
           ] })
@@ -2601,7 +3154,14 @@ const Details = () => {
           label: t("transaction.totalFee"),
           value: /* @__PURE__ */ jsxRuntime.jsxs("strong", { className: "inline-flex items-center gap-1", children: [
             /* @__PURE__ */ jsxRuntime.jsx("span", { children: totalFeeDisplay }),
-            /* @__PURE__ */ jsxRuntime.jsx(TokenSymbol, { symbol, className: "w-4 h-4", alt: "token" })
+            /* @__PURE__ */ jsxRuntime.jsx(
+              TokenSymbol,
+              {
+                symbol: gas.nativeSym,
+                className: "w-4 h-4",
+                alt: "token"
+              }
+            )
           ] }),
           isLoading
         }
@@ -2616,7 +3176,7 @@ const DetailsRow = ({
 }) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between items-center", children: [
   /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
     /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-priority font-normal", children: label }),
-    /* @__PURE__ */ jsxRuntime.jsx(Tip, { text: label, children: /* @__PURE__ */ jsxRuntime.jsx(TipIcon, { className: "w-4 h-4 text-receive-icon" }) })
+    /* @__PURE__ */ jsxRuntime.jsx(Tip, { text: label, children: /* @__PURE__ */ jsxRuntime.jsx(InfoIcon, {}) })
   ] }),
   isLoading ? /* @__PURE__ */ jsxRuntime.jsx(skeleton.Skeleton, { className: "h-4 w-16 rounded-md" }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-foreground text-sm", children: value ?? "—" })
 ] });
@@ -2669,6 +3229,20 @@ const useTransactionStore = zustand.create((set, get) => ({
     };
     set({ current: next });
   },
+  updateActualFee: (feeValue, feeSymbol) => {
+    const cur = get().current;
+    if (!cur) return;
+    const next = {
+      ...cur,
+      metadata: {
+        ...cur.metadata,
+        actualFeeValue: feeValue,
+        actualFeeSymbol: feeSymbol
+      },
+      updatedAt: Date.now()
+    };
+    set({ current: next });
+  },
   reset: () => {
     set({ current: void 0 });
   }
@@ -2814,9 +3388,13 @@ function isUserRejection(error) {
   if (error instanceof TransactionRejectedError) {
     return true;
   }
+  if (typeof error === "string") {
+    const message = error.toLowerCase();
+    return message.includes("rejected") || message.includes("denied") || message.includes("declined") || message.includes("not sent") || message.includes("user denied") || message.includes("user rejected") || message.includes("user reject") || message.includes("user cancelled") || message.includes("user canceled") || message.includes("action_rejected") || message.includes("ethers-user-denied") || message.includes("denied transaction") || message.includes("reject request") || message.includes("declined by user");
+  }
   if (error instanceof Error) {
     const message = error.message.toLowerCase();
-    return message.includes("rejected") || message.includes("denied") || message.includes("user denied") || message.includes("user rejected") || message.includes("user reject") || message.includes("user cancelled") || message.includes("user canceled") || message.includes("action_rejected") || message.includes("ethers-user-denied") || message.includes("denied transaction") || message.includes("reject request");
+    return message.includes("rejected") || message.includes("denied") || message.includes("declined") || message.includes("not sent") || message.includes("user denied") || message.includes("user rejected") || message.includes("user reject") || message.includes("user cancelled") || message.includes("user canceled") || message.includes("action_rejected") || message.includes("ethers-user-denied") || message.includes("denied transaction") || message.includes("reject request") || message.includes("declined by user");
   }
   return false;
 }
@@ -2835,17 +3413,13 @@ function toChainStrategyError(error, chainKey, context) {
       error
     );
   }
-  return new ChainStrategyError(
-    String(error),
-    "UNKNOWN_ERROR",
-    chainKey
-  );
+  return new ChainStrategyError(String(error), "UNKNOWN_ERROR", chainKey);
 }
 function useBridgeTransaction() {
   const { quote } = useBridgeQuoteStore();
   const { chainRegistry } = useChainStrategies();
   const { srcAddress, dstAddress } = useAddresses();
-  const { assetMatrix, tokens, selectedAssetSymbol } = useTokensStore();
+  const { assetMatrix, selectedAssetSymbol } = useTokensStore();
   const { chains } = useChainsStore();
   const txStore = useTransactionStore();
   const [isProcessing, setIsProcessing] = react.useState(false);
@@ -2874,31 +3448,33 @@ function useBridgeTransaction() {
     }
     const srcChain = chains?.find((c) => c.chainKey === quote.srcChainKey);
     const dstChain = chains?.find((c) => c.chainKey === quote.dstChainKey);
-    const quoteWithFees = addTonNetworkFee(quote, chains) || quote;
-    const amounts = getQuoteAmounts(quoteWithFees, srcToken, dstToken);
-    const fees = getQuoteFees(quoteWithFees, tokens, chains, srcToken, dstToken);
+    const amounts = getQuoteAmounts(quote, srcToken, dstToken);
     const metadata = {
       srcChainName: srcChain?.name || quote.srcChainKey,
       dstChainName: dstChain?.name || quote.dstChainKey,
       srcTokenSymbol: srcToken?.symbol || quote.srcToken,
       dstTokenSymbol: dstToken?.symbol || quote.dstToken,
       srcAmountHuman: amounts.inputHuman,
-      dstAmountHuman: amounts.outputHuman,
-      // TODO: IT'S NOT TRUE DAMN :)
-      totalFeeValue: fees.inSrcToken ?? fees.inDstToken ?? void 0,
-      totalFeeSymbol: fees.inSrcToken ? srcToken?.symbol : fees.inDstToken ? dstToken?.symbol : void 0
+      dstAmountHuman: amounts.outputHuman
+      // Actual fee will be updated when transaction completes
     };
     txStore.setTransaction(quote, "executing", metadata);
     setIsProcessing(true);
     try {
       const steps = quote.steps || [];
       if (steps.length === 0) {
-        throw new InvalidStepsError(quote.srcChainKey, "No transaction steps found in quote");
+        throw new InvalidStepsError(
+          quote.srcChainKey,
+          "No transaction steps found in quote"
+        );
       }
       const chainKey = steps[0].chainKey;
       const strategy = chainRegistry.getStrategy(chainKey);
       if (!strategy) {
-        throw new InvalidStepsError(chainKey, `No strategy available for chain: ${chainKey}`);
+        throw new InvalidStepsError(
+          chainKey,
+          `No strategy available for chain: ${chainKey}`
+        );
       }
       if (!strategy.isConnected()) {
         throw new WalletNotConnectedError(chainKey);
@@ -2910,7 +3486,6 @@ function useBridgeTransaction() {
         srcChainKey: quote.srcChainKey,
         dstChainKey: quote.dstChainKey
       };
-      console.log(steps);
       const txResult = await strategy.executeSteps(steps, context, (hash) => {
         txStore.setSrcHash(hash);
         txStore.updateStatus("processing");
@@ -2921,6 +3496,21 @@ function useBridgeTransaction() {
             if (result.dstTxHash) {
               txStore.setDstHash(result.dstTxHash);
             }
+            if (result.actualFeeValue) {
+              let feeSymbol = result.actualFeeSymbol;
+              if (!feeSymbol) {
+                const srcChain2 = chains?.find(
+                  (c) => c.chainKey === quote.srcChainKey
+                );
+                feeSymbol = srcChain2?.nativeCurrency?.symbol || "";
+              }
+              if (feeSymbol) {
+                const feeValue = parseFloat(result.actualFeeValue);
+                if (!isNaN(feeValue)) {
+                  txStore.updateActualFee(feeValue, feeSymbol);
+                }
+              }
+            }
             txStore.updateStatus("completed");
             console.log("Transaction completed successfully");
           } else {
@@ -2938,19 +3528,26 @@ function useBridgeTransaction() {
           console.error("Error tracking completion:", err);
         });
       } else {
-        throw new TransactionFailedError(chainKey, "Transaction hash not received from wallet");
+        throw new TransactionFailedError(
+          chainKey,
+          "Transaction hash not received from wallet"
+        );
       }
       return txResult;
     } catch (err) {
       if (isUserRejection(err)) {
         txStore.setError("TRANSACTION_REJECTED");
-        throw new TransactionFailedError(quote.srcChainKey, "Transaction rejected by user");
+        throw new TransactionFailedError(
+          quote.srcChainKey,
+          "Transaction rejected by user"
+        );
       }
       if (ChainStrategyError.isChainStrategyError(err)) {
         txStore.setError(err.code, { chainKey: err.chainKey });
         console.error("Chain strategy error:", err.toJSON());
         throw err;
       }
+      console.log(err);
       txStore.setError("UNKNOWN_ERROR");
       throw err;
     } finally {
@@ -2963,66 +3560,6 @@ function useBridgeTransaction() {
     hasQuote: !!quote
   };
 }
-function useGasEstimate(amountNum) {
-  const { fromChain } = useChainsStore();
-  const { selectedAssetSymbol, tokens } = useTokensStore();
-  const getSourceGasReserveHuman = useSettingsStore(
-    (state) => state.getSourceGasReserveHuman
-  );
-  const { srcAddress } = useAddresses();
-  const { balances, isLoading: balancesLoading } = useBalances(
-    fromChain?.chainKey,
-    srcAddress
-  );
-  const { chainRegistry } = useChainStrategies();
-  const balancesKnown = !balancesLoading;
-  const strategy = react.useMemo(() => {
-    if (!fromChain) return null;
-    return chainRegistry.getStrategy(fromChain.chainKey);
-  }, [fromChain, chainRegistry]);
-  const { data: gasRequirement } = reactQuery.useQuery({
-    queryKey: [
-      "gas-estimate",
-      fromChain?.chainKey,
-      selectedAssetSymbol,
-      amountNum,
-      balances
-    ],
-    queryFn: async () => {
-      if (!fromChain || !strategy) {
-        return null;
-      }
-      const selectedToken = tokens?.find(
-        (t) => t.symbol.toUpperCase() === selectedAssetSymbol?.toUpperCase()
-      ) || null;
-      const nativeTokenSymbol = fromChain.nativeCurrency?.symbol ?? "";
-      const nativeDecimals = fromChain.nativeCurrency?.decimals || 18;
-      const reserveFallback = getSourceGasReserveHuman(fromChain.chainKey);
-      const result = await strategy.estimateGasRequirement({
-        selectedToken,
-        nativeTokenSymbol,
-        amount: amountNum,
-        balances,
-        nativeDecimals,
-        reserveFallback
-      });
-      return result;
-    },
-    enabled: !!fromChain && !!strategy,
-    staleTime: 3e4,
-    gcTime: 5 * 6e4,
-    refetchOnWindowFocus: false,
-    retry: 1
-  });
-  return {
-    nativeSym: gasRequirement?.nativeSym || "",
-    nativeBalance: gasRequirement?.nativeBalance || 0,
-    requiredNative: gasRequirement?.requiredNative || 0,
-    balancesKnown,
-    isNativeSelected: gasRequirement?.isNativeSelected || false,
-    hasEnoughGas: balancesKnown ? gasRequirement?.hasEnoughGas ?? true : true
-  };
-}
 function useBalanceCheck(amountNum, gas) {
   const { fromChain } = useChainsStore();
   const { selectedAssetSymbol } = useTokensStore();
@@ -3353,8 +3890,8 @@ const WalletSelectModal = () => {
     {
       strategy: tonWallet,
       walletId: "ton",
-      name: t("wallets.tonKeeper"),
-      icon: TonKeeperIcon
+      name: t("wallets.tonconnect"),
+      icon: TonConnectIcon
     },
     {
       strategy: metaMaskWallet,
@@ -3392,8 +3929,8 @@ const WalletSelectModal = () => {
   const tonWallets = [
     {
       id: "ton",
-      name: t("wallets.tonKeeper"),
-      icon: TonKeeperIcon,
+      name: t("wallets.tonconnect"),
+      icon: TonConnectIcon,
       enabled: true
     }
   ];
@@ -3605,7 +4142,7 @@ const SuccessStep = ({
     /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-4 pt-10 px-8 flex-1 justify-start items-center text-center noise bg-background", children: [
       icon,
       /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogHeader, { children: /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogTitle, { children: t("transaction.success") }) }),
-      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "w-full space-y-3 mt-4 relative z-10 text-sm", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "w-full space-y-2 mt-4 relative z-10 pb-14", children: [
         metadata?.srcAmountHuman && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between items-center", children: [
           /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground", children: t("transaction.bridged") }),
           /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "inline-flex items-center gap-1 font-medium", children: [
@@ -3617,15 +4154,13 @@ const SuccessStep = ({
         ] }),
         /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between items-center", children: [
           /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground", children: t("transaction.transferTitle") }),
-          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "font-medium", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "font-medium space-x-1", children: [
             /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "inline-flex gap-1 items-center", children: [
               metadata?.srcChainName,
               " ",
               /* @__PURE__ */ jsxRuntime.jsx(NetworkSymbol, { chainKey: metadata.srcChainName })
             ] }),
-            " ",
-            "→",
-            " ",
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground", children: "→" }),
             /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "inline-flex gap-1 items-center", children: [
               metadata?.dstChainName,
               " ",
@@ -3639,17 +4174,17 @@ const SuccessStep = ({
             "button",
             {
               onClick: handleOpenExplorer,
-              className: "font-medium hover:underline cursor-pointer inline-flex items-center gap-1",
+              className: "font-medium cursor-pointer inline-flex items-center gap-1 underline hover:no-underline",
               children: formatHash(srcTxHash)
             }
           )
         ] }),
-        metadata?.totalFeeValue && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between items-center", children: [
+        metadata?.actualFeeValue && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between items-center", children: [
           /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground", children: t("transaction.finalFee") }),
           /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "font-medium", children: [
-            metadata.totalFeeValue,
+            metadata.actualFeeValue,
             " ",
-            metadata.totalFeeSymbol
+            metadata.actualFeeSymbol
           ] })
         ] })
       ] })
@@ -3746,7 +4281,7 @@ const useTokens = () => {
   return { ...query };
 };
 const useChains = () => {
-  const { setChains, setFromChain } = useChainsStore();
+  const { setChains, setFromChain, fromChain } = useChainsStore();
   const query = reactQuery.useQuery({
     queryKey: ["chains"],
     queryFn: () => getChains(),
@@ -3760,10 +4295,16 @@ const useChains = () => {
   });
   react.useEffect(() => {
     if (query.isSuccess && query.data?.length) {
+      console.log(
+        `[DEBUG] Loaded ${query.data.length} chains from API:`,
+        query.data.map((c) => c.chainKey)
+      );
       setChains(query.data);
-      setFromChain(query.data[0]);
+      if (!fromChain) {
+        setFromChain(query.data[0]);
+      }
     }
-  }, [query.isSuccess, query.data, setChains, setFromChain]);
+  }, [query.isSuccess, query.data]);
   react.useEffect(() => {
     if (query.isError && query.error) {
       console.error(query.error.name, query.error.message);
@@ -3921,7 +4462,9 @@ async function getEvmBalances(publicClient, address, tokens, priorityToken) {
         }
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        const isZeroDataError = errorMessage.includes('returned no data ("0x")');
+        const isZeroDataError = errorMessage.includes(
+          'returned no data ("0x")'
+        );
         if (!isZeroDataError) {
           console.debug(
             `Failed to get priority token balance for ${priorityToken.symbol}:`,
@@ -4032,12 +4575,9 @@ async function getTonBalances(address, tokens, customTonClient, tonApiKey) {
     }
     const client = getTonClient(customTonClient, tonApiKey);
     const accountAddress = ton.Address.parse(address);
-    console.log(address);
-    console.log(tokens);
     try {
       const balance = await client.getBalance(accountAddress);
       const tonBalance = Number(balance) / 1e9;
-      console.log("tonBalance", tonBalance);
       if (tonBalance > 0) {
         balances.TON = { balance: tonBalance, address: "ton-native" };
       }
@@ -4094,8 +4634,23 @@ async function getTronBalances(tronWeb, address, tokens) {
   try {
     if (!tronWeb) throw new Error("TronWeb not available");
     const ownerB58 = toTronBase58(address, tronWeb);
+    try {
+      const trxBalanceSun = await tronWeb.trx.getBalance(ownerB58);
+      const sunNum = Number(trxBalanceSun);
+      const trxVal = tronWeb.fromSun(sunNum);
+      const trxStr = typeof trxVal === "string" ? trxVal : trxVal.toString();
+      const trxBalance = parseFloat(trxStr);
+      if (trxBalance > 0) {
+        balances.TRX = { balance: trxBalance, address: ownerB58 };
+      }
+    } catch (error) {
+      console.warn("Failed to get native TRX balance:", error);
+    }
     for (const token of tokens) {
       try {
+        if (isNativeAddress(token.address) && token.symbol.toUpperCase() === "TRX") {
+          continue;
+        }
         let balance = 0;
         if (isNativeAddress(token.address)) {
           const trxBalanceSun = await tronWeb.trx.getBalance(ownerB58);
@@ -4182,6 +4737,9 @@ class EvmChainStrategy {
   getConnectLabel(t) {
     return t("wallets.connectEvmWallet");
   }
+  getClient() {
+    return this.provider;
+  }
   async getBalances(address, tokens, priorityToken) {
     if (!this.publicClient) {
       console.warn("No publicClient available for balance query");
@@ -4198,52 +4756,6 @@ class EvmChainStrategy {
     if (!address) return false;
     return /^0x[0-9a-fA-F]{40}$/.test(address);
   }
-  async estimateGasRequirement(params) {
-    const provider = this.provider;
-    const {
-      selectedToken,
-      nativeTokenSymbol,
-      amount,
-      balances,
-      nativeDecimals,
-      reserveFallback
-    } = params;
-    const nativeSym = nativeTokenSymbol.toUpperCase();
-    const isNativeSelected = nativeSym === (selectedToken?.symbol ?? "").toUpperCase();
-    const nativeBalance = Number(balances[nativeSym]?.balance ?? 0);
-    let estimatedGas = null;
-    if (provider) {
-      try {
-        const gasPriceHex = await provider.send("eth_gasPrice", []);
-        const gasPrice = BigInt(gasPriceHex);
-        const approveGas = isNativeSelected ? 0n : EVM_CONFIG.gasEstimates.approve;
-        const bridgeGas = EVM_CONFIG.gasEstimates.bridge;
-        const totalGas = approveGas + bridgeGas;
-        const bufferMultiplier = BigInt(Math.floor(EVM_CONFIG.gasBuffer * 100));
-        const requiredWei = gasPrice * totalGas * bufferMultiplier / 100n;
-        const { formatUnits } = await import("ethers");
-        estimatedGas = Number(formatUnits(requiredWei, nativeDecimals));
-      } catch {
-        estimatedGas = null;
-      }
-    }
-    const requiredNative = estimatedGas ?? reserveFallback;
-    const amountNum = amount ?? 0;
-    let hasEnoughGas = true;
-    if (isNativeSelected) {
-      hasEnoughGas = nativeBalance - amountNum >= requiredNative;
-    } else {
-      hasEnoughGas = nativeBalance >= requiredNative;
-    }
-    return {
-      estimatedGas,
-      nativeBalance,
-      requiredNative,
-      hasEnoughGas,
-      nativeSym,
-      isNativeSelected
-    };
-  }
   validateSteps(steps) {
     if (!steps || steps.length === 0) {
       throw new InvalidStepsError("evm", "No transaction steps provided");
@@ -4336,8 +4848,24 @@ class EvmChainStrategy {
       console.log(
         `EVM transaction confirmed in block ${receipt.blockNumber} with ${EVM_CONFIG.requiredConfirmations} confirmations`
       );
+      let actualFeeValue;
+      try {
+        const gasUsed = receipt.gasUsed;
+        const effectiveGasPrice = receipt.gasPrice;
+        if (gasUsed && effectiveGasPrice) {
+          const feeWei = gasUsed * effectiveGasPrice;
+          const { formatUnits } = await import("ethers");
+          const feeInNative = 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
+        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") {
@@ -4350,8 +4878,26 @@ class EvmChainStrategy {
             console.log(
               `Replacement transaction succeeded in block ${replacementReceipt.blockNumber}`
             );
+            let actualFeeValue;
+            try {
+              const receipt = error.receipt;
+              const gasUsed = receipt.gasUsed;
+              const effectiveGasPrice = receipt.gasPrice || receipt.effectiveGasPrice;
+              if (gasUsed && effectiveGasPrice) {
+                const feeWei = gasUsed * effectiveGasPrice;
+                const { formatUnits } = await import("ethers");
+                const feeInNative = 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
+              completed: true,
+              actualFeeValue
             };
           } else {
             const chainError2 = new TransactionRevertedError("evm", txHash);
@@ -4554,6 +5100,9 @@ class TonChainStrategy {
   getConnectLabel(t) {
     return t("wallets.connectTonWallet");
   }
+  getClient() {
+    return getTonClient(this.config.tonClient, this.config.tonApiKey);
+  }
   async getBalances(address, tokens) {
     return await getTonBalances(
       address,
@@ -4566,39 +5115,6 @@ class TonChainStrategy {
     if (!address) return false;
     return true;
   }
-  async estimateGasRequirement(params) {
-    const {
-      selectedToken,
-      nativeTokenSymbol,
-      amount,
-      balances,
-      nativeDecimals = 9,
-      reserveFallback
-    } = params;
-    const nativeSym = nativeTokenSymbol.toUpperCase();
-    const isNativeSelected = nativeSym === (selectedToken?.symbol ?? "").toUpperCase();
-    const nativeBalance = Number(balances[nativeSym]?.balance ?? 0);
-    const { formatUnits } = await import("ethers");
-    const estimatedGas = Number(
-      formatUnits(TON_CONFIG.estimatedNetworkFee, nativeDecimals)
-    );
-    const requiredNative = estimatedGas > 0 ? estimatedGas : reserveFallback;
-    const amountNum = amount ?? 0;
-    let hasEnoughGas = true;
-    if (isNativeSelected) {
-      hasEnoughGas = nativeBalance - amountNum >= requiredNative;
-    } else {
-      hasEnoughGas = nativeBalance >= requiredNative;
-    }
-    return {
-      estimatedGas,
-      nativeBalance,
-      requiredNative,
-      hasEnoughGas,
-      nativeSym,
-      isNativeSelected
-    };
-  }
   validateSteps(steps) {
     if (!steps || steps.length === 0) {
       throw new InvalidStepsError("ton", "No transaction steps provided");
@@ -4675,11 +5191,11 @@ class TonChainStrategy {
   }
   async waitForCompletion(txHash) {
     try {
-      const confirmed = await this.checkTonTransaction(
+      const result = await this.checkTonTransaction(
         txHash,
         TON_CONFIG.timeout
       );
-      if (!confirmed) {
+      if (!result.confirmed) {
         const error = new TransactionFailedError(
           "ton",
           "Transaction not confirmed on-chain",
@@ -4691,7 +5207,9 @@ class TonChainStrategy {
         };
       }
       return {
-        completed: true
+        completed: true,
+        actualFeeValue: result.fee,
+        actualFeeSymbol: "TON"
       };
     } catch (error) {
       const chainError = toChainStrategyError(
@@ -4734,7 +5252,7 @@ class TonChainStrategy {
             "Expected external-in message, got:",
             inMessage.info.type
           );
-          return false;
+          return { confirmed: false };
         }
         accountAddress = inMessage.info.dest;
         targetMessageHash = this.getNormalizedExtMessageHash(inMessage);
@@ -4742,7 +5260,7 @@ class TonChainStrategy {
         targetMessageHash = Buffer.from(hashOrBoc, "hex");
         if (!this.config.tonAddress) {
           console.debug("No wallet address available for hex hash lookup");
-          return false;
+          return { confirmed: false };
         }
         accountAddress = core.Address.parse(this.config.tonAddress);
       }
@@ -4769,7 +5287,13 @@ class TonChainStrategy {
               );
               if (txInMessageHash.equals(targetMessageHash)) {
                 console.debug("Transaction found by in-message hash");
-                return true;
+                const totalFees = tx.totalFees;
+                const feeInTon = Number(totalFees) / 1e9;
+                console.log(`TON transaction fee: ${feeInTon} TON`);
+                return {
+                  confirmed: true,
+                  fee: feeInTon.toString()
+                };
               }
             }
           }
@@ -4784,10 +5308,10 @@ class TonChainStrategy {
           hash = void 0;
         }
       }
-      return false;
+      return { confirmed: false };
     } catch (error) {
       console.debug("Error parsing BOC or checking transaction:", error);
-      return false;
+      return { confirmed: false };
     }
   }
 }
@@ -4841,7 +5365,7 @@ class TronChainStrategy {
     return t("wallets.connectTronWallet");
   }
   async getBalances(address, tokens) {
-    const tronWeb = this.getTronWeb();
+    const tronWeb = this.getClient();
     if (!tronWeb) return {};
     return await getTronBalances(tronWeb, address, tokens);
   }
@@ -4849,35 +5373,6 @@ class TronChainStrategy {
     if (!address) return false;
     return /^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(address);
   }
-  async estimateGasRequirement(params) {
-    const {
-      selectedToken,
-      nativeTokenSymbol,
-      amount,
-      balances,
-      reserveFallback
-    } = params;
-    const nativeSym = nativeTokenSymbol.toUpperCase();
-    const isNativeSelected = nativeSym === (selectedToken?.symbol ?? "").toUpperCase();
-    const nativeBalance = Number(balances[nativeSym]?.balance ?? 0);
-    const estimatedGas = null;
-    const requiredNative = reserveFallback;
-    const amountNum = amount ?? 0;
-    let hasEnoughGas = true;
-    if (isNativeSelected) {
-      hasEnoughGas = nativeBalance - amountNum >= requiredNative;
-    } else {
-      hasEnoughGas = nativeBalance >= requiredNative;
-    }
-    return {
-      estimatedGas,
-      nativeBalance,
-      requiredNative,
-      hasEnoughGas,
-      nativeSym,
-      isNativeSelected
-    };
-  }
   validateSteps(steps) {
     console.log("validateSteps");
     if (!steps?.length) {
@@ -4894,8 +5389,7 @@ class TronChainStrategy {
     }
   }
   async executeSteps(steps, _context, onFirstHash) {
-    console.log("executeSteps");
-    const tronWeb = this.getTronWeb();
+    const tronWeb = this.getClient();
     if (!tronWeb) {
       throw new ProviderNotAvailableError("tron");
     }
@@ -4989,7 +5483,7 @@ class TronChainStrategy {
   }
   async waitForCompletion(txHash) {
     try {
-      const tronWeb = this.getTronWeb();
+      const tronWeb = this.getClient();
       if (!tronWeb) {
         throw new ProviderNotAvailableError("tron");
       }
@@ -4998,6 +5492,7 @@ class TronChainStrategy {
       );
       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);
@@ -5032,7 +5527,9 @@ class TronChainStrategy {
               };
             }
             txBlockNumber = info.blockNumber;
-            console.log(`TRON transaction found in block ${txBlockNumber}`);
+            const feeSun = info.fee || 0;
+            actualFeeTrx = feeSun / 1e6;
+            console.log(`TRON transaction found in block ${txBlockNumber}, fee: ${actualFeeTrx} TRX`);
           }
         } catch (e) {
           console.debug("TRON getTransactionInfo error:", e);
@@ -5060,7 +5557,9 @@ class TronChainStrategy {
                 `TRON transaction confirmed in block ${txBlockNumber} with ${confirmations} confirmations`
               );
               return {
-                completed: true
+                completed: true,
+                actualFeeValue: actualFeeTrx?.toString(),
+                actualFeeSymbol: "TRX"
               };
             }
             console.log(
@@ -5089,7 +5588,7 @@ class TronChainStrategy {
       };
     }
   }
-  getTronWeb() {
+  getClient() {
     return typeof window !== "undefined" ? window.tronWeb : void 0;
   }
   /**
@@ -5406,7 +5905,7 @@ class TronChainStrategy {
    */
   async checkSolidified(txHash) {
     try {
-      const tronWeb = this.getTronWeb();
+      const tronWeb = this.getClient();
       if (!tronWeb) {
         return false;
       }
@@ -5552,7 +6051,7 @@ const SettingsModal = ({ isOpen, onClose }) => {
         /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between items-center", children: [
           /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
             /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-muted-foreground text-sm font-medium leading-4", children: t("settings.gasOnDestination") }),
-            /* @__PURE__ */ jsxRuntime.jsx(Tip, { text: t("settings.gasOnDestination"), children: /* @__PURE__ */ jsxRuntime.jsx(TipIcon, { className: "w-4 h-4 text-muted-foreground" }) })
+            /* @__PURE__ */ jsxRuntime.jsx(Tip, { text: t("settings.gasOnDestination"), children: /* @__PURE__ */ jsxRuntime.jsx(InfoIcon, { className: "w-4 h-4 text-muted-foreground" }) })
           ] }),
           /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-foreground text-sm font-medium leading-4", children: formatUsd(gasUsdValue) })
         ] }),
@@ -5590,7 +6089,7 @@ const SettingsModal = ({ isOpen, onClose }) => {
         /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between items-center", children: [
           /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
             /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-muted-foreground text-sm font-medium leading-4", children: t("settings.slippageTolerance") }),
-            /* @__PURE__ */ jsxRuntime.jsx(Tip, { text: t("settings.slippageTolerance"), children: /* @__PURE__ */ jsxRuntime.jsx(TipIcon, { className: "w-4 h-4 text-muted-foreground" }) })
+            /* @__PURE__ */ jsxRuntime.jsx(Tip, { text: t("settings.slippageTolerance"), children: /* @__PURE__ */ jsxRuntime.jsx(InfoIcon, { className: "w-4 h-4 text-muted-foreground" }) })
           ] }),
           slippageBps >= 500 && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-destructive text-xs font-medium", children: t("settings.highSlippageWarning", {
             defaultValue: "High slippage warning"
@@ -5620,7 +6119,7 @@ const SettingsModal = ({ isOpen, onClose }) => {
       /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-5", children: [
         /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex justify-between items-center", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
           /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-muted-foreground text-sm font-medium leading-4", children: t("settings.routePriority") }),
-          /* @__PURE__ */ jsxRuntime.jsx(Tip, { text: t("settings.routePriority"), children: /* @__PURE__ */ jsxRuntime.jsx(TipIcon, { className: "w-4 h-4 text-muted-foreground" }) })
+          /* @__PURE__ */ jsxRuntime.jsx(Tip, { text: t("settings.routePriority"), children: /* @__PURE__ */ jsxRuntime.jsx(InfoIcon, { className: "w-4 h-4 text-muted-foreground" }) })
         ] }) }),
         /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-end gap-2", children: routePresets.map((r) => /* @__PURE__ */ jsxRuntime.jsx(
           badge.Badge,
@@ -5653,7 +6152,7 @@ const TokenRow = ({
     button.Button,
     {
       onClick: onPick,
-      className: `w-full rounded-sm bg-transparent flex items-center justify-between gap-3 px-5 hover:bg-accent hover:scale-100 ${isSelected ? "border border-ring" : ""}`,
+      className: `w-full rounded-xs bg-transparent flex items-center justify-between gap-3 px-3 hover:bg-accent hover:scale-100 ${isSelected ? "bg-accent hover:bg-accent/50" : ""}`,
       children: [
         /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
           /* @__PURE__ */ jsxRuntime.jsx(
@@ -5674,7 +6173,7 @@ const TokenRow = ({
           /* @__PURE__ */ jsxRuntime.jsx(skeleton.Skeleton, { className: "h-3 w-12 rounded-md" })
         ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
           /* @__PURE__ */ jsxRuntime.jsx("div", { className: "font-semibold text-foreground text-lg leading-4 truncate", children: hasAnyWallet ? formatBalance(balance) : "—" }),
-          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs leading-3 text-muted-foreground", children: hasAnyWallet && balance > 0 && usdValue > 0 ? formatUsd(usdValue) : "—" })
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs leading-3 text-muted-foreground/50", children: hasAnyWallet && balance > 0 && usdValue > 0 ? formatUsd(usdValue) : "—" })
         ] }) })
       ]
     }
@@ -5817,7 +6316,7 @@ const TokenSelectModal = ({
     [groupedTokens.willChangeSrcChain]
   );
   const hasNoResults = tokensToRender.length === 0 && willChangeSrcTokens.length === 0;
-  return /* @__PURE__ */ jsxRuntime.jsx(dialog.Dialog, { open: isOpen, onOpenChange: (open) => !open && handleClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(dialog.DialogContent, { className: "max-h-[90dvh] h-[90dvh] overflow-hidden flex flex-col", children: [
+  return /* @__PURE__ */ jsxRuntime.jsx(dialog.Dialog, { open: isOpen, onOpenChange: (open) => !open && handleClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(dialog.DialogContent, { className: "md:max-h-[90dvh] md:h-[90dvh] overflow-hidden flex flex-col", children: [
     /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogHeader, { className: "text-left", children: /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogTitle, { children: t("bridge.selectToken") }) }),
     /* @__PURE__ */ jsxRuntime.jsx(
       SearchInput,
@@ -5831,24 +6330,26 @@ const TokenSelectModal = ({
       /* @__PURE__ */ jsxRuntime.jsx(
         button.Button,
         {
-          variant: tab === "my" ? "default" : "outline",
+          variant: tab === "my" ? "default" : "ghost",
           onClick: () => setTab("my"),
           size: "sm",
+          className: utils.cn(tab !== "my" && "bg-muted hover:bg-accent"),
           children: t("bridge.myTokens")
         }
       ),
       /* @__PURE__ */ jsxRuntime.jsx(
         button.Button,
         {
-          variant: tab === "all" ? "default" : "outline",
+          variant: tab === "all" ? "default" : "ghost",
           onClick: () => setTab("all"),
           size: "sm",
+          className: utils.cn(tab !== "all" && "bg-muted hover:bg-accent"),
           children: t("bridge.allTokens")
         }
       )
     ] }),
-    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 overflow-auto -mx-3", children: hasNoResults ? /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground px-5 py-4", children: t("bridge.noResults") }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-      effectiveTab === "my" && myTokens.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "leading-4 text-base font-semibold text-muted-foreground uppercase px-5 py-2", children: t("bridge.noBalancesFound") }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 overflow-auto px-1", children: hasNoResults ? /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground px-5 py-4", children: t("bridge.noResults") }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      effectiveTab === "my" && myTokens.length === 0 && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "leading-4 text-base font-semibold text-muted-foreground uppercase py-2", children: t("bridge.noBalancesFound") }),
       tokensToRender.map(({ token, willChangeSrc }) => {
         const bal = getBalance(token.symbol);
         const usd = getTokenUsdValue(token.symbol, token.price?.usd);
@@ -5899,6 +6400,7 @@ const TokenSelectModal = ({
 function useBridgeRefresh() {
   const qc = reactQuery.useQueryClient();
   const { srcAddress, dstAddress } = useAddresses();
+  const { fromChain, toChain } = useChainsStore();
   const { setLoading: setQLoading, triggerRefetch } = useBridgeQuoteStore();
   const { hasAnyWallet } = useConnectedWalletsStore();
   const [spinning, setSpinning] = react.useState(false);
@@ -5911,14 +6413,30 @@ function useBridgeRefresh() {
         qc.invalidateQueries({ queryKey: ["chains"] })
       ];
       if (hasAnyWallet()) {
-        if (srcAddress)
+        if (srcAddress) {
           queries.push(
             qc.invalidateQueries({ queryKey: ["srcTokens", srcAddress] })
           );
-        if (dstAddress)
+          if (fromChain?.chainKey) {
+            queries.push(
+              qc.invalidateQueries({
+                queryKey: ["balances", fromChain.chainKey, srcAddress]
+              })
+            );
+          }
+        }
+        if (dstAddress) {
           queries.push(
             qc.invalidateQueries({ queryKey: ["dstTokens", dstAddress] })
           );
+          if (toChain?.chainKey) {
+            queries.push(
+              qc.invalidateQueries({
+                queryKey: ["balances", toChain.chainKey, dstAddress]
+              })
+            );
+          }
+        }
       }
       await Promise.all(queries);
       triggerRefetch();
@@ -5929,6 +6447,8 @@ function useBridgeRefresh() {
     qc,
     srcAddress,
     dstAddress,
+    fromChain?.chainKey,
+    toChain?.chainKey,
     hasAnyWallet,
     setQLoading,
     triggerRefetch
@@ -5948,7 +6468,7 @@ const RefreshButton = () => {
       onClick: handleRefresh,
       disabled: spinning,
       variant: "secondary",
-      className: "bg-card text-card-foreground hover:text-card-foreground h-9",
+      className: "h-9 w-11",
       size: "sm",
       children: /* @__PURE__ */ jsxRuntime.jsx(
         ReloadIcon,
@@ -5976,7 +6496,7 @@ const SelectTokenButton = ({
       onClick,
       size: "sm",
       variant: "secondary",
-      className: "shrink-0 gap-2 bg-card text-card-foreground hover:text-card-foreground h-9",
+      className: "shrink-0 gap-2 h-9 !pl-2",
       type: "button",
       "aria-label": label,
       children: [
@@ -6024,7 +6544,7 @@ const Toolbar = () => {
         {
           onClick: onOpenSettings,
           size: "sm",
-          className: "bg-card text-card-foreground hover:text-card-foreground h-9",
+          className: "h-9 w-11",
           variant: "secondary",
           children: /* @__PURE__ */ jsxRuntime.jsx(BoltIcon, { stroke: "currentColor" })
         }
@@ -6304,11 +6824,16 @@ exports.DEFAULT_SLIPPAGE_BPS = DEFAULT_SLIPPAGE_BPS;
 exports.EvaaBridge = EvaaBridge;
 exports.RoutePriority = RoutePriority;
 exports.RouteType = RouteType;
+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;