@rash2x/bridge-widget 0.2.10 → 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");
@@ -45,15 +46,15 @@ const framerMotion = require("framer-motion");
 const accordion = require("@/components/ui/accordion");
 const tooltip = require("@/components/ui/tooltip");
 const sonner = require("sonner");
+const reactDialog = require("@radix-ui/react-dialog");
 const ethers = require("ethers");
 const viem = require("viem");
-const ton = require("@ton/ton");
 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 = { "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" } };
@@ -68,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 = { "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": "Рекомендуемый" } };
@@ -120,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",
@@ -221,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) {
@@ -230,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);
@@ -242,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) {
@@ -651,9 +872,398 @@ function isAddressValidForChain(chainKey, addr) {
   if (chainKey === "tron") return isTronAddress(addr);
   return isEvmAddress(addr);
 }
+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;
+}
+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 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 } = useChainsStore();
+  const { fromChain, toChain, chains } = useChainsStore();
   const { srcAddress, dstAddress } = useAddresses();
   const { slippageBps, routePriority, getDstNativeAmount, getSlippageDecimal } = useSettingsStore();
   const {
@@ -665,6 +1275,8 @@ function useBridgeQuote() {
     setNoRoute,
     resetWithIdle
   } = useBridgeQuoteStore();
+  const { chainRegistry } = useChainStrategies();
+  const publicClient = wagmi.usePublicClient();
   const input2 = inputAmount;
   const srcTokenOnFrom = react.useMemo(
     () => resolveTokenOnChainFromMatrix$2(
@@ -753,7 +1365,85 @@ function useBridgeQuote() {
           return;
         }
         if (cancelled) return;
-        setQuote(quoteRoute);
+        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();
@@ -779,7 +1469,10 @@ function useBridgeQuote() {
     setQError,
     slippageBps,
     routePriority,
-    refetchTrigger
+    refetchTrigger,
+    chainRegistry,
+    chains,
+    publicClient
   ]);
   return { loading };
 }
@@ -801,7 +1494,8 @@ async function getTokens() {
     throw new Error(`Failed to load chains: ${res.status}`);
   }
   const data = await res.json();
-  return Array.isArray(data) ? data : data.tokens ?? [];
+  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");
@@ -828,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;
@@ -858,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);
@@ -926,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]);
@@ -960,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();
@@ -1333,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"
             }
           )
         ] }),
@@ -1469,7 +2164,7 @@ const WalletConnectIcon = (props) => {
     }
   );
 };
-const TonKeeperIcon = (props) => {
+const TonConnectIcon = (props) => {
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "svg",
     {
@@ -1607,18 +2302,30 @@ const SwapButton = () => {
   ) });
 };
 const WalletBalance = (props) => {
-  const { value, isLoading = false } = props;
+  const { value, isLoading = false, showMax = false, onMaxClick } = props;
+  const { t } = useBridgeTranslation();
   const hasNoData = !value || value === "0" || value === "0.00" || value === "0.0";
   const shouldShowSkeleton = isLoading && hasNoData;
+  const shouldShowMaxButton = showMax && !hasNoData && !isLoading;
   if (shouldShowSkeleton) {
     return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2 items-center", children: [
       /* @__PURE__ */ jsxRuntime.jsx(WalletIcon, { className: "text-muted-foreground" }),
-      /* @__PURE__ */ jsxRuntime.jsx(skeleton.Skeleton, { className: "h-4 w-16 rounded-md" })
+      /* @__PURE__ */ jsxRuntime.jsx(skeleton.Skeleton, { className: "h-4 w-12 rounded-md" })
     ] });
   }
   return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2 items-center", children: [
     /* @__PURE__ */ jsxRuntime.jsx(WalletIcon, { className: "text-muted-foreground" }),
-    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm leading-5 font-medium text-muted-foreground", children: value })
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm leading-5 font-medium text-muted-foreground", children: value }),
+    shouldShowMaxButton && /* @__PURE__ */ jsxRuntime.jsx(
+      button.Button,
+      {
+        variant: "ghost",
+        size: "sm",
+        onClick: onMaxClick,
+        className: "h-auto p-0 px-0 text-xs font-medium border-b border-foreground rounded-none",
+        children: t("bridge.max")
+      }
+    )
   ] });
 };
 const BASE_URL$1 = "https://icons-ckg.pages.dev/stargate-light/networks";
@@ -1647,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: [
@@ -1738,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();
@@ -1809,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,
@@ -1858,27 +2597,32 @@ 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: [
-    /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogHeader, { children: /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogTitle, { children: t("bridge.selectNetwork") }) }),
+  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,
       {
         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") })
     ] })
   ] }) });
 };
@@ -1888,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) {
@@ -1984,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 })
@@ -2049,6 +2751,11 @@ const SwapSection = ({
     },
     [onSelect, onClose]
   );
+  const handleMaxClick = react.useCallback(() => {
+    if (balance.balance && onAmountChange) {
+      onAmountChange(balance.balance.toString());
+    }
+  }, [balance.balance, onAmountChange]);
   return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
     /* @__PURE__ */ jsxRuntime.jsxs(
       "div",
@@ -2065,7 +2772,9 @@ const SwapSection = ({
               WalletBalance,
               {
                 value: truncateToDecimals(balance.balance, 2),
-                isLoading: balance.isLoading
+                isLoading: balance.isLoading,
+                showMax: isSource,
+                onMaxClick: handleMaxClick
               }
             )
           ] }),
@@ -2113,7 +2822,8 @@ const SwapSection = ({
         onClose,
         items: chains,
         allowedItems: allowedChains,
-        onChangeChain
+        onChangeChain,
+        isSource
       }
     )
   ] });
@@ -2167,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)
@@ -2186,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,
@@ -2196,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),
@@ -2219,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")
@@ -2242,8 +2951,8 @@ const AnotherAddress = () => {
     ) })
   ] });
 };
-const TipIcon = (props) => {
-  return /* @__PURE__ */ jsxRuntime.jsxs(
+const InfoIcon = (props) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
     "svg",
     {
       width: "16",
@@ -2252,56 +2961,22 @@ const TipIcon = (props) => {
       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" })
-          }
-        ) })
-      ]
+      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"
+        }
+      )
     }
   );
 };
 const Tip = (props) => {
   const { children, text } = props;
   return /* @__PURE__ */ jsxRuntime.jsxs(tooltip.Tooltip, { children: [
-    /* @__PURE__ */ jsxRuntime.jsx(tooltip.TooltipTrigger, { 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 }) })
   ] });
 };
@@ -2315,97 +2990,84 @@ const TokenSymbol = ({
   const src = `${BASE_URL}/${normalizedSymbol}.svg`;
   return /* @__PURE__ */ jsxRuntime.jsx("img", { src, alt: alt ?? symbol, className });
 };
-function getQuoteAmounts(quote, srcToken, dstToken) {
-  if (!quote || !srcToken || !dstToken) {
-    return {
-      inputHuman: 0,
-      outputHuman: 0,
-      outputHumanRounded: "0",
-      minReceivedHuman: 0
-    };
-  }
-  const inputHuman = fromLD(quote.srcAmount, srcToken.decimals);
-  const outputHuman = fromLD(quote.dstAmount, dstToken.decimals);
-  const outputHumanRounded = truncateToDecimals(outputHuman, 2);
-  const minReceivedHuman = fromLD(
-    quote.dstAmountMin || "0",
-    dstToken.decimals
-  );
-  return {
-    inputHuman,
-    outputHuman,
-    outputHumanRounded,
-    minReceivedHuman
-  };
-}
-function getQuoteFees(quote, tokens, chains, srcToken, dstToken) {
-  if (!quote || !tokens || !chains) {
-    return {
-      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 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";
@@ -2422,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,
@@ -2444,24 +3107,10 @@ 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 rounded-sm", children: [
+  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: [
     /* @__PURE__ */ jsxRuntime.jsx(accordion.AccordionTrigger, { className: "w-full gap-1 items-center py-6 px-5 rounded-b-sm data-[state=open]:pb-3", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "w-full flex items-center justify-between", children: [
       /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm font-normal text-priority leading-4", children: t("bridge.youWillReceive", { defaultValue: "You will receive" }) }),
       /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "bg-transparent hover:bg-transparent shadow-none h-4 p-0 px-0 py-0 flex items-center gap-2", children: [
@@ -2478,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 })
           ] })
@@ -2505,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
         }
@@ -2520,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 ?? "—" })
 ] });
@@ -2573,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 });
   }
@@ -2718,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;
 }
@@ -2739,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);
@@ -2779,29 +3449,32 @@ function useBridgeTransaction() {
     const srcChain = chains?.find((c) => c.chainKey === quote.srcChainKey);
     const dstChain = chains?.find((c) => c.chainKey === quote.dstChainKey);
     const amounts = getQuoteAmounts(quote, srcToken, dstToken);
-    const fees = getQuoteFees(quote, tokens, chains, 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);
@@ -2813,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");
@@ -2824,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 {
@@ -2841,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 {
@@ -2866,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();
@@ -3178,6 +3812,7 @@ const WalletModalButton = (props) => {
   const { icon: IconComponent, name, onClose } = props;
   const { chainRegistry } = useChainStrategies();
   const { connect, isPending } = wagmi.useConnect();
+  const [isConnecting, setIsConnecting] = react.useState(false);
   if (props.variant === "connected") {
     const { address, onDisconnect } = props;
     return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "-mx-3", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: buttonBaseClasses, children: [
@@ -3201,6 +3836,7 @@ const WalletModalButton = (props) => {
   }
   const { walletId, connector } = props;
   const handleConnect = async () => {
+    setIsConnecting(true);
     try {
       if (connector) {
         connect({ connector });
@@ -3213,9 +3849,13 @@ const WalletModalButton = (props) => {
       onClose?.();
     } catch (error) {
       console.error("Failed to connect wallet:", error);
+      const errorMessage = error instanceof Error ? error.message : "Failed to connect wallet. Please try again.";
+      sonner.toast.error(errorMessage);
+    } finally {
+      setIsConnecting(false);
     }
   };
-  const isDisabled = connector ? isPending : false;
+  const isDisabled = connector ? isPending : isConnecting;
   return /* @__PURE__ */ jsxRuntime.jsxs(
     button.Button,
     {
@@ -3250,8 +3890,8 @@ const WalletSelectModal = () => {
     {
       strategy: tonWallet,
       walletId: "ton",
-      name: t("wallets.tonKeeper"),
-      icon: TonKeeperIcon
+      name: t("wallets.tonconnect"),
+      icon: TonConnectIcon
     },
     {
       strategy: metaMaskWallet,
@@ -3289,8 +3929,8 @@ const WalletSelectModal = () => {
   const tonWallets = [
     {
       id: "ton",
-      name: t("wallets.tonKeeper"),
-      icon: TonKeeperIcon,
+      name: t("wallets.tonconnect"),
+      icon: TonConnectIcon,
       enabled: true
     }
   ];
@@ -3326,7 +3966,7 @@ const WalletSelectModal = () => {
     }
   ].filter((category) => category.wallets.length > 0);
   return /* @__PURE__ */ jsxRuntime.jsx(dialog.Dialog, { open: isOpen, onOpenChange: (open) => !open && onClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(dialog.DialogContent, { children: [
-    /* @__PURE__ */ jsxRuntime.jsxs(dialog.DialogHeader, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(dialog.DialogHeader, { className: "text-left", children: [
       /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogTitle, { children: t("wallets.chooseWallet") }),
       /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogDescription, { children: t("wallets.oneWalletPerEnv") })
     ] }),
@@ -3369,7 +4009,7 @@ const WalletSelectModal = () => {
   ] }) });
 };
 const ProgressStep = ({
-  icon = /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "w-12 h-12 animate-spin" })
+  icon = /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "w-16 h-16 animate-spin" })
 }) => {
   const { t } = useBridgeTranslation();
   return /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogContent, { showCloseButton: false, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex relative flex-col gap-4 py-10 px-8 flex-1 items-center justify-start text-center noise bg-background", children: [
@@ -3379,40 +4019,130 @@ const ProgressStep = ({
   ] }) });
 };
 const FailedStep = ({
-  icon = /* @__PURE__ */ jsxRuntime.jsx(lucideReact.AlertCircleIcon, { className: "w-12 h-12" })
+  icon = /* @__PURE__ */ jsxRuntime.jsx(lucideReact.AlertCircleIcon, { className: "w-16 h-16" })
 }) => {
   const { current, reset } = useTransactionStore();
   const { t } = useBridgeTranslation();
   return /* @__PURE__ */ jsxRuntime.jsxs(dialog.DialogContent, { showCloseButton: false, children: [
-    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col relative gap-4 pt-10 px-8 flex-1 items-center justify-start text-center noise", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col relative gap-4 py-10 px-8 flex-1 items-center justify-start text-center noise", children: [
       icon,
-      /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogHeader, { children: /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogTitle, { children: t("transaction.failed") }) }),
-      current?.errorCode && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "w-full space-y-2 mt-6 relative z-10", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground", children: t(
-        `errors.${current.errorCode}`,
-        current.errorParams || {}
-      ) }) })
+      /* @__PURE__ */ jsxRuntime.jsxs(dialog.DialogHeader, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogTitle, { children: t("transaction.failed") }),
+        current?.errorCode && /* @__PURE__ */ jsxRuntime.jsx(reactDialog.DialogDescription, { children: t(
+          `errors.${current.errorCode}`,
+          current.errorParams || {}
+        ) })
+      ] })
     ] }),
-    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-col gap-3 pb-10 px-8", children: /* @__PURE__ */ jsxRuntime.jsx(button.Button, { variant: "outline", className: "w-full", onClick: reset, children: t("common.close") }) })
+    /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogFooter, { children: /* @__PURE__ */ jsxRuntime.jsx(button.Button, { variant: "outline", className: "w-full min-w-40", onClick: reset, children: t("common.close") }) })
   ] });
 };
+const EXPLORER_CONFIGS = {
+  // TON
+  ton: {
+    baseUrl: "https://tonscan.org",
+    txPath: "/tx/"
+  },
+  // TRON
+  tron: {
+    baseUrl: "https://tronscan.org",
+    txPath: "/#/transaction/"
+  },
+  // Ethereum & EVM chains
+  ethereum: {
+    baseUrl: "https://etherscan.io",
+    txPath: "/tx/"
+  },
+  eth: {
+    baseUrl: "https://etherscan.io",
+    txPath: "/tx/"
+  },
+  // BSC (Binance Smart Chain)
+  bsc: {
+    baseUrl: "https://bscscan.com",
+    txPath: "/tx/"
+  },
+  "binance-smart-chain": {
+    baseUrl: "https://bscscan.com",
+    txPath: "/tx/"
+  },
+  // Polygon
+  polygon: {
+    baseUrl: "https://polygonscan.com",
+    txPath: "/tx/"
+  },
+  matic: {
+    baseUrl: "https://polygonscan.com",
+    txPath: "/tx/"
+  },
+  // Avalanche
+  avalanche: {
+    baseUrl: "https://snowtrace.io",
+    txPath: "/tx/"
+  },
+  avax: {
+    baseUrl: "https://snowtrace.io",
+    txPath: "/tx/"
+  },
+  // Arbitrum
+  arbitrum: {
+    baseUrl: "https://arbiscan.io",
+    txPath: "/tx/"
+  },
+  // Optimism
+  optimism: {
+    baseUrl: "https://optimistic.etherscan.io",
+    txPath: "/tx/"
+  },
+  // Base
+  base: {
+    baseUrl: "https://basescan.org",
+    txPath: "/tx/"
+  },
+  // Fantom
+  fantom: {
+    baseUrl: "https://ftmscan.com",
+    txPath: "/tx/"
+  }
+};
+function getExplorerTxUrl(chainKey, txHash) {
+  if (!chainKey || !txHash) {
+    return null;
+  }
+  const normalizedChainKey = chainKey.toLowerCase();
+  const config = EXPLORER_CONFIGS[normalizedChainKey];
+  if (!config) {
+    console.warn(
+      `No explorer config found for chain: ${chainKey}. Please add it to EXPLORER_CONFIGS.`
+    );
+    return null;
+  }
+  return `${config.baseUrl}${config.txPath}${txHash}`;
+}
+function openTransactionInExplorer(chainKey, txHash) {
+  const url = getExplorerTxUrl(chainKey, txHash);
+  if (url && typeof window !== "undefined") {
+    window.open(url, "_blank", "noopener,noreferrer");
+  }
+}
 const SuccessStep = ({
-  icon = /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CheckCircle2, { className: "w-12 h-12" })
+  icon = /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CheckCircle2, { className: "w-16 h-16" })
 }) => {
   const { current, reset } = useTransactionStore();
   const { t } = useBridgeTranslation();
   const metadata = current?.metadata;
   const srcTxHash = current?.srcTxHash;
-  const handleCopyHash = () => {
-    if (srcTxHash) {
-      navigator.clipboard.writeText(srcTxHash);
-      sonner.toast.success(t("transaction.hashCopied"));
+  const srcChainKey = current?.quote?.srcChainKey;
+  const handleOpenExplorer = () => {
+    if (srcTxHash && srcChainKey) {
+      openTransactionInExplorer(srcChainKey, srcTxHash);
     }
   };
   return /* @__PURE__ */ jsxRuntime.jsxs(dialog.DialogContent, { showCloseButton: false, children: [
     /* @__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: [
@@ -3424,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,
               " ",
@@ -3445,18 +4173,18 @@ const SuccessStep = ({
           /* @__PURE__ */ jsxRuntime.jsx(
             "button",
             {
-              onClick: handleCopyHash,
-              className: "font-medium hover:underline cursor-pointer",
+              onClick: handleOpenExplorer,
+              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
           ] })
         ] })
       ] })
@@ -3482,7 +4210,7 @@ const useCountdown = (initialSeconds) => {
   };
 };
 const ConfirmStep = ({
-  icon = /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Clock, { className: "w-12 h-12" })
+  icon = /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Clock, { className: "w-16 h-16" })
 }) => {
   const { t } = useBridgeTranslation();
   const { formatTime } = useCountdown(90);
@@ -3553,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(),
@@ -3567,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);
@@ -3636,49 +4370,6 @@ class ChainStrategyRegistry {
     await strategy.disconnect();
   }
 }
-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
-};
-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 isNativeAddress(addr) {
   if (!addr) return false;
   const a = addr.toLowerCase();
@@ -3771,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}:`,
@@ -3882,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" };
       }
@@ -3944,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);
@@ -4032,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");
@@ -4048,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");
@@ -4186,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") {
@@ -4200,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);
@@ -4404,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,
@@ -4416,35 +5115,6 @@ class TonChainStrategy {
     if (!address) return false;
     return true;
   }
-  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) {
     if (!steps || steps.length === 0) {
       throw new InvalidStepsError("ton", "No transaction steps provided");
@@ -4497,23 +5167,35 @@ class TonChainStrategy {
       const result = await this.config.tonConnectUI.sendTransaction(
         transaction2
       );
-      const hash = result.boc;
-      onFirstHash?.(hash);
-      return {
-        chainKey: "ton",
-        hash
-      };
+      const bocBase64 = result.boc;
+      try {
+        const inMessage = core.loadMessage(core.Cell.fromBase64(bocBase64).beginParse());
+        const messageHash = this.getNormalizedExtMessageHash(inMessage);
+        const hexHash = messageHash.toString("hex");
+        onFirstHash?.(hexHash);
+        return {
+          chainKey: "ton",
+          hash: hexHash
+        };
+      } catch (error) {
+        console.error("Error parsing BOC to hex hash:", error);
+        onFirstHash?.(bocBase64);
+        return {
+          chainKey: "ton",
+          hash: bocBase64
+        };
+      }
     } catch (error) {
       throw toChainStrategyError(error, "ton", "transaction");
     }
   }
   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",
@@ -4525,7 +5207,9 @@ class TonChainStrategy {
         };
       }
       return {
-        completed: true
+        completed: true,
+        actualFeeValue: result.fee,
+        actualFeeSymbol: "TON"
       };
     } catch (error) {
       const chainError = toChainStrategyError(
@@ -4555,20 +5239,31 @@ class TonChainStrategy {
     };
     return core.beginCell().store(core.storeMessage(normalizedMessage, { forceRef: true })).endCell().hash();
   }
-  async checkTonTransaction(bocBase64, timeoutMs = 36e4) {
+  async checkTonTransaction(hashOrBoc, timeoutMs = 36e4) {
     const deadline = Date.now() + timeoutMs;
     const client = getTonClient(this.config.tonClient, this.config.tonApiKey);
     try {
-      const inMessage = core.loadMessage(core.Cell.fromBase64(bocBase64).beginParse());
-      if (inMessage.info.type !== "external-in") {
-        console.debug(
-          "Expected external-in message, got:",
-          inMessage.info.type
-        );
-        return false;
+      let targetMessageHash;
+      let accountAddress;
+      try {
+        const inMessage = core.loadMessage(core.Cell.fromBase64(hashOrBoc).beginParse());
+        if (inMessage.info.type !== "external-in") {
+          console.debug(
+            "Expected external-in message, got:",
+            inMessage.info.type
+          );
+          return { confirmed: false };
+        }
+        accountAddress = inMessage.info.dest;
+        targetMessageHash = this.getNormalizedExtMessageHash(inMessage);
+      } catch {
+        targetMessageHash = Buffer.from(hashOrBoc, "hex");
+        if (!this.config.tonAddress) {
+          console.debug("No wallet address available for hex hash lookup");
+          return { confirmed: false };
+        }
+        accountAddress = core.Address.parse(this.config.tonAddress);
       }
-      const accountAddress = inMessage.info.dest;
-      const targetMessageHash = this.getNormalizedExtMessageHash(inMessage);
       let lt = void 0;
       let hash = void 0;
       while (Date.now() < deadline) {
@@ -4580,7 +5275,7 @@ class TonChainStrategy {
             archival: true
           });
           if (transactions.length === 0) {
-            await new Promise((r) => setTimeout(r, 3e3));
+            await new Promise((r) => setTimeout(r, TON_CONFIG.pollingInterval));
             lt = void 0;
             hash = void 0;
             continue;
@@ -4592,24 +5287,31 @@ 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()
+                };
               }
             }
           }
           const lastTx = transactions[transactions.length - 1];
           lt = lastTx.lt.toString();
           hash = lastTx.hash().toString("base64");
+          await new Promise((r) => setTimeout(r, TON_CONFIG.pollingInterval));
         } catch (error) {
           console.debug("Error fetching transactions:", error);
-          await new Promise((r) => setTimeout(r, 3e3));
+          await new Promise((r) => setTimeout(r, TON_CONFIG.pollingInterval));
           lt = void 0;
           hash = void 0;
         }
       }
-      return false;
+      return { confirmed: false };
     } catch (error) {
       console.debug("Error parsing BOC or checking transaction:", error);
-      return false;
+      return { confirmed: false };
     }
   }
 }
@@ -4628,9 +5330,14 @@ class TronChainStrategy {
     return "TRON Chain Strategy";
   }
   async connect() {
-    const tronWeb = this.getTronWeb();
-    if (!tronWeb && (typeof window === "undefined" || !window.tronLink)) {
-      throw new WalletNotFoundError("tron", "TronLink");
+    if (!this.isTronLinkInstalled()) {
+      if (typeof window !== "undefined") {
+        window.open("https://www.tronlink.org/", "_blank");
+      }
+      throw new WalletNotFoundError(
+        "tron",
+        "TronLink wallet is not installed. Please install TronLink extension and try again."
+      );
     }
     this.config.tronSelect(tronwalletAdapters.TronLinkAdapterName);
     await new Promise((resolve) => setTimeout(resolve, 100));
@@ -4658,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);
   }
@@ -4666,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) {
@@ -4711,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");
     }
@@ -4806,7 +5483,7 @@ class TronChainStrategy {
   }
   async waitForCompletion(txHash) {
     try {
-      const tronWeb = this.getTronWeb();
+      const tronWeb = this.getClient();
       if (!tronWeb) {
         throw new ProviderNotAvailableError("tron");
       }
@@ -4815,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);
@@ -4849,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);
@@ -4877,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(
@@ -4906,9 +5588,26 @@ class TronChainStrategy {
       };
     }
   }
-  getTronWeb() {
+  getClient() {
     return typeof window !== "undefined" ? window.tronWeb : void 0;
   }
+  /**
+   * Check if TronLink wallet is actually installed
+   * This excludes Bybit Wallet which also injects tronLink for compatibility
+   */
+  isTronLinkInstalled() {
+    if (typeof window === "undefined") {
+      return false;
+    }
+    const hasBybitWallet = typeof window.bybitWallet !== "undefined" && typeof window.bybitWallet.tronLink !== "undefined";
+    if (hasBybitWallet && !window.tronLink) {
+      return false;
+    }
+    if (!window.tronLink) {
+      return false;
+    }
+    return true;
+  }
   hexToAscii(h) {
     if (!h) return null;
     const clean = h.replace(/^0x/, "");
@@ -5206,7 +5905,7 @@ class TronChainStrategy {
    */
   async checkSolidified(txHash) {
     try {
-      const tronWeb = this.getTronWeb();
+      const tronWeb = this.getClient();
       if (!tronWeb) {
         return false;
       }
@@ -5312,7 +6011,7 @@ const routePresets = [
   RoutePriority.CHEAPEST,
   RoutePriority.RECOMMENDED
 ];
-const SettingModal = ({ isOpen, onClose }) => {
+const SettingsModal = ({ isOpen, onClose }) => {
   const { t } = useBridgeTranslation();
   const { toChain } = useChainsStore();
   const { tokens } = useTokensStore();
@@ -5345,14 +6044,14 @@ const SettingModal = ({ isOpen, onClose }) => {
   );
   const activeBtn = "bg-primary hover:bg-primary/80 text-primary-foreground transition-colors";
   const notActiveBtn = "bg-accent hover:bg-accent/80 text-accent-foreground transition-colors";
-  return /* @__PURE__ */ jsxRuntime.jsx(dialog.Dialog, { open: isOpen, onOpenChange: (open) => !open && onClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(dialog.DialogContent, { children: [
-    /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogHeader, { children: /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogTitle, { children: t("settings.title") }) }),
+  return /* @__PURE__ */ jsxRuntime.jsx(dialog.Dialog, { open: isOpen, onOpenChange: (open) => !open && onClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(dialog.DialogContent, { onOpenAutoFocus: (e) => e.preventDefault(), children: [
+    /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogHeader, { className: "text-left", children: /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogTitle, { children: t("settings.title") }) }),
     /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-5", children: [
       /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-5", children: [
         /* @__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) })
         ] }),
@@ -5374,6 +6073,7 @@ const SettingModal = ({ isOpen, onClose }) => {
             badge.Badge,
             {
               onClick: () => setGasPreset(g),
+              size: "lg",
               className: utils.cn(
                 "cursor-pointer",
                 gasPreset === g ? activeBtn : notActiveBtn
@@ -5389,7 +6089,7 @@ const SettingModal = ({ 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"
@@ -5400,6 +6100,7 @@ const SettingModal = ({ isOpen, onClose }) => {
           /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center gap-2", children: slippagePresets.map((p) => /* @__PURE__ */ jsxRuntime.jsx(
             badge.Badge,
             {
+              size: "lg",
               onClick: () => {
                 const bps = parseFloat(p.replace("%", "")) * 100;
                 setSlippageBps(bps);
@@ -5418,11 +6119,12 @@ const SettingModal = ({ 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,
           {
+            size: "lg",
             onClick: () => setRoutePriority(r),
             className: utils.cn(
               "cursor-pointer",
@@ -5450,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(
@@ -5471,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) : "—" })
         ] }) })
       ]
     }
@@ -5614,8 +6316,8 @@ 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: [
-    /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogHeader, { children: /* @__PURE__ */ jsxRuntime.jsx(dialog.DialogTitle, { children: t("bridge.selectToken") }) }),
+  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,
       {
@@ -5628,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);
@@ -5696,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);
@@ -5708,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();
@@ -5726,6 +6447,8 @@ function useBridgeRefresh() {
     qc,
     srcAddress,
     dstAddress,
+    fromChain?.chainKey,
+    toChain?.chainKey,
     hasAnyWallet,
     setQLoading,
     triggerRefetch
@@ -5745,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,
@@ -5773,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: [
@@ -5821,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" })
         }
@@ -5839,7 +6562,7 @@ const Toolbar = () => {
         }
       }
     ),
-    /* @__PURE__ */ jsxRuntime.jsx(SettingModal, { isOpen: isOpenSettings, onClose: onCloseSettings })
+    /* @__PURE__ */ jsxRuntime.jsx(SettingsModal, { isOpen: isOpenSettings, onClose: onCloseSettings })
   ] });
 };
 const EvaaBridgeWithProviders = (props) => {
@@ -6101,10 +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;