@wheelx-widget/widget 0.1.11 → 0.1.12

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import * as React5 from 'react';
-import React5__default, { createContext, memo, useState, useMemo, useRef, useEffect, useContext, createElement, useCallback } from 'react';
-import { defineRecipe, chakra, Tooltip as Tooltip$1, Portal, VStack, Box, HStack, InputGroup, Input, Icon, Image, useBreakpointValue, Dialog, Spinner, Link, Button, Text, Popover, Collapsible, useDisclosure } from '@chakra-ui/react';
+import React5__default, { createContext, forwardRef, memo, useState, useMemo, useRef, useEffect, useContext, createElement, useCallback } from 'react';
+import { createToaster, defineRecipe, chakra, Tooltip as Tooltip$1, Portal, Box, Image, VStack, HStack, InputGroup, Input, Icon, useBreakpointValue, Dialog, Spinner, Link, Button, Text, Popover, Switch, Collapsible, useDisclosure } from '@chakra-ui/react';
 import { useQuery, QueryClient, QueryClientProvider, useMutation, keepPreviousData } from '@tanstack/react-query';
 import { useUserWallets, DynamicContextProvider, useRpcProviders, useDynamicContext, useTokenBalances, ChainEnum, useDynamicModals, useIsLoggedIn } from '@dynamic-labs/sdk-react-core';
 import { EthereumWalletConnectors } from '@dynamic-labs/ethereum';
@@ -8,17 +8,17 @@ import { SolanaWalletConnectorsWithConfig } from '@dynamic-labs/solana';
 import { DynamicWagmiConnector } from '@dynamic-labs/wagmi-connector';
 import { useAccount, WagmiProvider, useChainId, useConfig, useReconnect, createConfig, useDisconnect, useConnectors, useEstimateFeesPerGas, fallback, http as http$1, useWaitForTransactionReceipt, useSendTransaction } from 'wagmi';
 import { defineChain, zeroAddress, createPublicClient, http, parseUnits, erc20Abi, formatUnits, isAddress, hexToString, createClient, custom } from 'viem';
-import { mainnet, arbitrum, optimism, unichain, base as base$1, ink as ink$1, linea, soneium as soneium$1, bsc as bsc$1, worldchain, opBNB, mode, lisk, zksync, celo, polygon, avalanche, plumeMainnet, zora, sonic, berachain, bob, abstract, morph, taiko, scroll, hemi, xLayer, mantle, cronos, gravity, blast, manta, zircuit, xdc, sei, plume, gnosis, hashkey, flowMainnet, etherlink, ronin, flare, rootstock, iota, pulsechain, sepolia, arbitrumSepolia, optimismSepolia, baseSepolia, unichainSepolia, arcTestnet } from 'wagmi/chains';
+import { unichainSepolia, unichain, baseSepolia, base as base$1, optimismSepolia, optimism, arbitrumSepolia, arbitrum, sepolia, mainnet, polygon, bsc, avalanche, zksync, linea, scroll, mantle, blast, celo, gnosis, sonic, zora, mode, taiko, sei, xdc, ink, soneium as soneium$1, worldchain, opBNB, lisk, morph, bob, abstract, hemi, xLayer, cronos, gravity, manta, zircuit, berachain, plumeMainnet, plume, hashkey, flowMainnet, etherlink, ronin, flare, rootstock, iota, pulsechain, arcTestnet } from 'wagmi/chains';
 import { ThemeProvider } from '@emotion/react';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import axios6, { AxiosError } from 'axios';
 import { create } from 'zustand';
 import { Fraction, RoundingMode } from 'bi-fraction';
-import { base, soneium, ink, bsc } from 'viem/chains';
+import { base, soneium, ink as ink$1, bsc as bsc$1 } from 'viem/chains';
 import { PublicKey, VersionedTransaction, VersionedMessage, Transaction } from '@solana/web3.js';
 import { parseAccount, getAddress } from 'viem/utils';
 import { writeContract as writeContract$1, waitForTransactionReceipt as waitForTransactionReceipt$1, getTransaction, call, readContract as readContract$1 } from 'viem/actions';
-import { MdOutlineStarOutline, MdOutlineStarPurple500, MdFavoriteBorder, MdFavorite } from 'react-icons/md';
+import { MdOutlineStarOutline, MdOutlineStarPurple500, MdFavoriteBorder, MdFavorite, MdLocalGasStation } from 'react-icons/md';
 import { WalletIcon as WalletIcon$1 } from '@dynamic-labs/wallet-book';
 import { FiEdit } from 'react-icons/fi';
 import { IoAddCircleOutline, IoClose } from 'react-icons/io5';
@@ -45,7 +45,8 @@ var defaultTheme = {
   normalButtonBg: "#F5F6F8",
   normalButtonText: "#1A1D26",
   disabledButtonBg: "#E2E4E8",
-  disabledButtonText: "#A0A4AE"
+  disabledButtonText: "#A0A4AE",
+  getGasSwitchColorPalette: "purple"
 };
 var WidgetThemeContext = createContext({
   theme: defaultTheme
@@ -64,9 +65,15 @@ var WidgetThemeProvider = ({
 };
 
 // src/api/consts.ts
-var BASE_API_URL = "https://api.wheelx.fi";
+var _baseApiUrl = "https://api.wheelx.fi";
+function getBaseApiUrl() {
+  return _baseApiUrl;
+}
+function setBaseApiUrl(url) {
+  _baseApiUrl = url;
+}
 async function getChainsAndTokens() {
-  const url = `${BASE_API_URL}/v1/chain-info`;
+  const url = `${getBaseApiUrl()}/v1/chain-info`;
   const res = await axios6.get(url);
   return res.data;
 }
@@ -76,6 +83,7 @@ var useChainsAndTokens = (enabled = true) => {
     queryFn: () => getChainsAndTokens(),
     enabled,
     staleTime: 30 * 1e3,
+    // 30s：与 ISR 对齐，避免客户端立即重复请求
     refetchOnWindowFocus: false
   });
   return result;
@@ -160,10 +168,12 @@ var useWalletConnectedStore = create((set, get) => ({
   setEvmWalletInfo: (address, connectorId) => set({ evmWalletAddress: address, evmWalletConnectorId: connectorId }),
   isEvmWalletMetamask: false,
   setIsEvmWalletMetamask: (isEvmWalletMetamask) => set({ isEvmWalletMetamask }),
+  // Widget: logging-out guard
   isLoggingOut: false,
   setIsLoggingOut: (isLoggingOut) => set({ isLoggingOut }),
+  // Widget: disconnect timestamp for 2-second auto-reconnect guard
   lastDisconnectTimestamp: 0,
-  setLastDisconnectTimestamp: (ts) => set({ lastDisconnectTimestamp: ts })
+  setLastDisconnectTimestamp: (timestamp) => set({ lastDisconnectTimestamp: timestamp })
 }));
 
 // src/stores/useSyncWalletConnectedStore.ts
@@ -182,15 +192,16 @@ var useSyncWalletConnectedStore = () => {
     isLoggingOut,
     lastDisconnectTimestamp
   } = useWalletConnectedStore();
+  const guardRef = useRef({
+    isLoggingOut: false,
+    lastDisconnectTimestamp: 0
+  });
+  guardRef.current = { isLoggingOut, lastDisconnectTimestamp };
   useEffect(() => {
-    if (isLoggingOut) return;
-    const msSinceDisconnect = Date.now() - lastDisconnectTimestamp;
-    if (msSinceDisconnect < 2e3) {
-      const { isEthWalletConnected, isSolanaWalletConnected } = useWalletConnectedStore.getState();
-      const hasNoConnectedWallets = !isEthWalletConnected && !isSolanaWalletConnected;
-      if (hasNoConnectedWallets) {
-        return;
-      }
+    if (guardRef.current.isLoggingOut) return;
+    const msSinceDisconnect = Date.now() - guardRef.current.lastDisconnectTimestamp;
+    if (guardRef.current.lastDisconnectTimestamp > 0 && msSinceDisconnect < 2e3) {
+      return;
     }
     const solanaWallet = userWallets.find((wallet) => {
       const chain = String(
@@ -207,16 +218,10 @@ var useSyncWalletConnectedStore = () => {
       ).toLowerCase();
       return chain.includes("evm");
     });
-    const hasEverDisconnected = lastDisconnectTimestamp > 0;
-    let evmAddress = null;
-    if (hasEverDisconnected && !evmWallet) {
-      evmAddress = null;
-    } else {
-      evmAddress = evmWallet?.address ?? wagmiAddress ?? null;
-    }
+    const evmAddress = evmWallet?.address ?? wagmiAddress ?? null;
     const evmConnectorId = wagmiConnector?.id ?? getEvmConnectorId(evmWallet) ?? null;
     setEvmWalletInfo(evmAddress, evmConnectorId);
-    setIsEthWalletConnected(Boolean(evmAddress || isConnected && !hasEverDisconnected));
+    setIsEthWalletConnected(Boolean(evmAddress || isConnected));
   }, [
     userWallets,
     wagmiAddress,
@@ -248,79 +253,116 @@ var FavoritesContext = createContext({
   isLoading: true,
   walletAddress: void 0
 });
-var FavoritesProvider = ({ children }) => {
+var FavoritesProvider = ({
+  children
+}) => {
   const address = useEvmAddress();
+  const { isConnected } = useAccount();
   const [favorites, setFavorites] = useState([]);
   const [isLoading, setIsLoading] = useState(true);
-  const mountedRef = useRef(false);
   const getStorageKey = useCallback(() => {
     if (!address) return null;
     return `web3-favorites-${address.toLowerCase()}`;
   }, [address]);
   useEffect(() => {
-    mountedRef.current = true;
-    const id = requestAnimationFrame(() => {
-      if (!mountedRef.current) return;
+    const loadFavorites = async () => {
       if (!address) {
         setFavorites([]);
         setIsLoading(false);
         return;
       }
       try {
-        const k = getStorageKey();
-        if (!k) {
+        const storageKey = getStorageKey();
+        if (!storageKey) {
           setIsLoading(false);
           return;
         }
-        const s = localStorage.getItem(k);
-        if (s) setFavorites(JSON.parse(s));
-      } catch (_) {
+        const stored = localStorage.getItem(storageKey);
+        if (stored) {
+          const parsedFavorites = JSON.parse(stored);
+          setFavorites(parsedFavorites);
+        }
+      } catch (error) {
+        console.error("Failed to load favorites from localStorage:", error);
         setFavorites([]);
       } finally {
         setIsLoading(false);
       }
-    });
-    return () => {
-      mountedRef.current = false;
-      cancelAnimationFrame(id);
     };
+    loadFavorites();
   }, [address, getStorageKey]);
-  const save = (n) => {
+  const saveFavorites = (newFavorites) => {
     if (typeof window === "undefined") return;
-    const k = getStorageKey();
-    if (!k) return;
+    const storageKey = getStorageKey();
+    if (!storageKey) return;
     try {
-      localStorage.setItem(k, JSON.stringify(n));
-      setFavorites(n);
-    } catch (_) {
+      localStorage.setItem(storageKey, JSON.stringify(newFavorites));
+      setFavorites(newFavorites);
+    } catch (error) {
+      console.error("Failed to save favorites to localStorage:", error);
     }
   };
-  const addFavorite = (nId, nName = "Unknown Network") => {
-    if (!address) return;
-    if (!favorites.find((f) => f.networkId === nId))
-      save([...favorites, { networkId: nId, networkName: nName, timestamp: Date.now() }]);
+  const addFavorite = (networkId, networkName = "Unknown Network") => {
+    if (!isConnected || !address) {
+      console.warn("Cannot add favorite: No wallet connected");
+      return;
+    }
+    const existingIndex = favorites.findIndex(
+      (fav) => fav.networkId === networkId
+    );
+    if (existingIndex === -1) {
+      const newFavorite = {
+        networkId,
+        networkName,
+        timestamp: Date.now()
+      };
+      const updatedFavorites = [...favorites, newFavorite];
+      saveFavorites(updatedFavorites);
+    }
   };
-  const removeFavorite = (nId) => {
-    if (!address) return;
-    save(favorites.filter((f) => f.networkId !== nId));
+  const removeFavorite = (networkId) => {
+    if (!isConnected || !address) {
+      console.warn("Cannot remove favorite: No wallet connected");
+      return;
+    }
+    const updatedFavorites = favorites.filter(
+      (fav) => fav.networkId !== networkId
+    );
+    saveFavorites(updatedFavorites);
+  };
+  const isFavorite = (networkId) => {
+    return favorites.some((fav) => fav.networkId === networkId);
   };
-  const isFavorite = (nId) => favorites.some((f) => f.networkId === nId);
   const clearFavorites = () => {
-    if (!address) return;
-    const k = getStorageKey();
-    if (!k) return;
+    if (!isConnected || !address) return;
+    const storageKey = getStorageKey();
+    if (!storageKey) return;
     try {
-      localStorage.removeItem(k);
+      localStorage.removeItem(storageKey);
       setFavorites([]);
-    } catch (_) {
+    } catch (error) {
+      console.error("Failed to clear favorites:", error);
     }
   };
-  return /* @__PURE__ */ jsx(FavoritesContext.Provider, { value: { favorites, addFavorite, removeFavorite, isFavorite, clearFavorites, isLoading, walletAddress: address }, children });
+  const contextValue = {
+    favorites,
+    addFavorite,
+    removeFavorite,
+    isFavorite,
+    clearFavorites,
+    isLoading,
+    walletAddress: address
+  };
+  return /* @__PURE__ */ jsx(FavoritesContext.Provider, { value: contextValue, children });
 };
 var useFavoritesContext = () => {
-  const c = useContext(FavoritesContext);
-  if (c === void 0) throw new Error("useFavoritesContext must be used within a FavoritesProvider");
-  return c;
+  const context = useContext(FavoritesContext);
+  if (context === void 0) {
+    throw new Error(
+      "useFavoritesContext must be used within a FavoritesProvider"
+    );
+  }
+  return context;
 };
 
 // src/core/SelectTokenModal/storageUtils.ts
@@ -353,88 +395,229 @@ var TokenFavoritesContext = createContext({
   walletAddress: void 0,
   storageError: null
 });
-var TokenFavoritesProvider = ({ children }) => {
+var TokenFavoritesProvider = ({
+  children
+}) => {
   const address = useEvmAddress();
+  const { isConnected } = useAccount();
   const [favorites, setFavorites] = useState([]);
   const [isLoading, setIsLoading] = useState(true);
   const [storageError, setStorageError] = useState(null);
-  const mountedRef = useRef(false);
   const getStorageKey = useCallback(() => {
     if (!address) return null;
     return `web3-token-favorites-${address.toLowerCase()}`;
   }, [address]);
   useEffect(() => {
-    mountedRef.current = true;
-    const id = requestAnimationFrame(() => {
-      if (!mountedRef.current) return;
+    const loadFavorites = async () => {
       if (!address) {
         setFavorites([]);
         setIsLoading(false);
         return;
       }
       try {
-        const k = getStorageKey();
-        if (!k) {
+        const storageKey = getStorageKey();
+        if (!storageKey) {
           setIsLoading(false);
           return;
         }
-        const s = localStorage.getItem(k);
-        if (s) setFavorites(JSON.parse(s));
-      } catch (_) {
+        const stored = localStorage.getItem(storageKey);
+        if (stored) {
+          const parsedFavorites = JSON.parse(stored);
+          setFavorites(parsedFavorites);
+        }
+      } catch (error) {
+        console.error("Failed to load favorites from localStorage:", error);
         setFavorites([]);
       } finally {
         setIsLoading(false);
       }
-    });
-    return () => {
-      mountedRef.current = false;
-      cancelAnimationFrame(id);
     };
+    loadFavorites();
   }, [address, getStorageKey]);
-  const saveFavorites = (n) => {
+  const saveFavorites = (newFavorites) => {
     if (typeof window === "undefined") return;
     if (!isLocalStorageSupported()) {
-      setStorageError("no localStorage");
+      setStorageError("you browser can not using local storage");
       return;
     }
-    const k = getStorageKey();
-    if (!k) return;
+    const storageKey = getStorageKey();
+    if (!storageKey) return;
     try {
-      localStorage.setItem(k, JSON.stringify(n));
-      setFavorites(n);
-    } catch (_) {
+      localStorage.setItem(storageKey, JSON.stringify(newFavorites));
+      setFavorites(newFavorites);
+    } catch (error) {
+      console.error("Failed to save favorites to localStorage:", error);
     }
   };
-  const addFavorite = (ci, ta, s, d, l, n, tg) => {
-    if (!address) return;
-    if (!favorites.find((f) => f.chain_id === ci && f.address === ta))
-      saveFavorites([...favorites, { chain_id: ci, address: ta, symbol: s, decimals: d, logo: l, name: n, tags: tg, timestamp: Date.now() }]);
+  const addFavorite = (chainId, tokenAddress, symbol, decimals, logo, name, tags) => {
+    if (!isConnected || !address) {
+      console.warn("Cannot add favorite: No wallet connected");
+      return;
+    }
+    const existingIndex = favorites.findIndex(
+      (fav) => fav.chain_id === chainId && fav.address === tokenAddress
+    );
+    if (existingIndex === -1) {
+      const newFavorite = {
+        chain_id: chainId,
+        address: tokenAddress,
+        symbol,
+        decimals,
+        logo,
+        name,
+        tags,
+        timestamp: Date.now()
+      };
+      const updatedFavorites = [...favorites, newFavorite];
+      saveFavorites(updatedFavorites);
+    }
   };
-  const removeFavorite = (ci, ta) => {
-    if (!address) return;
-    setFavorites((p) => {
-      const u = p.filter((f) => !(f.chain_id === ci && f.address === ta));
-      saveFavorites(u);
-      return u;
+  const removeFavorite = (chainId, tokenAddress) => {
+    if (!isConnected || !address) {
+      console.warn("Cannot remove favorite: No wallet connected");
+      return;
+    }
+    setFavorites((prevFavorites) => {
+      const updatedFavorites = prevFavorites.filter(
+        (fav) => !(fav.chain_id === chainId && fav.address === tokenAddress)
+      );
+      saveFavorites(updatedFavorites);
+      return updatedFavorites;
     });
   };
-  const isFavorite = (ci, ta) => favorites.some((f) => f.chain_id === ci && f.address === ta);
+  const isFavorite = (chainId, tokenAddress) => {
+    return favorites.some(
+      (fav) => fav.chain_id === chainId && fav.address === tokenAddress
+    );
+  };
   const clearFavorites = () => {
-    if (!address) return;
-    const k = getStorageKey();
-    if (!k) return;
+    if (!isConnected || !address) return;
+    const storageKey = getStorageKey();
+    if (!storageKey) return;
     try {
-      localStorage.removeItem(k);
+      localStorage.removeItem(storageKey);
       setFavorites([]);
-    } catch (_) {
+    } catch (error) {
+      console.error("Failed to clear favorites:", error);
     }
   };
-  return /* @__PURE__ */ jsx(TokenFavoritesContext.Provider, { value: { favorites, addFavorite, removeFavorite, isFavorite, clearFavorites, isLoading, walletAddress: address, storageError }, children });
+  const contextValue = {
+    favorites,
+    addFavorite,
+    removeFavorite,
+    isFavorite,
+    clearFavorites,
+    isLoading,
+    storageError,
+    walletAddress: address
+  };
+  return /* @__PURE__ */ jsx(TokenFavoritesContext.Provider, { value: contextValue, children });
 };
 var useTokenFavoritesContext = () => {
-  const c = useContext(TokenFavoritesContext);
-  if (c === void 0) throw new Error("useTokenFavoritesContext must be used within TokenFavoritesProvider");
-  return c;
+  const context = useContext(TokenFavoritesContext);
+  if (context === void 0) {
+    throw new Error(
+      "useFavoritesContext must be used within a token FavoritesProvider"
+    );
+  }
+  return context;
+};
+
+// src/utils/platform.ts
+var isReactNativeWebView = () => {
+  if (typeof window === "undefined") return false;
+  return !!window.ReactNativeWebView;
+};
+var isWebView = () => {
+  if (typeof window === "undefined" || typeof navigator === "undefined") return false;
+  const ua = navigator.userAgent.toLowerCase();
+  if (ua.includes("wv") || ua.includes("android-webview")) return true;
+  if ((ua.includes("iphone") || ua.includes("ipad")) && !ua.includes("safari") && !ua.includes("crios"))
+    return true;
+  if (isReactNativeWebView()) return true;
+  return false;
+};
+var isMobileDevice = () => {
+  if (typeof navigator === "undefined" || typeof window === "undefined") return false;
+  const ua = navigator.userAgent.toLowerCase();
+  const isMobile = /android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini|mobile/i.test(ua);
+  const hasTouchScreen = "ontouchstart" in window || navigator.maxTouchPoints > 0;
+  return isMobile || hasTouchScreen && window.innerWidth < 1024;
+};
+var shouldInterceptDeepLinks = () => {
+  return isReactNativeWebView();
+};
+var isDeepLinkUrl = (url) => {
+  if (!url) return false;
+  const lower = url.toLowerCase();
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(url) && !lower.startsWith("http://") && !lower.startsWith("https://") && !lower.startsWith("about:") && !lower.startsWith("javascript:") && !lower.startsWith("data:") && !lower.startsWith("blob:") && !lower.startsWith("file:") || // WalletConnect v2: wc:<topic>@2?param=value (no "://")
+  lower.startsWith("wc:") || // Android intent:// URLs
+  lower.startsWith("intent://");
+};
+var KNOWN_WALLET_UNIVERSAL_LINKS = {
+  // MetaMask
+  "https://metamask.app.link/": "https://metamask.app.link/",
+  // Phantom — /ul/v1/* are encrypted session API endpoints that ONLY work
+  // with the https://phantom.app domain. Do NOT convert to phantom://.
+  // Both key and value are identical → convertToDeepLink() returns as-is.
+  "https://phantom.app/": "https://phantom.app/",
+  // Coinbase Wallet
+  "https://go.cb-w.com/": "https://go.cb-w.com/",
+  // Trust Wallet
+  "https://link.trustwallet.com/": "https://link.trustwallet.com/",
+  // Rainbow
+  "https://rnbwapp.com/": "https://rnbwapp.com/",
+  // OKX Wallet
+  "https://www.okx.com/": "https://www.okx.com/",
+  "https://okx.com/": "https://okx.com/",
+  // BitGet / BitKeep
+  "https://bitkeep.com/": "https://bitkeep.com/",
+  "https://bitget.com/": "https://bitget.com/",
+  // TokenPocket
+  "https://rn.tokenpocket.pro/": "https://rn.tokenpocket.pro/",
+  // SafePal
+  "https://safepal.io/": "https://safepal.io/",
+  // Zerion
+  "https://zerion.io/": "https://zerion.io/",
+  // Ledger Live
+  "https://ledger.live/": "https://ledger.live/"
+};
+var convertToDeepLink = (url) => {
+  if (!url) return url;
+  for (const [prefix, scheme] of Object.entries(KNOWN_WALLET_UNIVERSAL_LINKS)) {
+    if (url.toLowerCase().startsWith(prefix)) {
+      return url.slice(prefix.length) ? scheme + url.slice(prefix.length) : scheme;
+    }
+  }
+  return url;
+};
+var isWalletRelatedUrl = (url) => {
+  if (!url) return false;
+  if (isDeepLinkUrl(url)) return true;
+  const lower = url.toLowerCase();
+  return Object.keys(KNOWN_WALLET_UNIVERSAL_LINKS).some(
+    (prefix) => lower.startsWith(prefix)
+  );
+};
+var handleDeepLink = (url, handler) => {
+  if (handler) {
+    handler(url);
+    return;
+  }
+  const rnWebView = window.ReactNativeWebView;
+  if (rnWebView?.postMessage) {
+    rnWebView.postMessage(
+      JSON.stringify({
+        type: "WHEELX_DEEP_LINK",
+        url,
+        timestamp: Date.now()
+      })
+    );
+    console.log("[WheelX Widget] Sent deep link via ReactNativeWebView.postMessage:", url);
+    return;
+  }
+  window.dispatchEvent(new CustomEvent("wheelx:deepLink", { detail: { url } }));
+  console.log("[WheelX Widget] Dispatched wheelx:deepLink event:", url);
 };
 var tempo = defineChain({
   id: 4217,
@@ -467,10 +650,10 @@ var supportedChains = [
   optimism,
   unichain,
   base$1,
-  ink$1,
+  ink,
   linea,
   soneium$1,
-  bsc$1,
+  bsc,
   worldchain,
   opBNB,
   mode,
@@ -626,12 +809,95 @@ function LoadingSkeleton() {
     }
   );
 }
+function DeepLinkInterceptor({ config }) {
+  const interceptorInstalled = useRef(false);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    if (interceptorInstalled.current) return;
+    if (!shouldInterceptDeepLinks()) return;
+    interceptorInstalled.current = true;
+    const originalOpen = window.open.bind(window);
+    window.open = function(...args) {
+      const url = typeof args[0] === "string" ? args[0] : "";
+      if (url && isWalletRelatedUrl(url)) {
+        const deepLink = convertToDeepLink(url);
+        console.log("[WheelX Widget] Intercepted window.open deep link:", url, "\u2192", deepLink);
+        handleDeepLink(deepLink, config?.onDeepLink);
+        return null;
+      }
+      return originalOpen(...args);
+    };
+    let originalLocationHrefSetter = null;
+    try {
+      const proto = Object.getPrototypeOf(window.location);
+      const desc = Object.getOwnPropertyDescriptor(proto, "href");
+      if (desc?.set) {
+        originalLocationHrefSetter = desc.set.bind(window.location);
+        Object.defineProperty(window.location, "href", {
+          ...desc,
+          set(value) {
+            if (isWalletRelatedUrl(value)) {
+              const deepLink = convertToDeepLink(value);
+              console.log("[WheelX Widget] Intercepted location.href deep link:", value, "\u2192", deepLink);
+              handleDeepLink(deepLink, config?.onDeepLink);
+              return;
+            }
+            return originalLocationHrefSetter.call(window.location, value);
+          }
+        });
+        console.log("[WheelX Widget] location.href interceptor INSTALLED successfully");
+      } else {
+        console.warn("[WheelX Widget] location.href interceptor NOT installed: no setter descriptor found");
+      }
+    } catch (e) {
+      console.warn("[WheelX Widget] location.href interceptor FAILED:", String(e));
+    }
+    const handleClick = (e) => {
+      const target = e.target;
+      const anchor = target.closest("a");
+      if (!anchor) return;
+      const href = anchor.getAttribute("href") || "";
+      if (href && isWalletRelatedUrl(href)) {
+        e.preventDefault();
+        e.stopPropagation();
+        const deepLink = convertToDeepLink(href);
+        console.log("[WheelX Widget] Intercepted anchor click deep link:", href, "\u2192", deepLink);
+        handleDeepLink(deepLink, config?.onDeepLink);
+      }
+    };
+    const handleBeforeUnload = () => {
+      const currentHref = window.location.href;
+      if (isWalletRelatedUrl(currentHref)) {
+        console.log("[WheelX Widget] Detected deep link navigation in beforeunload:", currentHref);
+      }
+    };
+    document.addEventListener("click", handleClick, true);
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    console.log("[WheelX Widget] Deep link interceptor installed for WebView environment");
+    return () => {
+      document.removeEventListener("click", handleClick, true);
+      window.removeEventListener("beforeunload", handleBeforeUnload);
+      window.open = originalOpen;
+      if (originalLocationHrefSetter) {
+        try {
+          const proto = Object.getPrototypeOf(window.location);
+          const originalDesc = Object.getOwnPropertyDescriptor(proto, "href");
+          if (originalDesc) {
+            Object.defineProperty(window.location, "href", originalDesc);
+          }
+        } catch (_) {
+        }
+      }
+    };
+  }, []);
+  return null;
+}
 function ChainsAndTokensLoader({ children, config }) {
   const { data } = useChainsAndTokens(true);
   const { setChains, setSlippagePolicies } = useChainsStore();
   const { setTokens } = useTokensStore();
   const initialDataRef = React5__default.useRef(false);
-  const allChains = useMemo(() => {
+  const allChains2 = useMemo(() => {
     if (!data?.chains) return null;
     const l = [...data.chains];
     if (data.deposit_platforms?.prediction?.chains) l.push(...data.deposit_platforms.prediction.chains);
@@ -643,7 +909,7 @@ function ChainsAndTokensLoader({ children, config }) {
     if (data.deposit_platforms?.prediction?.tokens) l.push(...data.deposit_platforms.prediction.tokens);
     return l;
   }, [data]);
-  const filteredChains = allChains;
+  const filteredChains = allChains2;
   const filteredTokens = allTokens;
   React5__default.useEffect(() => {
     if (filteredChains && !initialDataRef.current) {
@@ -668,6 +934,9 @@ function ChainsAndTokensLoader({ children, config }) {
 var DEFAULT_ENVIRONMENT_ID = "f217660e-2cec-470b-a8f4-ac655b16f802";
 var solanaRpcUrl = "https://mainnet.helius-rpc.com/?api-key=7337bed2-6c3a-472f-b06f-9b2be0e1392f";
 var WheelXProvider = ({ config, children }) => {
+  if (config?.apiBaseUrl) {
+    setBaseApiUrl(config.apiBaseUrl);
+  }
   const queryClient = useMemo(() => new QueryClient(), []);
   const evmNetworks = useMemo(() => supportedChains.map((chain) => ({
     chainId: chain.id,
@@ -678,18 +947,46 @@ var WheelXProvider = ({ config, children }) => {
     blockExplorerUrls: chain.blockExplorers?.default?.url ? [chain.blockExplorers.default.url] : []
   })), []);
   const solanaConnectors = useMemo(() => SolanaWalletConnectorsWithConfig({ customRpcUrls: { solana: [solanaRpcUrl] } }), []);
-  const dynamicSettings = useMemo(() => ({
-    environmentId: config?.dynamicEnvironmentId || DEFAULT_ENVIRONMENT_ID,
-    walletConnectors: [EthereumWalletConnectors, solanaConnectors],
-    enableConnectOnlyFallback: false,
-    initialAuthenticationMode: "connect-only",
-    mobileExperience: "redirect",
-    deepLinkPreference: "universal",
-    defaultNumberOfWalletsToShow: 25,
-    overrides: { evmNetworks }
-  }), [evmNetworks, solanaConnectors, config?.dynamicEnvironmentId]);
+  const dynamicSettings = useMemo(() => {
+    const isRN = isReactNativeWebView();
+    return {
+      environmentId: config?.dynamicEnvironmentId || DEFAULT_ENVIRONMENT_ID,
+      walletConnectors: [EthereumWalletConnectors, solanaConnectors],
+      enableConnectOnlyFallback: false,
+      initialAuthenticationMode: "connect-only",
+      // ── mobileExperience ──────────────────────────────────────
+      // H5 / DApp browser: use simple global string (original behavior).
+      //   The browser natively handles https:// universal links to open
+      //   wallet apps — no interception needed.
+      //
+      // React Native WebView: use per-wallet object config so each wallet
+      //   explicitly uses 'redirect' mode, forcing the SDK to generate deep
+      //   link URLs that our DeepLinkInterceptor can catch and forward.
+      ...isRN ? {
+        mobileExperience: {
+          okx: "redirect",
+          phantom: "redirect",
+          metamask: "redirect",
+          default: "redirect"
+        }
+      } : {
+        mobileExperience: "redirect"
+      },
+      // In React Native WebView, use 'native' so Dynamic SDK generates
+      // phantom://, metamask:// etc. — these custom schemes route directly
+      // to the wallet app via Linking.openURL(), avoiding the browser.
+      // In H5 / DApp, use 'universal' so the browser handles the https://
+      // universal links normally.
+      deepLinkPreference: isRN ? "native" : "universal",
+      defaultNumberOfWalletsToShow: 25,
+      overrides: { evmNetworks }
+    };
+  }, [evmNetworks, solanaConnectors, config?.dynamicEnvironmentId]);
   const wagmiConfig = useMemo(() => getWagmiConfig(), []);
-  return /* @__PURE__ */ jsx(WidgetThemeProvider, { theme: config?.theme, children: /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx(DynamicContextProvider, { settings: dynamicSettings, children: /* @__PURE__ */ jsx(WagmiProvider, { config: wagmiConfig, children: /* @__PURE__ */ jsx(DynamicWagmiConnector, { children: /* @__PURE__ */ jsx(ChainsAndTokensLoader, { config, children }) }) }) }) }) });
+  return /* @__PURE__ */ jsx(WidgetThemeProvider, { theme: config?.theme, children: /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx(DynamicContextProvider, { settings: dynamicSettings, children: /* @__PURE__ */ jsx(WagmiProvider, { config: wagmiConfig, children: /* @__PURE__ */ jsxs(DynamicWagmiConnector, { children: [
+    /* @__PURE__ */ jsx(DeepLinkInterceptor, { config }),
+    /* @__PURE__ */ jsx(ChainsAndTokensLoader, { config, children })
+  ] }) }) }) }) });
 };
 var createQuoteMutationError = (message, extra) => {
   const quoteError = new Error(message);
@@ -716,7 +1013,7 @@ var useGetQuote = (signal) => useMutation({
   mutationFn: async (requestBody) => {
     try {
       const res = await axios6.post(
-        `${BASE_API_URL}/v1/quote`,
+        `${getBaseApiUrl()}/v1/quote`,
         {
           ...requestBody,
           quote_only: true
@@ -779,7 +1076,7 @@ var useGetQuote = (signal) => useMutation({
   }
 });
 async function getTokenInfo(value, chainId) {
-  const url = `${BASE_API_URL}/v1/token-info`;
+  const url = `${getBaseApiUrl()}/v1/token-info`;
   const res = await axios6.get(url, {
     params: {
       address: value,
@@ -796,12 +1093,13 @@ var useTokenInfo = ({
   const result = useQuery({
     queryKey: ["tokenInfo", value, chainId],
     queryFn: () => getTokenInfo(value, chainId),
+    // enabled: !!value && isAddress(value)
     enabled: !!value && !!chainId
   });
   return result;
 };
 async function getUsdPrice(tokens) {
-  const url = `${BASE_API_URL}/v1/token-price`;
+  const url = `${getBaseApiUrl()}/v1/token-price`;
   const res = await axios6.post(url, tokens);
   return res.data;
 }
@@ -815,15 +1113,25 @@ var useUsdPrice = (tokens) => {
   });
 };
 var getHyperliquidBalance = async (address) => {
+  const newUrl = `https://api.hyperliquid.xyz/info`;
   try {
-    const response = await fetch("https://api.hyperliquid.xyz/info", {
+    const response = await fetch(`${newUrl}`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ type: "clearinghouseState", user: address })
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        type: "clearinghouseState",
+        user: address
+      })
     });
     return await response.json();
   } catch (error) {
-    return { code: 1, message: error, withdrawable: null };
+    return {
+      code: 1,
+      message: error,
+      withdrawable: null
+    };
   }
 };
 var useHyperliquidBalance = (address, enabled) => {
@@ -843,7 +1151,7 @@ var useHyperliquidBalance = (address, enabled) => {
 };
 async function getOrderDetail(orderId) {
   const res = await axios6.get(
-    `${BASE_API_URL}/v1/order/${orderId}`
+    `${getBaseApiUrl()}/v1/order/${orderId}`
   );
   return res.data;
 }
@@ -866,6 +1174,7 @@ var useIntervalGetOrderDetailPlus = ({
     },
     refetchOnMount: false,
     retry: false,
+    // Disable React Query's built-in retries; rely on refetchInterval for continuous polling
     enabled: queryEnabled
   });
   useEffect(() => {
@@ -891,14 +1200,22 @@ var useIntervalGetOrderDetailPlus = ({
   };
 };
 async function getTokenBalance(address) {
-  const url = `${BASE_API_URL}/v1/token-balances`;
-  const res = await axios6.get(url, { params: { address } });
+  const url = `${getBaseApiUrl()}/v1/token-balances`;
+  const res = await axios6.get(url, {
+    params: {
+      address
+    }
+  });
   return res.data;
 }
 async function getSolanaTokenBalance(address) {
   if (!address) return [];
-  const url = `${BASE_API_URL}/v1/token-balances`;
-  const res = await axios6.get(url, { params: { address } });
+  const url = `${getBaseApiUrl()}/v1/token-balances`;
+  const res = await axios6.get(url, {
+    params: {
+      address
+    }
+  });
   return res.data;
 }
 async function getAllTokenBalances(evmAddress, solanaAddress) {
@@ -909,11 +1226,12 @@ async function getAllTokenBalances(evmAddress, solanaAddress) {
   return [...evmBalances || [], ...solanaBalances || []];
 }
 var useAllTokenBalance = (evmAddress, solanaAddress) => {
-  return useQuery({
+  const result = useQuery({
     queryKey: ["allTokenBalance", evmAddress, solanaAddress],
     queryFn: () => getAllTokenBalances(evmAddress, solanaAddress),
     enabled: !!evmAddress || !!solanaAddress
   });
+  return result;
 };
 var useDifferentAddressStore = create((set) => ({
   differentAddress: void 0,
@@ -921,6 +1239,10 @@ var useDifferentAddressStore = create((set) => ({
   isDepositPlatformToken: false,
   setIsDepositPlatformToken: (isDepositPlatformToken) => set({ isDepositPlatformToken })
 }));
+var useGetGasStore = create((set) => ({
+  sponsorGas: false,
+  setSponsorGas: (sponsorGas) => set({ sponsorGas })
+}));
 var useWalletConnectModal = () => {
   const { setShowAuthFlow } = useDynamicContext();
   const { setShowLinkNewWalletModal } = useDynamicModals();
@@ -1034,6 +1356,7 @@ var Store = class {
   setStorageData(data) {
     setLocalStorage(this.key, JSON.stringify(data));
   }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   get(label) {
     const data = this.getStorageData();
     return data[label] || null;
@@ -1153,7 +1476,7 @@ var logger = {
   error: errorWithTimestamp,
   debug: debugWithTimestamp
 };
-var wagmiSupportedChains = [mainnet, base$1, soneium$1, polygon, arbitrum, optimism, bsc$1];
+var wagmiSupportedChains = [mainnet, base$1, soneium$1, polygon, arbitrum, optimism, bsc];
 var getTxLink = (txHash, chainId) => {
   if (isSolanaChain(chainId)) {
     return `${SOLANA_MAINNET.explorerUrl}/tx/${txHash}`;
@@ -1173,35 +1496,28 @@ var openFunctionHash = "0x3448bbc2203c608599ad448eeb1007cea04b788ac631f9f558e8dd
 function isApproveValid(approve) {
   return approve != null && typeof approve === "object" && Object.keys(approve).length > 0 && approve.amount !== void 0 && approve.spender !== void 0 && approve.token !== void 0;
 }
-
-// src/core/ui/toaster.tsx
-var createToastStub = () => ({
-  success: (_opts) => {
-  },
-  error: (_opts) => {
-  },
-  warning: (_opts) => {
-  },
-  info: (_opts) => {
-  },
-  loading: (_opts) => {
-  },
-  create: (_opts) => "",
-  remove: (_id) => {
-  },
-  isActive: (_id) => false,
-  closeAll: () => {
-  },
-  close: (_id) => {
-  }
+var toaster = createToaster({
+  placement: "top-end",
+  pauseOnPageIdle: true
+});
+var bottomToaster = createToaster({
+  placement: "bottom-end",
+  pauseOnPageIdle: true
+});
+var topToaster = createToaster({
+  placement: "top",
+  pauseOnPageIdle: true
 });
-var toaster = createToastStub();
 var initialState = {
+  // fromTxHash:
+  //   '0x635470331be4c59357ff80b62c596ba5b09508d8c1572477ad7b2f4f0a0bd1a7' as `0x${string}`,
   fromTxHash: null,
   toTxHash: null,
   startTrading: false,
   solanaFromTxHash: null,
   isSolanaTransaction: false
+  // fromValue: null,
+  // tryAgain: false
 };
 var useTxStateContextStore = create((set) => ({
   ...initialState,
@@ -1440,9 +1756,6 @@ var useResetSwapAndBridgeState = () => {
     prevPathnameRef.current = currentPathname;
   }, []);
 };
-var logger2 = {
-  error: (...args) => console.error(...args)
-};
 var useGuardChain = (callback, requiredChainId) => {
   const [isSwitching, setIsSwitching] = useState(false);
   const cb = useRef(callback);
@@ -1455,29 +1768,42 @@ var useGuardChain = (callback, requiredChainId) => {
     isSwitching,
     sendTx: useCallback(async () => {
       if (chainId !== requiredChainId) {
+        console.log("###chainId is !== requiredChainId, need switch chain###");
+        console.log(
+          "###current chainId:",
+          chainId,
+          "requiredChainId:",
+          requiredChainId
+        );
         try {
           setIsSwitching(true);
           await connectRequiredChain(config, requiredChainId, connector);
+          console.log("###switch chain success###");
+          console.log("### reconnecting wagmi connector ###");
           try {
             await reconnectAsync();
-          } catch {
+          } catch (reconnectError) {
+            console.log("### reconnect failed, but continuing ###", reconnectError);
           }
           await new Promise((resolve) => setTimeout(resolve, 500));
           setIsSwitching(false);
           cb.current();
         } catch (error) {
           setIsSwitching(false);
-          logger2.error("switch chain error", error);
+          console.log("###switch chain fail###");
+          logger.error("switch chain error", error);
           throw new Error(
             `Failed to switch to ${getChainName(config, requiredChainId)}. Please switch manually in your wallet.`
           );
         }
       } else {
         if (!connector) {
+          console.log("### connector is undefined on correct chain, reconnecting... ###");
           try {
             await reconnectAsync();
             await new Promise((resolve) => setTimeout(resolve, 300));
-          } catch {
+          } catch (reconnectError) {
+            console.log("### reconnect failed ###", reconnectError);
           }
         }
         cb.current();
@@ -1494,13 +1820,24 @@ async function connectRequiredChain(config, chainId, connector) {
   if (!chain) {
     throw new Error(`Chain with id ${chainId} not found in config`);
   }
+  console.log("### connectRequiredChain ###", {
+    chainId,
+    chainName: chain.name
+  });
+  console.log("### connector ###", connector?.name, connector?.id);
   let provider;
   if (connector) {
     try {
       if (connector.id && connector.name) {
         provider = await connector.getProvider?.();
+        console.log("### Got provider from connector ###", {
+          connectorName: connector.name,
+          connectorId: connector.id,
+          isMetaMask: provider?.isMetaMask
+        });
       }
-    } catch {
+    } catch (e) {
+      console.log("### Failed to get provider from connector, will use fallback ###", e);
     }
   }
   if (!provider) {
@@ -1520,17 +1857,30 @@ async function connectRequiredChain(config, chainId, connector) {
     } else {
       provider = ethereum;
     }
+    console.log("### Fallback to window.ethereum ###", {
+      isMetaMask: provider?.isMetaMask,
+      isOkxWallet: provider?.isOkxWallet
+    });
   }
   if (!provider) {
     throw new Error("No wallet provider found");
   }
+  console.log("### Provider info ###", {
+    isMetaMask: provider.isMetaMask,
+    isConnected: provider.isConnected?.()
+  });
   try {
+    console.log("### Trying wallet_switchEthereumChain ###");
     await provider.request({
       method: "wallet_switchEthereumChain",
       params: [{ chainId: `0x${chainId.toString(16)}` }]
     });
+    console.log("### wallet_switchEthereumChain success ###");
   } catch (switchError) {
+    console.log("### switchChain error ###", switchError);
+    console.log("### error.code ###", switchError?.code);
     if (switchError?.code === 4902) {
+      console.log("### Chain not found, adding to wallet ###");
       const addChainParams = {
         chainId: `0x${chainId.toString(16)}`,
         chainName: chain.name,
@@ -1538,16 +1888,20 @@ async function connectRequiredChain(config, chainId, connector) {
           name: chain.nativeCurrency.name,
           symbol: chain.nativeCurrency.symbol,
           decimals: 18
+          // Metamask requires decimals to be 18
         },
         rpcUrls: chain.rpcUrls.default.http,
         blockExplorerUrls: chain.blockExplorers?.default ? [chain.blockExplorers.default.url] : []
       };
+      console.log("### addChainParams ###", addChainParams);
       try {
         await provider.request({
           method: "wallet_addEthereumChain",
           params: [addChainParams]
         });
+        console.log("### Chain added successfully ###");
       } catch (addError) {
+        console.log("### wallet_addEthereumChain error ###", addError);
         throw addError;
       }
     } else {
@@ -1592,11 +1946,311 @@ var useRefreshLoading = () => {
   }, [isLoading, setIsLoading]);
   return { isLoading, startLoading };
 };
+var katana2 = /* @__PURE__ */ defineChain({
+  id: 747474,
+  name: "Katana",
+  network: "katana",
+  nativeCurrency: {
+    name: "Ether",
+    symbol: "ETH",
+    decimals: 18
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://rpc.katana.network"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "katana explorer",
+      url: "https://explorer.katanarpc.com"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 1898013
+    }
+  },
+  testnet: false
+});
+var hyperevm2 = /* @__PURE__ */ defineChain({
+  id: 999,
+  name: "HyperEVM",
+  network: "HYPE",
+  nativeCurrency: {
+    name: "HYPER",
+    symbol: "HYPER",
+    decimals: 18
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://rpc.hyperliquid.xyz/evm", "https://rpc.hypurrscan.io"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Purrsec",
+      url: "https://hyperevmscan.io"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 13051
+    }
+  },
+  testnet: false
+});
+var plasma2 = /* @__PURE__ */ defineChain({
+  id: 9745,
+  name: "Plasma",
+  network: "Plasma",
+  nativeCurrency: {
+    name: "Plasma",
+    symbol: "XPL",
+    decimals: 18
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://rpc.plasma.to"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Plasma explorer",
+      url: "https://plasmascan.to"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 1
+    }
+  },
+  testnet: true
+});
+var rari2 = /* @__PURE__ */ defineChain({
+  id: 1380012617,
+  name: "RARI",
+  network: "rari",
+  nativeCurrency: {
+    name: "Ether",
+    symbol: "ETH",
+    decimals: 18
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://mainnet.rpc.rarichain.org/http"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "RARI explorer",
+      url: "https://mainnet.explorer.rarichain.org/"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 1898013
+    }
+  },
+  testnet: true
+});
+
+// src/consts/stable.ts
+var stable2 = { tokens: [], id: 1 };
+
+// src/consts/monad.ts
+var monad2 = { tokens: [], chains: [], id: 10143 };
+
+// src/consts/mainnet.ts
+var mainnet3 = { tokens: [], chains: [], id: 1 };
+var metis2 = /* @__PURE__ */ defineChain({
+  id: 1088,
+  name: "Metis",
+  nativeCurrency: {
+    decimals: 18,
+    name: "Metis",
+    symbol: "METIS"
+  },
+  rpcUrls: {
+    default: {
+      http: [
+        "https://metis.api.onfinality.io/public",
+        "https://metis-public.nodies.app",
+        "https://metis-andromeda.rpc.thirdweb.com",
+        "https://metis.drpc.org"
+      ],
+      webSocket: ["wss://metis-rpc.publicnode.com", "wss://metis.drpc.org"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Metis Explorer",
+      url: "https://explorer.metis.io",
+      apiUrl: "https://api.routescan.io/v2/network/mainnet/evm/1088/etherscan/api"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xca11bde05977b3631167028862be2a173976ca11",
+      blockCreated: 2338552
+    }
+  }
+});
+var polygonZkEvm2 = /* @__PURE__ */ defineChain({
+  id: 1101,
+  name: "Polygon zkEVM",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ["https://zkevm-rpc.com"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "PolygonScan",
+      url: "https://www.oklink.com/polygon-zkevm",
+      apiUrl: "https://api-zkevm.polygonscan.com/api"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xca11bde05977b3631167028862be2a173976ca11",
+      blockCreated: 57746
+    }
+  }
+});
+var megaeth2 = /* @__PURE__ */ defineChain({
+  id: 4326,
+  name: "MegaETH",
+  network: "MegaETH",
+  nativeCurrency: {
+    name: "ETH",
+    symbol: "ETH",
+    decimals: 18
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://mainnet.megaeth.com/rpc"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "megaeth explorer",
+      url: "https://megaeth.blockscout.com/"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 0
+    }
+  },
+  testnet: false
+});
+
+// src/consts/chainsInfo.ts
+var allChains = [
+  { chain: mainnet, networkType: "mainnet" },
+  { chain: arbitrum, networkType: "mainnet" },
+  { chain: optimism, networkType: "mainnet" },
+  { chain: base$1, networkType: "mainnet" },
+  { chain: polygon, networkType: "mainnet" },
+  { chain: bsc, networkType: "mainnet" },
+  { chain: avalanche, networkType: "mainnet" },
+  { chain: zksync, networkType: "mainnet" },
+  { chain: linea, networkType: "mainnet" },
+  { chain: scroll, networkType: "mainnet" },
+  { chain: mantle, networkType: "mainnet" },
+  { chain: blast, networkType: "mainnet" },
+  { chain: celo, networkType: "mainnet" },
+  { chain: gnosis, networkType: "mainnet" },
+  { chain: sonic, networkType: "mainnet" },
+  { chain: zora, networkType: "mainnet" },
+  { chain: mode, networkType: "mainnet" },
+  { chain: taiko, networkType: "mainnet" },
+  { chain: sei, networkType: "mainnet" },
+  { chain: xdc, networkType: "mainnet" },
+  { chain: ink, networkType: "mainnet" },
+  { chain: soneium$1, networkType: "mainnet" },
+  { chain: worldchain, networkType: "mainnet" },
+  { chain: unichain, networkType: "mainnet" },
+  { chain: opBNB, networkType: "mainnet" },
+  { chain: lisk, networkType: "mainnet" },
+  { chain: morph, networkType: "mainnet" },
+  { chain: bob, networkType: "mainnet" },
+  { chain: abstract, networkType: "mainnet" },
+  { chain: hemi, networkType: "mainnet" },
+  { chain: xLayer, networkType: "mainnet" },
+  { chain: cronos, networkType: "mainnet" },
+  { chain: gravity, networkType: "mainnet" },
+  { chain: manta, networkType: "mainnet" },
+  { chain: zircuit, networkType: "mainnet" },
+  { chain: berachain, networkType: "mainnet" },
+  { chain: plumeMainnet, networkType: "mainnet" },
+  { chain: plume, networkType: "mainnet" },
+  { chain: hashkey, networkType: "mainnet" },
+  { chain: flowMainnet, networkType: "mainnet" },
+  { chain: etherlink, networkType: "mainnet" },
+  { chain: ronin, networkType: "mainnet" },
+  { chain: flare, networkType: "mainnet" },
+  { chain: rootstock, networkType: "mainnet" },
+  { chain: iota, networkType: "mainnet" },
+  { chain: pulsechain, networkType: "mainnet" },
+  // custom chains
+  { chain: katana2, networkType: "mainnet" },
+  { chain: hyperevm2, networkType: "mainnet" },
+  { chain: plasma2, networkType: "mainnet" },
+  { chain: rari2, networkType: "mainnet" },
+  { chain: stable2, networkType: "mainnet" },
+  { chain: monad2, networkType: "mainnet" },
+  { chain: mainnet3, networkType: "mainnet" },
+  { chain: metis2, networkType: "mainnet" },
+  { chain: polygonZkEvm2, networkType: "mainnet" },
+  { chain: megaeth2, networkType: "mainnet" },
+  // testnet
+  { chain: sepolia, networkType: "testnet" },
+  { chain: arbitrumSepolia, networkType: "testnet" },
+  { chain: optimismSepolia, networkType: "testnet" },
+  { chain: baseSepolia, networkType: "testnet" },
+  { chain: unichainSepolia, networkType: "testnet" }
+];
+var testnetIdMapMainnetId = {
+  [sepolia.id]: mainnet.id,
+  [arbitrumSepolia.id]: arbitrum.id,
+  [optimismSepolia.id]: optimism.id,
+  [baseSepolia.id]: base$1.id,
+  [unichainSepolia.id]: unichain.id
+};
+var chainsInfo = allChains.reduce(
+  (acc, { chain }) => {
+    acc[chain.id] = {
+      name: chain.name ?? `Chain ${chain.id}`,
+      id: chain.id,
+      icon: chain.testnet ? `https://wheelx.fi/images/networks/${testnetIdMapMainnetId[chain.id] || chain.id}.png` : `https://wheelx.fi/images/networks/${chain.id}.png`,
+      explorer: chain.blockExplorers?.default?.url,
+      rpc: chain.rpcUrls?.default?.http?.[0] ?? ""
+    };
+    return acc;
+  },
+  {}
+);
+var defaultRpc = allChains.reduce(
+  (acc, { chain }) => {
+    acc[chain.id] = chain.rpcUrls?.default?.http?.[0] ?? "";
+    return acc;
+  },
+  {}
+);
+
+// src/core/hooks/useTokenBalance.ts
 var FRONTEND_MAX_RETRY_COUNT = 3;
 var REQUEST_TIMEOUT = 4e3;
 var BALANCE_REFETCH_INTERVAL = 12e3;
 var chainRpcMode = /* @__PURE__ */ new Map();
-var defaultRpc = {};
 var getBalanceByClient = async (client, address, tokenAddress) => {
   if (tokenAddress) {
     const [value2, decimals, symbol] = await Promise.all([
@@ -1722,9 +2376,10 @@ var selectSolanaConnection = (providers) => {
     defaultProvider: solanaProviders?.[0]?.provider ?? null
   };
 };
-var useSolanaTokenBalance = (tokenMintAddress, isEnabled = true) => {
+var useSolanaTokenBalance = (tokenMintAddress, isEnabled = true, ownerAddress) => {
   const { solanaWalletAddress } = useWalletConnectedStore();
   const { defaultProvider: connection } = useRpcProviders(selectSolanaConnection);
+  const resolvedOwnerAddress = ownerAddress || solanaWalletAddress;
   const normalizedTokenMint = normalizeAddress(tokenMintAddress);
   const isSolToken = !tokenMintAddress || normalizedTokenMint === normalizeAddress(SOL_MINT_ADDRESS) || normalizedTokenMint === normalizeAddress(SOL_NATIVE_ADDRESS);
   const {
@@ -1734,7 +2389,7 @@ var useSolanaTokenBalance = (tokenMintAddress, isEnabled = true) => {
     error,
     fetchAccountBalances
   } = useTokenBalances({
-    accountAddress: solanaWalletAddress || void 0,
+    accountAddress: resolvedOwnerAddress || void 0,
     chainName: ChainEnum.Sol,
     networkId: SOLANA_MAINNET_NETWORK_ID,
     includeNativeBalance: true,
@@ -1748,7 +2403,7 @@ var useSolanaTokenBalance = (tokenMintAddress, isEnabled = true) => {
   useEffect(() => {
     let cancelled = false;
     const fetchByRpc = async () => {
-      if (!isEnabled || !solanaWalletAddress || !connection) {
+      if (!isEnabled || !resolvedOwnerAddress || !connection) {
         setRpcData(null);
         setRpcError(null);
         setRpcLoading(false);
@@ -1757,7 +2412,7 @@ var useSolanaTokenBalance = (tokenMintAddress, isEnabled = true) => {
       setRpcLoading(true);
       setRpcError(null);
       try {
-        const owner = new PublicKey(solanaWalletAddress);
+        const owner = new PublicKey(resolvedOwnerAddress);
         if (isSolToken) {
           const lamports = await connection.getBalance(owner);
           if (cancelled) return;
@@ -1806,9 +2461,9 @@ var useSolanaTokenBalance = (tokenMintAddress, isEnabled = true) => {
     return () => {
       cancelled = true;
     };
-  }, [connection, isEnabled, isSolToken, solanaWalletAddress, tokenMintAddress]);
+  }, [connection, isEnabled, isSolToken, resolvedOwnerAddress, tokenMintAddress]);
   const dynamicData = useMemo(() => {
-    if (!isEnabled || !solanaWalletAddress) return null;
+    if (!isEnabled || !resolvedOwnerAddress) return null;
     if (isSolToken) {
       const native = tokenBalances.find((item) => item.isNative);
       if (!native) {
@@ -1843,12 +2498,12 @@ var useSolanaTokenBalance = (tokenMintAddress, isEnabled = true) => {
       formatted: String(targetToken.balance ?? 0),
       symbol: targetToken.symbol || ""
     };
-  }, [isEnabled, isSolToken, normalizedTokenMint, solanaWalletAddress, tokenBalances]);
+  }, [isEnabled, isSolToken, normalizedTokenMint, resolvedOwnerAddress, tokenBalances]);
   const data = useMemo(() => {
-    if (!isEnabled || !solanaWalletAddress) return null;
+    if (!isEnabled || !resolvedOwnerAddress) return null;
     if (rpcData) return rpcData;
     return dynamicData;
-  }, [dynamicData, isEnabled, rpcData, solanaWalletAddress]);
+  }, [dynamicData, isEnabled, rpcData, resolvedOwnerAddress]);
   return {
     data,
     isLoading: isLoading || rpcLoading,
@@ -2487,24 +3142,29 @@ function useRetryAbleTransactionReceipt(hash, chain_id, maxRetries = 6) {
     lastError
   };
 }
-
-// src/core/utils/consts.ts
 var nullAddress = "0x0000000000000000000000000000000000000000";
+var hyperliquidChainId = 998;
 var ETH_TO_ETH_BRIDGE_SLIPPAGE = 0;
 var ETH_TO_ETH_BRIDGE_REFRESH_INTERVAL = 15;
-var isETHtoETHBridge = (fromToken, toToken, chains) => {
-  if (!chains) return false;
-  const fromChain = chains.find((c) => c.chain_id === fromToken.chain_id);
-  const toChain = chains.find((c) => c.chain_id === toToken.chain_id);
-  if (!fromChain || !toChain) return false;
-  const fromIsEth = fromToken.address.toLowerCase() === fromChain.eth_token.toLowerCase();
-  const toIsEth = toToken.address.toLowerCase() === toChain.eth_token.toLowerCase();
-  const isDifferentChain = fromToken.chain_id !== toToken.chain_id;
-  return fromIsEth && toIsEth && isDifferentChain;
-};
+function isETHtoETHBridge(fromTokenInfo, toTokenInfo, chains) {
+  if (!fromTokenInfo || !toTokenInfo || !chains) return false;
+  if (fromTokenInfo.chain_id === toTokenInfo.chain_id) return false;
+  const fromChain = chains.find(
+    (c) => c.chain_id === fromTokenInfo.chain_id
+  );
+  const toChain = chains.find(
+    (c) => c.chain_id === toTokenInfo.chain_id
+  );
+  const fromIsETH = fromTokenInfo.address === fromChain?.eth_token || fromTokenInfo.tags?.includes("native");
+  const toIsETH = toTokenInfo.address === toChain?.eth_token || toTokenInfo.tags?.includes("native");
+  return fromIsETH && toIsETH;
+}
 var STABLECOIN_SAME_CHAIN_SLIPPAGE = 10;
 var STABLECOIN_CROSS_CHAIN_SLIPPAGE = 50;
 var STABLECOIN_REFRESH_INTERVAL = 30;
+var STABLECOIN_SAME_CHAIN_WARN_SLIPPAGE = 5;
+var STABLECOIN_CROSS_CHAIN_WARN_SLIPPAGE = 20;
+var HIGH_SLIPPAGE_WARN_THRESHOLD = 300;
 function isStablecoin(tokenInfo) {
   if (!tokenInfo?.categories) return false;
   return tokenInfo.categories.includes("stablecoin");
@@ -2534,7 +3194,26 @@ function getDefaultSlippage(policy, isBridge, isSameChain) {
   if (isBridge) return 200;
   return 0;
 }
-var hyperliquidChainId = 998;
+function getLowSlippageWarnThreshold(fromTokenInfo, toTokenInfo, matchedPolicy, isETHtoETH = false) {
+  if (!fromTokenInfo || !toTokenInfo) return 0;
+  if (isETHtoETH) return 0;
+  const isSameChain = fromTokenInfo.chain_id === toTokenInfo.chain_id;
+  const isBridge = !isSameChain;
+  if (isStablecoin(fromTokenInfo) && isStablecoin(toTokenInfo)) {
+    return isBridge ? STABLECOIN_CROSS_CHAIN_WARN_SLIPPAGE : STABLECOIN_SAME_CHAIN_WARN_SLIPPAGE;
+  }
+  if (matchedPolicy?.min_slippage !== void 0) {
+    return matchedPolicy.min_slippage;
+  }
+  return 0;
+}
+function isNativeToken(tokenInfo) {
+  if (!tokenInfo) return false;
+  if (isSolanaChain2(tokenInfo.chain_id)) {
+    return tokenInfo.symbol?.toUpperCase() === "SOL" || String(tokenInfo.address) === "11111111111111111111111111111111";
+  }
+  return tokenInfo.address === zeroAddress || tokenInfo.tags?.includes("native");
+}
 var calculateSlippage = (slippage) => {
   if (!slippage) return;
   const slippageFraction = new Fraction(slippage);
@@ -2546,31 +3225,86 @@ var formatSlippage = (slippage) => {
 };
 
 // src/core/utils/debounce.ts
-function debounce2(func, wait) {
-  let timeout = null;
+function debounce2(func, delay) {
+  let timeoutId = null;
   return (...args) => {
-    if (timeout) clearTimeout(timeout);
-    timeout = setTimeout(() => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
       func(...args);
-    }, wait);
+      timeoutId = null;
+    }, delay);
   };
 }
 
 // src/core/utils/defaultData.ts
 var saveDay = [
-  { name: "Blast", chainId: 81457, day: 8 },
-  { name: "Bob", chainId: 60808, day: 5 },
-  { name: "Celo", chainId: 42220, day: 7 },
-  { name: "Gravity", chainId: 1625, day: 7 },
-  { name: "Hashkey Chain", chainId: 177, day: 7 },
-  { name: "Ink", chainId: 57073, day: 7 },
-  { name: "Lisk", chainId: 1135, day: 7 },
-  { name: "Mode", chainId: 34443, day: 7 },
-  { name: "opBNB", chainId: 204, day: 7 },
-  { name: "RARI", chainId: 1380012617, day: 8 },
-  { name: "Unichain", chainId: 130, day: 7 },
-  { name: "Worldchain", chainId: 480, day: 7 },
-  { name: "Zora", chainId: 7777777, day: 7 }
+  {
+    name: "Blast",
+    chainId: 81457,
+    day: 8
+  },
+  {
+    name: "Bob",
+    chainId: 60808,
+    day: 5
+  },
+  {
+    name: "Celo",
+    chainId: 42220,
+    day: 7
+  },
+  {
+    name: "Gravity",
+    chainId: 1625,
+    day: 7
+  },
+  {
+    name: "Hashkey Chain",
+    chainId: 177,
+    day: 7
+  },
+  {
+    name: "Ink",
+    chainId: 57073,
+    day: 7
+  },
+  {
+    name: "Lisk",
+    chainId: 1135,
+    day: 7
+  },
+  {
+    name: "Mode",
+    chainId: 34443,
+    day: 7
+  },
+  {
+    name: "opBNB",
+    chainId: 204,
+    day: 7
+  },
+  {
+    name: "RARI",
+    chainId: 1380012617,
+    day: 8
+  },
+  {
+    name: "Unichain",
+    chainId: 130,
+    day: 7
+  },
+  {
+    name: "Worldchain",
+    chainId: 480,
+    day: 7
+  },
+  {
+    name: "Zora",
+    chainId: 7777777,
+    day: 7
+  }
 ];
 
 // ../../node_modules/@wagmi/core/dist/esm/utils/getAction.js
@@ -2900,29 +3634,6 @@ var getErc20Approval = (config) => {
 };
 
 // src/core/utils/index.ts
-var getOrderedTokensChainSearch = (tokens) => tokens;
-var getOrderedTokensAssets = (tokens) => tokens;
-var mergeAndDeduplicate = (a, b, key = "") => [...a, ...b];
-var STABLECOIN_SAME_CHAIN_WARN_SLIPPAGE = 5;
-var STABLECOIN_CROSS_CHAIN_WARN_SLIPPAGE = 20;
-var HIGH_SLIPPAGE_WARN_THRESHOLD = 300;
-function isStablecoin2(tokenInfo) {
-  if (!tokenInfo?.categories) return false;
-  return tokenInfo.categories.includes("stablecoin");
-}
-function getLowSlippageWarnThreshold(fromTokenInfo, toTokenInfo, matchedPolicy, isETHtoETH = false) {
-  if (!fromTokenInfo || !toTokenInfo) return 0;
-  if (isETHtoETH) return 0;
-  const isSameChain = fromTokenInfo.chain_id === toTokenInfo.chain_id;
-  const isBridge = !isSameChain;
-  if (isStablecoin2(fromTokenInfo) && isStablecoin2(toTokenInfo)) {
-    return isBridge ? STABLECOIN_CROSS_CHAIN_WARN_SLIPPAGE : STABLECOIN_SAME_CHAIN_WARN_SLIPPAGE;
-  }
-  if (matchedPolicy?.min_slippage !== void 0) {
-    return matchedPolicy.min_slippage;
-  }
-  return 0;
-}
 var formatDecimalNum = (val, fixed = 6) => {
   if (val === void 0 || val === null || val === "") return "";
   const num = Number(val);
@@ -3405,7 +4116,47 @@ var BoxWithBg = ({
 }) => {
   return /* @__PURE__ */ jsx(Box, { w: "100%", bg: "#F5F6FF", borderRadius: "16px", p: 3, ...props, children });
 };
-var OptimizedImage = (props) => /* @__PURE__ */ jsx(Image, { ...props });
+var OptimizedImage = forwardRef(
+  ({
+    src,
+    alt,
+    width,
+    height,
+    fill = false,
+    objectFit = "cover",
+    w,
+    h,
+    ...props
+  }, ref) => {
+    const boxWidth = w ?? width;
+    const boxHeight = h ?? height;
+    const isPercentWidth = typeof boxWidth === "string" && boxWidth.endsWith("%");
+    const shouldUseFill = fill || isPercentWidth;
+    return /* @__PURE__ */ jsx(
+      Box,
+      {
+        ref,
+        position: shouldUseFill ? "relative" : "static",
+        overflow: "hidden",
+        w,
+        h,
+        ...props,
+        children: /* @__PURE__ */ jsx(
+          Image,
+          {
+            src,
+            alt,
+            width: shouldUseFill ? "100%" : boxWidth,
+            height: shouldUseFill ? "100%" : boxHeight,
+            objectFit,
+            loading: "lazy"
+          }
+        )
+      }
+    );
+  }
+);
+OptimizedImage.displayName = "OptimizedImage";
 
 // src/core/utils/twoApprove.ts
 var useUSDTHandler = () => {
@@ -3447,7 +4198,9 @@ var FormButton = ({
   clearLockedRequestId,
   lockedRequestId,
   getQuote,
-  currentRequestId
+  currentRequestId,
+  skipEvmWalletConnect = false,
+  skipSolanaWalletConnect = false
 }) => {
   const { theme } = useWidgetTheme();
   const address = useEvmAddress();
@@ -3667,11 +4420,19 @@ var FormButton = ({
       console.log("[Transaction] Connectors empty but wallet detected, triggering Dynamic reconnect...");
       openModal();
       setUserCancelsTransaction(true);
+      toaster.create({
+        description: "Please reconnect your EVM wallet and try again",
+        type: "info"
+      });
       return;
     }
     if (!txOwner || !txConnector) {
       setUserCancelsTransaction(true);
       openConnectModal();
+      toaster.create({
+        description: "Please reconnect EVM wallet and try again",
+        type: "error"
+      });
       return;
     }
     try {
@@ -3932,6 +4693,10 @@ var FormButton = ({
   const handleSolanaSwap = async () => {
     if (!isSolanaWalletConnected || !solanaWalletAddress) {
       setUserCancelsTransaction(true);
+      toaster.create({
+        description: "Please reconnect Solana wallet and try again",
+        type: "error"
+      });
       openModal();
       return;
     }
@@ -4014,7 +4779,7 @@ var FormButton = ({
         }
       ) });
     }
-    if ((fromTokenInfo.isSolana || toTokenInfo.isSolana) && !solanaWalletAddress) {
+    if ((fromTokenInfo.isSolana || toTokenInfo.isSolana) && !solanaWalletAddress && !(skipSolanaWalletConnect && !fromTokenInfo.isSolana)) {
       return renderSolanaWalletConnectButton();
     }
     if (!fromTokenInfo.isSolana && !hasEvmUiWallet) {
@@ -4026,14 +4791,14 @@ var FormButton = ({
       }
       return renderEvmWalletConnectButton();
     } else if (!hasEvmUiWallet && solanaWalletAddress) {
-      if (!fromTokenInfo.isSolana && !toTokenInfo.isSolana || !fromTokenInfo.isSolana && toTokenInfo.isSolana || fromTokenInfo.isSolana && !toTokenInfo.isSolana) {
+      if (!fromTokenInfo.isSolana && !toTokenInfo.isSolana || !fromTokenInfo.isSolana && toTokenInfo.isSolana || fromTokenInfo.isSolana && !toTokenInfo.isSolana && !skipEvmWalletConnect) {
         return renderEvmWalletConnectButton("EVM");
       }
     } else if (hasEvmUiWallet && !solanaWalletAddress) {
-      if (fromTokenInfo.isSolana || toTokenInfo.isSolana) {
+      if (fromTokenInfo.isSolana || toTokenInfo.isSolana && !skipSolanaWalletConnect) {
         return renderSolanaWalletConnectButton();
       }
-      if (fromTokenInfo.isSolana && toTokenInfo.isSolana || !fromTokenInfo.isSolana && toTokenInfo.isSolana || fromTokenInfo.isSolana && !toTokenInfo.isSolana) {
+      if (fromTokenInfo.isSolana && toTokenInfo.isSolana || !fromTokenInfo.isSolana && toTokenInfo.isSolana && !skipSolanaWalletConnect || fromTokenInfo.isSolana && !toTokenInfo.isSolana) {
         return renderSolanaWalletConnectButton();
       }
     }
@@ -4147,9 +4912,10 @@ var FormButton = ({
     )
   ] });
 };
-function getOrderedTokensAssets2(tokens, selectedChain, propertyName) {
+function getOrderedTokensAssets(tokens, selectedChain, propertyName) {
   return tokens?.filter((token) => {
-    return true;
+    if (!selectedChain) return true;
+    return token.chain_id === selectedChain;
   }).sort((a, b) => {
     if (a.usdPrice === null && b.usdPrice === null) {
       if (a.balance && b.balance) {
@@ -4251,6 +5017,48 @@ function getOrderedTokensChainNormal(tokens, selectedChain, propertyName) {
     return 0;
   });
 }
+function getOrderedTokensChainSearch(tokens, selectedChain) {
+  return tokens?.filter((token) => {
+    if (!selectedChain) return true;
+    return token.chain_id === selectedChain;
+  }).sort((a, b) => {
+    if (a.usdPrice && b.usdPrice && a.balance && b.balance) {
+      if (a.balance === "NaN" && b.balance !== "NaN") {
+        return -1;
+      }
+      if (a.balance !== "NaN" && b.balance === "NaN") {
+        return 1;
+      }
+      if (a.balance === "NaN" && b.balance === "NaN") {
+        return 0;
+      }
+      const aBalance = new Fraction(a.usdPrice).mul(a.balance);
+      const bBalance = new Fraction(b.usdPrice).mul(b.balance);
+      if (aBalance.gt(bBalance)) return -1;
+      if (aBalance.lt(bBalance)) return 1;
+    }
+    if (a.balance && b.balance) {
+      if (a.balance === "NaN" && b.balance !== "NaN") {
+        return -1;
+      }
+      if (a.balance !== "NaN" && b.balance === "NaN") {
+        return 1;
+      }
+      if (a.balance === "NaN" && b.balance === "NaN") {
+        return 0;
+      }
+      if (new Fraction(a.balance).gt(new Fraction(b.balance))) return -1;
+      if (new Fraction(a.balance).lt(new Fraction(b.balance))) return 1;
+    }
+    if (a.balance && !b.balance) return -1;
+    if (!a.balance && b.balance) return 1;
+    const aIsDin = a.token_type === "preset";
+    const bIsDin = b.token_type === "preset";
+    if (aIsDin && !bIsDin) return -1;
+    if (!aIsDin && bIsDin) return 1;
+    return 0;
+  });
+}
 function processChains(favorites, allNetworks) {
   const favoriteNetworkIds = new Set(favorites.map((fav) => fav.networkId));
   const favoriteChains = allNetworks.filter(
@@ -4261,6 +5069,28 @@ function processChains(favorites, allNetworks) {
   );
   return { favoriteChains, nonFavoriteChains };
 }
+function mergeAndDeduplicate(arr1, arr2) {
+  const mergedArray = [...arr1, ...arr2];
+  const map = /* @__PURE__ */ new Map();
+  for (const item of mergedArray) {
+    const key = `${item.address}-${item.chain_id}`;
+    if (!map.has(key)) {
+      map.set(key, item);
+    } else {
+      const existingItem = map.get(key);
+      const existingHasPreset = existingItem.token_type === "preset";
+      const currentHasPreset = item.token_type === "preset";
+      if (existingHasPreset && !currentHasPreset) {
+        continue;
+      } else if (!existingHasPreset && currentHasPreset) {
+        map.set(key, item);
+      } else {
+        continue;
+      }
+    }
+  }
+  return Array.from(map.values());
+}
 function filterTokenByType(items, searchString) {
   return items.filter((item) => item.categories?.includes(searchString));
 }
@@ -4272,17 +5102,8 @@ function filterTokenUnType(items, excludeTypes) {
   });
 }
 
-// src/consts/mainnet.ts
-var mainnet3 = { id: 1 };
-
-// src/consts/monad.ts
-var monad2 = { id: 10143 };
-
-// src/consts/stable.ts
-var stable2 = { id: 1 };
-
 // src/core/SelectTokenModal/hooks/useChainsAndTokensForSelect.ts
-[mainnet3.id, base.id, ink.id, bsc.id, monad2.id, soneium.id, stable2.id];
+[mainnet3.id, base.id, ink$1.id, bsc$1.id, monad2.id, soneium.id, stable2.id];
 var useChainsAndTokensForSelect = ({
   data,
   selectedChain,
@@ -4298,7 +5119,7 @@ var useChainsAndTokensForSelect = ({
     ],
     [data?.chains, data?.deposit_platforms?.prediction?.chains]
   );
-  const allChains = useMemo(() => {
+  const allChains2 = useMemo(() => {
     if (!allowedChainIds || allowedChainIds.length === 0) return rawChains;
     const allowedSet = new Set(allowedChainIds);
     return rawChains.filter((c) => allowedSet.has(c.chain_id));
@@ -4327,39 +5148,39 @@ var useChainsAndTokensForSelect = ({
     setSearchTokensValue("");
   }, []);
   const popularChains = useMemo(
-    () => (allChains ?? []).filter((chain) => chain.is_popular === true).sort((a, b) => {
+    () => (allChains2 ?? []).filter((chain) => chain.is_popular === true).sort((a, b) => {
       const nameA = a.name.toLowerCase();
       const nameB = b.name.toLowerCase();
       if (nameA < nameB) return -1;
       if (nameA > nameB) return 1;
       return 0;
     }),
-    [allChains]
+    [allChains2]
   );
   const currentChain = useMemo(() => {
     if (selectedChainByPlatformId) {
-      return allChains?.find(
+      return allChains2?.find(
         (chain) => chain.platform_id === selectedChainByPlatformId
       );
     } else {
-      return allChains?.find((chain) => chain.chain_id === selectedChain);
+      return allChains2?.find((chain) => chain.chain_id === selectedChain);
     }
-  }, [allChains, selectedChain]);
+  }, [allChains2, selectedChain]);
   const searchChains = useMemo(() => {
-    return allChains?.filter((chain) => {
+    return allChains2?.filter((chain) => {
       if (searchChainsValue === "") return false;
       return chain.name.toLowerCase().includes(searchChainsValue.toLowerCase()) || chain.chain_id.toString().includes(searchChainsValue.toLowerCase());
     });
-  }, [allChains, searchChainsValue]);
+  }, [allChains2, searchChainsValue]);
   const orderedChains = useMemo(
-    () => allChains?.filter((chain) => !chain.is_popular).sort((a, b) => {
+    () => allChains2?.filter((chain) => !chain.is_popular).sort((a, b) => {
       const firstCharA = a.name.toLowerCase();
       const firstCharB = b.name.toLowerCase();
       if (firstCharA < firstCharB) return -1;
       if (firstCharA > firstCharB) return 1;
       return 0;
     }),
-    [allChains]
+    [allChains2]
   );
   const tokensWithBalances = useMemo(() => {
     if (!allTokens) return void 0;
@@ -4419,7 +5240,7 @@ var useChainsAndTokensForSelect = ({
     handleSearchChains,
     handleSearchTokens,
     resetSearch,
-    allChains
+    allChains: allChains2
   };
 };
 var useUserHasSelectedFromNetwork = create(
@@ -4465,15 +5286,15 @@ var useSearchTokens = ({
       if (filteredTokens) {
         const newArr = mergeAndDeduplicate(tokenWithBalances, filteredTokens);
         if (!selectedChain) {
-          return getOrderedTokensAssets(newArr);
+          return getOrderedTokensAssets(newArr, selectedChain);
         } else {
-          return getOrderedTokensChainSearch(newArr);
+          return getOrderedTokensChainSearch(newArr, selectedChain);
         }
       } else {
         if (!selectedChain) {
-          return getOrderedTokensAssets(tokenWithBalances);
+          return getOrderedTokensAssets(tokenWithBalances, selectedChain);
         } else {
-          return getOrderedTokensChainSearch(tokenWithBalances);
+          return getOrderedTokensChainSearch(tokenWithBalances, selectedChain);
         }
       }
     } else {
@@ -4482,9 +5303,9 @@ var useSearchTokens = ({
         return token.symbol.toLowerCase().includes(searchTokensValue.toLowerCase());
       });
       if (!selectedChain) {
-        return getOrderedTokensAssets(filteredTokens);
+        return getOrderedTokensAssets(filteredTokens, selectedChain);
       } else {
-        return getOrderedTokensChainSearch(filteredTokens);
+        return getOrderedTokensChainSearch(filteredTokens, selectedChain);
       }
     }
   }, [newAllToken, searchTokenInfoResult, searchTokensValue, selectedChain]);
@@ -4755,14 +5576,13 @@ var TokenAmountHeading = ({
   suffix,
   ...props
 }) => {
-  const { theme } = useWidgetTheme();
   const _amount = formatTokenAmount({
     amount,
     decimals
   });
   const leadingZeros = countLeadingZerosAfterDecimal(_amount);
   if (leadingZeros > 5) {
-    return /* @__PURE__ */ jsxs(Heading, { variant: "heading8", ...props, as: "div", color: theme.defaultTextColor, whiteSpace: "nowrap", children: [
+    return /* @__PURE__ */ jsxs(Heading, { variant: "heading8", ...props, as: "div", whiteSpace: "nowrap", children: [
       prefix,
       " ",
       _amount.slice(0, 3),
@@ -4781,7 +5601,7 @@ var TokenAmountHeading = ({
       suffix
     ] });
   }
-  return /* @__PURE__ */ jsxs(Heading, { variant: "heading11", ...props, as: "div", color: theme.defaultTextColor, whiteSpace: "nowrap", children: [
+  return /* @__PURE__ */ jsxs(Heading, { variant: "heading11", ...props, as: "div", whiteSpace: "nowrap", children: [
     prefix,
     " ",
     _amount,
@@ -4802,7 +5622,7 @@ var TokenAmountText = ({
   });
   const leadingZeros = countLeadingZerosAfterDecimal(_amount);
   if (leadingZeros > 5) {
-    return /* @__PURE__ */ jsxs(Text2, { variant: "content8", ...props, children: [
+    return /* @__PURE__ */ jsxs(Text2, { variant: "content7", ...props, as: "div", children: [
       prefix,
       " ",
       _amount.slice(0, 3),
@@ -4821,7 +5641,7 @@ var TokenAmountText = ({
       suffix
     ] });
   }
-  return /* @__PURE__ */ jsxs(Text2, { variant: "content7", ...props, children: [
+  return /* @__PURE__ */ jsxs(Text2, { variant: "content7", ...props, as: "div", children: [
     prefix,
     " ",
     _amount,
@@ -4829,7 +5649,6 @@ var TokenAmountText = ({
     suffix
   ] });
 };
-var chainsInfo = {};
 var TokenIconWithNetworkLogo = ({
   tokenInfo,
   customChainLogo,
@@ -4877,7 +5696,7 @@ var TokenIconWithNetworkLogo = ({
             w,
             h,
             borderRadius: "full",
-            src: logo || `https://wheelx.fi/images/default-token-icon.png`,
+            src: logo || `/images/default-token-icon.png`,
             alt: name || "",
             objectFit: "cover",
             priority
@@ -5379,7 +6198,7 @@ var TokenList = ({
       }
     }
     if (isSelectAll) {
-      return getOrderedTokensAssets2(userTokens)?.map((token, index) => {
+      return getOrderedTokensAssets(userTokens)?.map((token, index) => {
         return /* @__PURE__ */ jsx(
           TokenAndAddress,
           {
@@ -5574,7 +6393,7 @@ var AllChainsIcon = () => {
       /* @__PURE__ */ jsx(
         Image,
         {
-          src: "https://wheelx.fi/images/networks/1.png",
+          src: "/images/networks/1.png",
           alt: "ethereum",
           w: "10px",
           h: "10px",
@@ -5584,7 +6403,7 @@ var AllChainsIcon = () => {
       /* @__PURE__ */ jsx(
         Image,
         {
-          src: "https://wheelx.fi/images/networks/56.png",
+          src: "/images/networks/56.png",
           alt: "bnb",
           w: "10px",
           h: "10px",
@@ -5596,7 +6415,7 @@ var AllChainsIcon = () => {
       /* @__PURE__ */ jsx(
         Image,
         {
-          src: "https://wheelx.fi/images/networks/8453.png",
+          src: "/images/networks/8453.png",
           alt: "base",
           w: "10px",
           h: "10px",
@@ -5606,7 +6425,7 @@ var AllChainsIcon = () => {
       /* @__PURE__ */ jsx(
         Image,
         {
-          src: "https://wheelx.fi/images/networks/42161.png",
+          src: "/images/networks/42161.png",
           alt: "arbitrum",
           w: "10px",
           h: "10px",
@@ -6313,7 +7132,7 @@ var SelectTokenModal = ({
     handleSearchChains,
     handleSearchTokens,
     resetSearch,
-    allChains
+    allChains: allChains2
   } = useChainsAndTokensForSelect({
     data,
     selectedChain,
@@ -6440,7 +7259,7 @@ var SelectTokenModal = ({
     [handleClose, onSelectToken]
   );
   const [isMobileChainsOpen, setIsMobileChainsOpen] = useState(false);
-  const selectedChainInfo = allChains?.find((chain) => {
+  const selectedChainInfo = allChains2?.find((chain) => {
     if (selectedChainByPlatformId) {
       return chain.platform_id === selectedChainByPlatformId;
     } else {
@@ -6678,7 +7497,8 @@ var TokenSelectAndInput = ({
   totalGasFee,
   isLoadingFeeData,
   isInsufficientBalance,
-  onOpenDialog
+  onOpenDialog,
+  config
 }) => {
   const address = useEvmAddress();
   const userWallets = useUserWallets();
@@ -7009,6 +7829,21 @@ var TokenSelectAndInput = ({
       }
       if (address && !solanaWalletAddress) {
         if (!fromTokenInfo.isSolana && isSolanaChain2(toTokenInfo.chain_id) || fromTokenInfo.isSolana && isSolanaChain2(toTokenInfo.chain_id)) {
+          if (config?.solanaDifferentAddress) {
+            return /* @__PURE__ */ jsxs(HStack, { gap: 1, children: [
+              renderSolanaWalletIcon(),
+              /* @__PURE__ */ jsx(
+                Text2,
+                {
+                  variant: "content8",
+                  backgroundColor: theme.highlightBgColor,
+                  padding: "2px",
+                  color: theme.highlightTextColor,
+                  children: sliceAddress(config.solanaDifferentAddress)
+                }
+              )
+            ] });
+          }
           return /* @__PURE__ */ jsxs(
             HStack,
             {
@@ -7048,6 +7883,21 @@ var TokenSelectAndInput = ({
         if (!fromTokenInfo.isSolana && isSolanaChain2(toTokenInfo.chain_id) || fromTokenInfo.isSolana && isSolanaChain2(toTokenInfo.chain_id)) {
           return renderSolanaAddress(solanaWalletAddress);
         } else {
+          if (config?.evmDifferentAddress) {
+            return /* @__PURE__ */ jsxs(HStack, { gap: 1, children: [
+              walletIcon,
+              /* @__PURE__ */ jsx(
+                Text2,
+                {
+                  variant: "content8",
+                  backgroundColor: theme.highlightBgColor,
+                  padding: "2px",
+                  color: theme.highlightTextColor,
+                  children: sliceAddress(config.evmDifferentAddress)
+                }
+              )
+            ] });
+          }
           return /* @__PURE__ */ jsxs(
             HStack,
             {
@@ -7323,10 +8173,10 @@ var TokenSelectAndInput = ({
             bottom: ["6px", "8px"],
             left: 0,
             paddingRight: [2, 4],
-            children: !isFrom && !isDepositPlatformToken && /* @__PURE__ */ jsx(Fragment, { children: tokenInfo.isSolana ? solanaWalletAddress && /* @__PURE__ */ jsxs(Text2, { variant: "content8", children: [
+            children: !isFrom && !isDepositPlatformToken && /* @__PURE__ */ jsx(Fragment, { children: tokenInfo.isSolana ? (solanaWalletAddress || config?.solanaDifferentAddress) && /* @__PURE__ */ jsxs(Text2, { variant: "content8", children: [
               "Balance: ",
               displayBalance
-            ] }) : address && /* @__PURE__ */ jsxs(Text2, { variant: "content8", children: [
+            ] }) : (address || config?.evmDifferentAddress) && /* @__PURE__ */ jsxs(Text2, { variant: "content8", children: [
               "Balance: ",
               displayBalance
             ] }) })
@@ -8129,6 +8979,12 @@ var DifferentAddressDialogInner = ({
     isDepositPlatformToken
   ]);
   useEffect(() => {
+    if (isAddressError) {
+      bottomToaster.error({
+        description: isSolanaTarget ? "This address is not a valid Solana address." : "This address is not a EVM address.",
+        duration: 3e3
+      });
+    }
   }, [isAddressError, isSolanaTarget]);
   return /* @__PURE__ */ jsx(
     Dialog.Root,
@@ -8334,6 +9190,92 @@ var DifferentAddressDialog = ({
   );
 };
 var DifferentAddressDialog_default = DifferentAddressDialog;
+var GetGas = ({ tokenInfo, onToggle, config }) => {
+  const { theme } = useWidgetTheme();
+  const { solanaWalletAddress } = useWalletConnectedStore();
+  const address = useEvmAddress();
+  const { sponsorGas, setSponsorGas } = useGetGasStore();
+  const { tokens } = useTokensStore();
+  const { chains } = useChainsStore();
+  const isNative = useMemo(() => isNativeToken(tokenInfo), [tokenInfo]);
+  const supportSponsorGas = useMemo(() => {
+    if (!chains) return false;
+    const chain = chains.find((c) => c.chain_id === tokenInfo.chain_id);
+    return chain?.support_sponsor_gas ?? false;
+  }, [chains, tokenInfo.chain_id]);
+  const nativeToken = useMemo(() => {
+    if (!tokens) return null;
+    return tokens.find(
+      (t) => t.chain_id === tokenInfo.chain_id && isNativeToken(t)
+    );
+  }, [tokens, tokenInfo.chain_id]);
+  const isSolana = useMemo(() => {
+    return isSolanaChain2(tokenInfo.chain_id);
+  }, [tokenInfo.chain_id]);
+  const evmOwnerAddress = !isSolana && !address && config?.evmDifferentAddress ? config.evmDifferentAddress : void 0;
+  const evmNativeBalance = useTokenBalance2({
+    chainId: tokenInfo.chain_id,
+    tokenAddress: void 0,
+    connectAddress: evmOwnerAddress
+  });
+  const solanaOwnerAddress = isSolana && !solanaWalletAddress && config?.solanaDifferentAddress ? config.solanaDifferentAddress : void 0;
+  const { data: solanaNativeBalanceData } = useSolanaTokenBalance(
+    void 0,
+    isSolana,
+    solanaOwnerAddress
+  );
+  const nativeBalance = useMemo(() => {
+    if (isSolana) return solanaNativeBalanceData ?? void 0;
+    return evmNativeBalance;
+  }, [isSolana, solanaNativeBalanceData, evmNativeBalance]);
+  useEffect(() => {
+    if (!supportSponsorGas || isNative || nativeBalance === void 0) {
+      setSponsorGas(false);
+      return;
+    }
+    setSponsorGas(nativeBalance.value === 0n);
+  }, [supportSponsorGas, isNative, nativeBalance, setSponsorGas]);
+  const shouldShow = supportSponsorGas && !isNative && nativeBalance !== void 0 && nativeBalance.value === 0n;
+  if (!shouldShow) return null;
+  return /* @__PURE__ */ jsxs(
+    HStack,
+    {
+      w: "100%",
+      h: "42px",
+      padding: "0 14px",
+      fontSize: "12px",
+      color: theme.defaultTextColor,
+      backgroundColor: theme.highlightBgColor,
+      borderRadius: "10px",
+      gap: 0,
+      children: [
+        /* @__PURE__ */ jsx(MdLocalGasStation, { width: "14px", height: "14px" }),
+        /* @__PURE__ */ jsxs(Box, { flex: 1, marginLeft: "5px", children: [
+          "Get $",
+          nativeToken?.symbol ?? "ETH",
+          " as gas"
+        ] }),
+        /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(
+          Switch.Root,
+          {
+            colorPalette: theme.getGasSwitchColorPalette ?? "purple",
+            checked: sponsorGas,
+            onCheckedChange: (e) => {
+              setSponsorGas(e.checked);
+              onToggle?.();
+            },
+            children: [
+              /* @__PURE__ */ jsx(Switch.HiddenInput, {}),
+              /* @__PURE__ */ jsx(Switch.Control, {}),
+              /* @__PURE__ */ jsx(Switch.Label, {})
+            ]
+          }
+        ) })
+      ]
+    }
+  );
+};
+var GetGas_default = GetGas;
 var FormBody = ({
   getQuote,
   quoteInfo,
@@ -8369,6 +9311,7 @@ var FormBody = ({
   const [isInsufficientBalance, setIsInsufficientBalance] = useState(false);
   const address = useEvmAddress();
   const { solanaWalletAddress } = useWalletConnectedStore();
+  const { sponsorGas } = useGetGasStore();
   const slippage = address ? slippageStore.get(address) : customSlippage !== void 0 ? { value: customSlippage } : void 0;
   const fromTokenBalanceNormal = useTokenBalance2({
     chainId: fromTokenInfo.chain_id,
@@ -8378,6 +9321,11 @@ var FormBody = ({
     chainId: toTokenInfo.chain_id,
     tokenAddress: toTokenInfo.address === zeroAddress ? void 0 : toTokenInfo.address
   });
+  const toTokenFixedEvmBalance = useTokenBalance2({
+    chainId: toTokenInfo.chain_id,
+    tokenAddress: toTokenInfo.address === zeroAddress ? void 0 : toTokenInfo.address,
+    connectAddress: config?.evmDifferentAddress ? config.evmDifferentAddress : void 0
+  });
   const { data: fromTokenBalanceHyperBack } = useHyperliquidBalance(
     address,
     isFromHyperChain
@@ -8433,10 +9381,10 @@ var FormBody = ({
   }, [fromTokenInfo.isSolana, solanaWalletAddress, address]);
   const toAddress = useMemo(() => {
     if (toTokenInfo.isSolana) {
-      return solanaWalletAddress || "";
+      return config?.solanaDifferentAddress || solanaWalletAddress || "";
     }
-    return differentAddress || address || "";
-  }, [toTokenInfo.isSolana, solanaWalletAddress, differentAddress, address]);
+    return config?.evmDifferentAddress || differentAddress || address || "";
+  }, [toTokenInfo.isSolana, solanaWalletAddress, differentAddress, address, config?.solanaDifferentAddress, config?.evmDifferentAddress]);
   const isFromNativeSOL = fromTokenInfo.isSolana && (fromTokenInfo.symbol?.toUpperCase() === "SOL" || fromTokenInfo.address === "11111111111111111111111111111111");
   const isToNativeSOL = toTokenInfo.isSolana && (toTokenInfo.symbol?.toUpperCase() === "SOL" || toTokenInfo.address === "11111111111111111111111111111111");
   const fromTokenBalanceSolana = useSolanaTokenBalance(
@@ -8465,19 +9413,29 @@ var FormBody = ({
   ]);
   const toTokenBalance = useMemo(() => {
     if (toTokenInfo.isSolana) {
-      return toTokenBalanceSolana.data ? {
-        decimals: toTokenBalanceSolana.data.decimals,
-        value: toTokenBalanceSolana.data.value,
-        formatted: toTokenBalanceSolana.data.formatted
-      } : void 0;
+      if (toTokenBalanceSolana.data) {
+        return {
+          decimals: toTokenBalanceSolana.data.decimals,
+          value: toTokenBalanceSolana.data.value,
+          formatted: toTokenBalanceSolana.data.formatted
+        };
+      }
+      return void 0;
+    }
+    if (isToHyperChain) return toTokenBalanceHyper;
+    if (!address && config?.evmDifferentAddress && toTokenFixedEvmBalance) {
+      return toTokenFixedEvmBalance;
     }
-    return isToHyperChain ? toTokenBalanceHyper : toTokenBalanceNormal;
+    return toTokenBalanceNormal;
   }, [
     toTokenInfo.isSolana,
     toTokenBalanceSolana.data,
     isToHyperChain,
     toTokenBalanceHyper,
-    toTokenBalanceNormal
+    toTokenBalanceNormal,
+    address,
+    config?.evmDifferentAddress,
+    toTokenFixedEvmBalance
   ]);
   const balanceInfo = useMemo(() => {
     const fromBalance = new Fraction(fromTokenBalance?.value ?? 0n);
@@ -8580,8 +9538,8 @@ var FormBody = ({
       if (isSelectingFromToken) {
         setFromTokenInfo(tokenInfo);
         if (isTestnetChain(tokenInfo.chain_id)) {
-          const isNativeToken = tokenInfo.tags?.includes("native") || tokenInfo.address === zeroAddress;
-          if (isNativeToken) {
+          const isNativeToken2 = tokenInfo.tags?.includes("native") || tokenInfo.address === zeroAddress;
+          if (isNativeToken2) {
             const otherToken = tokens?.find(
               (t) => t.chain_id === tokenInfo.chain_id && t.address !== tokenInfo.address
             );
@@ -8616,8 +9574,8 @@ var FormBody = ({
       } else {
         setToTokenInfo(tokenInfo);
         if (isTestnetChain(tokenInfo.chain_id)) {
-          const isNativeToken = tokenInfo.tags?.includes("native") || tokenInfo.address === zeroAddress;
-          if (isNativeToken) {
+          const isNativeToken2 = tokenInfo.tags?.includes("native") || tokenInfo.address === zeroAddress;
+          if (isNativeToken2) {
             const otherToken = tokens?.find(
               (t) => t.chain_id === tokenInfo.chain_id && t.address !== tokenInfo.address
             );
@@ -8685,9 +9643,9 @@ var FormBody = ({
     };
     const _toAddress = () => {
       if (_toTokenInfo.isSolana) {
-        return solanaWalletAddress || "";
+        return config?.solanaDifferentAddress || solanaWalletAddress || "";
       }
-      return differentAddress || address || "";
+      return config?.evmDifferentAddress || differentAddress || address || "";
     };
     const vCode = extractVPathSegment();
     await getQuote({
@@ -8701,7 +9659,8 @@ var FormBody = ({
       slippage: calculateSlippage(slippage?.value),
       toTokenDecimals: _toTokenInfo.decimals,
       affiliation: vCode,
-      to_platform_id: _toTokenInfo.platform_id || 0
+      to_platform_id: _toTokenInfo.platform_id || 0,
+      sponsor_gas: sponsorGas
     });
     saveTokenSelection();
   };
@@ -8725,7 +9684,8 @@ var FormBody = ({
       slippage: calculateSlippage(slippage?.value) || autoSlippage,
       toTokenDecimals: toTokenInfo.decimals,
       affiliation: vCode,
-      to_platform_id: toTokenInfo.platform_id || 0
+      to_platform_id: toTokenInfo.platform_id || 0,
+      sponsor_gas: sponsorGas
     });
   };
   const handleToAmountChange = (value) => {
@@ -8743,7 +9703,8 @@ var FormBody = ({
         amount: parseUnits(fromAmount, fromTokenInfo.decimals).toString(),
         slippage: calculateSlippage(slippage?.value),
         toTokenDecimals: toTokenInfo.decimals,
-        to_platform_id: toTokenInfo.platform_id || 0
+        to_platform_id: toTokenInfo.platform_id || 0,
+        sponsor_gas: sponsorGas
       });
     };
     if (fromAddress && fromAmount) {
@@ -8806,12 +9767,14 @@ var FormBody = ({
               userBalance: balanceInfo.toBalance,
               usdPrice: toTokenUsdPrice,
               isInsufficientBalance,
-              onOpenDialog: handleOpenDifferentAddressDialog
+              onOpenDialog: handleOpenDifferentAddressDialog,
+              config
             }
           )
         ]
       }
     ),
+    /* @__PURE__ */ jsx(GetGas_default, { tokenInfo: toTokenInfo, onToggle: refetchQuote, config }),
     /* @__PURE__ */ jsx(
       FormButton,
       {
@@ -8834,7 +9797,9 @@ var FormBody = ({
         currentRequestId: quoteInfo.request_id,
         clearLockedRequestId,
         lockedRequestId,
-        getQuote
+        getQuote,
+        skipEvmWalletConnect: !toTokenInfo.isSolana && !!config?.evmDifferentAddress,
+        skipSolanaWalletConnect: toTokenInfo.isSolana && !!config?.solanaDifferentAddress
       }
     ),
     /* @__PURE__ */ jsx(
@@ -8911,7 +9876,7 @@ var SlippageSettings = ({ refetchQuote }) => {
     [fromTokenInfo, toTokenInfo, chains]
   );
   const isStablecoinPair = useMemo(
-    () => isStablecoin2(fromTokenInfo) && isStablecoin2(toTokenInfo),
+    () => isStablecoin(fromTokenInfo) && isStablecoin(toTokenInfo),
     [fromTokenInfo, toTokenInfo]
   );
   const isSameChain = useMemo(
@@ -9789,6 +10754,11 @@ var TxState = ({
     }
   }, [isError]);
   useEffect(() => {
+    if (timeOut && isTransactionBlocked) {
+      topToaster.error({
+        description: `This transaction is stuck on the source network. Please go to the wallet's activity section to speed up or cancel the transaction.`
+      });
+    }
   }, [isTransactionBlocked, timeOut]);
   useEffect(() => {
     if (isSolanaTransaction && solanaFromTxHash) {
@@ -10461,7 +11431,7 @@ var TxState = ({
   ) });
 };
 async function getOrderHistory(address, offset = 0, limit = 4) {
-  const url = `${BASE_API_URL}/v1/orders`;
+  const url = `${getBaseApiUrl()}/v1/orders`;
   const res = await axios6.get(url, {
     params: {
       address: Array.isArray(address) ? address : [address],
@@ -10897,10 +11867,10 @@ var MainForm = ({ config }) => {
   }, [fromTokenInfo.isSolana, solanaWalletAddress, address]);
   const toAddress = useMemo(() => {
     if (toTokenInfo.isSolana) {
-      return solanaWalletAddress || "";
+      return config?.solanaDifferentAddress || solanaWalletAddress || "";
     }
-    return differentAddress || address || "";
-  }, [toTokenInfo.isSolana, solanaWalletAddress, differentAddress, address]);
+    return config?.evmDifferentAddress || differentAddress || address || "";
+  }, [toTokenInfo.isSolana, solanaWalletAddress, differentAddress, address, config?.solanaDifferentAddress, config?.evmDifferentAddress]);
   useEffect(() => {
     if (timerRef.current && (new Fraction(fromAmount).eq(0) || fromTxHash || solanaFromTxHash || address)) {
       clearTimeout(timerRef.current);
@@ -11179,7 +12149,8 @@ var MainForm = ({ config }) => {
         affiliation: vCode,
         slippage: isAutoSlippage ? slippageValue && slippageValue !== "0" ? calculateSlippage(slippageValue) : slippageValue === "0" ? 0 : void 0 : calculateSlippage(slippageValue || slippage?.value),
         toTokenDecimals: toTokenInfo.decimals,
-        to_platform_id: toTokenInfo.platform_id || 0
+        to_platform_id: toTokenInfo.platform_id || 0,
+        sponsor_gas: useGetGasStore.getState().sponsorGas
       });
     },
     [
@@ -11426,6 +12397,6 @@ var MainForm = ({ config }) => {
 };
 var WheelXWidget = MainForm;
 
-export { WheelXProvider, WheelXWidget, WidgetThemeProvider, defaultTheme, getChainsAndTokens, mergeTokensWithCompositeKey, useChainsAndTokens, useChainsStore, useDifferentAddressStore, useEvmAddress, useGuardChain, useInitSwapAndBridgeState, useRefreshLoading, useResetSwapAndBridgeState, useSwapAndBridgeContextStore, useSyncWalletConnectedStore, useTokenBalance2 as useTokenBalance, useTokensStore, useTxStateContextStore, useWalletConnectedStore, useWidgetTheme };
+export { KNOWN_WALLET_UNIVERSAL_LINKS, WheelXProvider, WheelXWidget, WidgetThemeProvider, convertToDeepLink, defaultTheme, getChainsAndTokens, isDeepLinkUrl, isMobileDevice, isReactNativeWebView, isWalletRelatedUrl, isWebView, mergeTokensWithCompositeKey, shouldInterceptDeepLinks, useChainsAndTokens, useChainsStore, useDifferentAddressStore, useEvmAddress, useGuardChain, useInitSwapAndBridgeState, useRefreshLoading, useResetSwapAndBridgeState, useSwapAndBridgeContextStore, useSyncWalletConnectedStore, useTokenBalance2 as useTokenBalance, useTokensStore, useTxStateContextStore, useWalletConnectedStore, useWidgetTheme };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map