@0xsquid/react-hooks 8.0.1-tanstack-v5-beta.0 → 8.0.2

package/dist/{index-BA79s7uI.js → index-BKmIOD3t.js}

@@ -1,7 +1,7 @@
 import { ChainType, ActionType, SquidDataType, BridgeType, BridgeProvider, FeeType } from '@0xsquid/squid-types';
 import { zeroAddress as zeroAddress$1, parseUnits, formatUnits, isAddress, SwitchChainError, UserRejectedRequestError, erc20Abi, defineChain } from 'viem';
 import React, { useMemo, useCallback, useState, useEffect, createContext, useContext, useRef } from 'react';
-import { useQuery, useMutation, useQueryClient, useQueries, QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { useQuery, useMutation, useQueries, useQueryClient, QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { fromBech32 } from '@cosmjs/encoding';
 import * as bitcoin from 'bitcoinjs-lib';
 import { address } from 'bitcoinjs-lib';
@@ -3981,6 +3981,20 @@ class WidgetEvents extends EventTarget {
     constructor() {
         super();
     }
+    getRouteEventPayload = (route, txHash) => {
+        const { fromAddress, toAddress, fromChain, toChain, fromToken, toToken, fromAmount, } = route.params;
+        return {
+            fromAddress,
+            toAddress,
+            fromChain,
+            toChain,
+            fromToken,
+            toToken,
+            fromAmount,
+            quoteId: route.quoteId,
+            txHash,
+        };
+    };
     // Singleton, because we need to access this service outside the widget
     static getInstance() {
         if (!WidgetEvents.instance) {
@@ -4031,7 +4045,7 @@ class WidgetEvents extends EventTarget {
      * @param route
      */
     dispatchSwapExecuteCall(route, txHash) {
-        this.dispatch("swap", { route, txHash });
+        this.dispatch("swap", this.getRouteEventPayload(route, txHash));
     }
     /**
      * Dispatch event when user changes chain/token
@@ -4110,7 +4124,18 @@ class WidgetEvents extends EventTarget {
      * @param data Quote execution parameters
      */
     dispatchOnrampQuoteExecute(data) {
-        this.dispatch("onrampQuoteExecute", data);
+        this.dispatch("onrampQuoteExecute", {
+            tokenAddress: data.squidToken?.address,
+            tokenChainId: data.squidToken?.chainId,
+            amount: data.cryptoAmount,
+            paymentMethod: data.paymentMethod,
+            walletAddress: data.walletAddress,
+            orderId: data.orderId,
+            fiatCurrency: data.fiatCurrency,
+            cryptoCurrencyID: data.cryptoCurrencyID,
+            region: data.region,
+            onrampProviderId: data.onrampProviderId,
+        });
     }
     /**
      * Dispatch event when the search query has no results
@@ -26795,9 +26820,7 @@ const fetchHighestBalanceToken = (fetchCachedBalance, chainId) => {
     if (fetchCachedBalance) {
         const queryCache = fetchCachedBalance?.queryClient?.getQueryCache();
         // get cached balance from key
-        const cache = queryCache?.find({
-            queryKey: keys().allTokensBalance(fetchCachedBalance?.address, !isNaN(Number(chainId)) ? ChainType.EVM : ChainType.COSMOS),
-        });
+        const cache = queryCache?.find(keys().allTokensBalance(fetchCachedBalance?.address, !isNaN(Number(chainId)) ? ChainType.EVM : ChainType.COSMOS));
         // Parse result to TokenWithBalance[]
         const cacheResult = cache?.state.data ?? [];
         if (cacheResult.length > 0) {
@@ -27453,7 +27476,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await import('./secretService-D3MB_TMv.js');
+    const { fetchAllSecretBalances } = await import('./secretService-C2TxPa-m.js');
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -29212,16 +29235,13 @@ const useSquid = () => {
      * Fetch squid info
      * Will refetch every minute
      */
-    const squidInfoQuery = useQuery({
-        queryKey: keys().squidInfo(),
-        queryFn: async () => {
-            if (squid) {
-                await squid?.init();
-                initializeSquidWithAssetsColors(squid, assetsColors);
-                return squid;
-            }
-            return null;
+    const squidInfoQuery = useQuery(keys().squidInfo(), async () => {
+        if (squid) {
+            await squid?.init();
+            initializeSquidWithAssetsColors(squid, assetsColors);
+            return squid;
         }
+        return null;
     });
     const tokens = useMemo(() => {
         if ((squidInfoQuery?.data?.tokens ?? []).length > 0) {
@@ -29337,11 +29357,47 @@ const FINAL_TRANSACTION_STATUSES = [
     "completed",
     "failed",
 ];
+/**
+ * Configuration for transaction status tracking
+ */
+const createTransactionStatusConfig = ({ transactionId, walletAddress, providerId, replaceTransactionStatus, }) => {
+    return {
+        queryKey: keys().fiatToCryptoStatus(transactionId),
+        queryFn: () => new OnrampService().getTransactionStatus(transactionId, walletAddress, providerId),
+        enabled: !!transactionId && !!walletAddress && !!providerId,
+        retry: TX_STATUS_CONSTANTS.RETRY_COUNT,
+        retryDelay: TX_STATUS_CONSTANTS.RETRY_DELAY,
+        refetchInterval: (data) => {
+            if (data?.status && FINAL_TRANSACTION_STATUSES.includes(data.status)) {
+                return false;
+            }
+            return TX_STATUS_CONSTANTS.REFETCH_INTERVAL;
+        },
+        onSuccess: (data) => {
+            if (data) {
+                replaceTransactionStatus({
+                    txType: HistoryTxType.BUY,
+                    orderId: transactionId,
+                    status: data.status,
+                    transactionHash: data.transactionHash,
+                });
+            }
+        },
+        onError: () => {
+            replaceTransactionStatus({
+                txType: HistoryTxType.BUY,
+                orderId: transactionId,
+                status: "failed",
+                transactionHash: undefined,
+            });
+        },
+    };
+};
 /**
  * Fetches quotes for fiat to crypto conversion with provider details.
  * Returns available rates, fees, and supported payment methods for the conversion.
  */
-const useGetFiatQuote = ({ fiatCurrency, cryptoCurrencyID, amount, region, paymentMethod, enabled = true, }) => {
+const useGetFiatQuote = ({ fiatCurrency, cryptoCurrencyID, amount, region, paymentMethod, enabled = true, onSuccess, }) => {
     const service = useMemo(() => new OnrampService(), []);
     const { data: config } = useGetOnRampConfig();
     return useQuery({
@@ -29377,6 +29433,7 @@ const useGetFiatQuote = ({ fiatCurrency, cryptoCurrencyID, amount, region, payme
             return quoteResponse;
         },
         enabled: enabled && !!fiatCurrency && !!cryptoCurrencyID && amount > 0,
+        onSuccess,
     });
 };
 /**
@@ -29393,7 +29450,7 @@ const useGetOnRampConfig = () => {
             chains,
             tokens,
         }),
-        gcTime: 1000 * 60 * 60,
+        cacheTime: 1000 * 60 * 60,
         staleTime: 1000 * 60 * 30, // 30 minutes
     });
 };
@@ -29451,11 +29508,49 @@ const useExecuteFiatQuote = () => {
         },
     });
 };
+/**
+ * Tracks the status of a single fiat to crypto transaction.
+ */
+const useFiatOnRampTxStatus = (transactionId, walletAddress, providerId) => {
+    const replaceTransactionStatus = useHistoryStore((state) => state.replaceTransactionStatus);
+    return useQuery({
+        ...createTransactionStatusConfig({
+            transactionId,
+            walletAddress,
+            providerId,
+            replaceTransactionStatus,
+        }),
+    });
+};
+/**
+ * Tracks all pending fiat transactions.
+ */
+const useFiatTransactions = () => {
+    const transactions = useHistoryStore((state) => state.transactions.filter((tx) => tx.txType === HistoryTxType.BUY));
+    const replaceTransactionStatus = useHistoryStore((state) => state.replaceTransactionStatus);
+    const pendingTransactions = useMemo(() => transactions?.filter((tx) => !FINAL_TRANSACTION_STATUSES.includes(tx.data.status)) ?? [], [transactions]);
+    const queries = useQueries({
+        queries: pendingTransactions.map((tx) => ({
+            ...createTransactionStatusConfig({
+                transactionId: tx.data.orderId,
+                walletAddress: tx.data.toAddress,
+                providerId: tx.data.providerId,
+                replaceTransactionStatus,
+            }),
+        })),
+    });
+    return {
+        transactions: transactions.map((tx) => tx.data),
+        isLoading: queries.some((q) => q.isLoading),
+        isError: queries.some((q) => q.isError),
+    };
+};
 /**
  * Gets currency details including symbol and limits.
  * Example: USD → { symbol: "$", name: "US Dollar", ... }
  */
 const useCurrencyDetails = (currencyCode) => {
+    const { data: config } = useGetOnRampConfig();
     return useMemo(() => {
         if (!currencyCode)
             return undefined;
@@ -29468,7 +29563,7 @@ const useCurrencyDetails = (currencyCode) => {
             };
         }
         return undefined;
-    }, [currencyCode]);
+    }, [currencyCode, config?.supportedFiats]);
 };
 /**
  * Gets country details with flag URL and localized name.
@@ -29495,6 +29590,23 @@ const useAvailableQuotes = (quotes) => {
         return uniqueQuotes;
     }, [quotes]);
 };
+/**
+ * Gets the recommended quote based on best rates or provider preferences.
+ * Falls back to first available quote if no specific recommendation.
+ */
+const useRecommendedQuote = (quotes, recommendedQuote) => {
+    const availableQuotes = useAvailableQuotes(quotes);
+    return useMemo(() => {
+        if (!availableQuotes.length)
+            return undefined;
+        if (!recommendedQuote)
+            return availableQuotes[0];
+        // Try to find the recommended quote among available quotes
+        const recommendedAvailableQuote = availableQuotes.find((quote) => quote.onrampProviderId === recommendedQuote.onrampProviderId);
+        // If recommended quote is not available, return first available quote
+        return recommendedAvailableQuote ?? availableQuotes[0];
+    }, [availableQuotes, recommendedQuote]);
+};
 /**
  * Fetches the available payment methods for a given fiat and crypto currency pair.
  * The first item in the returned array is the most recommended.
@@ -29597,7 +29709,7 @@ const middleStepChecker = (statusResponse) => {
         }
         return TransactionStatus.ERROR;
     }
-    if (statusResponse?.isLoading) {
+    if (statusResponse?.isInitialLoading) {
         return TransactionStatus.INITIAL_LOADING;
     }
     return TransactionStatus.ONGOING;
@@ -30042,7 +30154,7 @@ const useClient = () => {
         queryFn: getUserCountry,
         enabled: isClient,
         retry: false,
-        gcTime: CACHE_TIME,
+        cacheTime: CACHE_TIME,
         staleTime: STALE_TIME,
     });
     const userCountry = countryData?.countryCode || DEFAULT_COUNTRY_CODE;
@@ -30143,13 +30255,11 @@ function useDebouncedValue(value, delay) {
  * @returns the ENS data of the given address
  */
 function useEnsDataForAddress({ address, options, }) {
-    const ensQuery = useQuery({
-        queryKey: keys().ensData(address?.toLowerCase()),
-        queryFn: () => EnsService.getEnsDataFromAddress(address),
+    const ensQuery = useQuery(keys().ensData(address?.toLowerCase()), () => EnsService.getEnsDataFromAddress(address), {
         ...options,
         enabled: Boolean(address?.trim()) &&
             (options?.enabled === undefined ? true : options.enabled),
-        gcTime: Infinity,
+        cacheTime: Infinity,
     });
     return ensQuery;
 }
@@ -30165,16 +30275,14 @@ function useEnsDataForAddress({ address, options, }) {
  */
 function useEnsSearch({ name, enabled = true, delayMs = 500, }) {
     const debouncedName = useDebouncedValue(enabled ? name : undefined, delayMs);
-    const ensSearchQuery = useQuery({
-        queryKey: keys().ensSearch(debouncedName),
-        queryFn: () => {
-            const isExactEnsSearch = checkIsExactEns(debouncedName);
-            return isExactEnsSearch
-                ? EnsService.getExactEns(debouncedName)
-                : EnsService.searchEnsNames(debouncedName);
-        },
+    const ensSearchQuery = useQuery(keys().ensSearch(debouncedName), () => {
+        const isExactEnsSearch = checkIsExactEns(debouncedName);
+        return isExactEnsSearch
+            ? EnsService.getExactEns(debouncedName)
+            : EnsService.searchEnsNames(debouncedName);
+    }, {
         enabled: Boolean(debouncedName?.trim()) && enabled,
-        gcTime: Infinity,
+        cacheTime: Infinity,
     });
     return ensSearchQuery;
 }
@@ -30195,25 +30303,23 @@ function checkIsExactEns(name = "") {
 
 const useCosmosForChain = (chain) => {
     const { keplrTypeWallet } = useCosmosSigner({ chain });
-    const cosmosAddressQuery = useQuery({
-        queryKey: keys().cosmosAddress(chain?.chainId),
-        queryFn: async () => {
-            if (!chain || !keplrTypeWallet)
-                return "";
-            try {
-                const address = await getCosmosKey(chain.chainId, keplrTypeWallet);
-                return address ?? "";
-            }
-            catch (error) {
-                await suggestChainOrThrow({
-                    chain: chain,
-                    error,
-                    keplrTypeWallet,
-                });
-                const address = await getCosmosKey(chain.chainId, keplrTypeWallet);
-                return address ?? "";
-            }
-        },
+    const cosmosAddressQuery = useQuery(keys().cosmosAddress(chain?.chainId), async () => {
+        if (!chain || !keplrTypeWallet)
+            return "";
+        try {
+            const address = await getCosmosKey(chain.chainId, keplrTypeWallet);
+            return address ?? "";
+        }
+        catch (error) {
+            await suggestChainOrThrow({
+                chain: chain,
+                error,
+                keplrTypeWallet,
+            });
+            const address = await getCosmosKey(chain.chainId, keplrTypeWallet);
+            return address ?? "";
+        }
+    }, {
         enabled: !!keplrTypeWallet && chain?.chainType === ChainType.COSMOS,
     });
     return cosmosAddressQuery;
@@ -30290,14 +30396,12 @@ const useIsSameAddressAndGnosisContext = () => {
 
 function useBitcoin() {
     const connectedBitcoinWallet = useWalletStore((store) => store.connectedWalletsByChainType[ChainType.BTC]);
-    const connectBitcoin = useMutation({
-        mutationFn: async ({ wallet, }) => {
-            const { address } = await wallet.connector.requestAccount();
-            return {
-                wallet,
-                address,
-            };
-        }
+    const connectBitcoin = useMutation(async ({ wallet, }) => {
+        const { address } = await wallet.connector.requestAccount();
+        return {
+            wallet,
+            address,
+        };
     });
     return {
         connectBitcoin,
@@ -30337,17 +30441,15 @@ function useEvm() {
     const { wallets } = useEvmWallets();
     const connectedEvmWallet = useWalletStore((store) => store.connectedWalletsByChainType[ChainType.EVM]);
     const recentEvmWalletId = useWalletStore((store) => store.recentConnectorIds[ChainType.EVM]);
-    const connectEvm = useMutation({
-        mutationFn: async ({ wallet, }) => {
-            const result = await connectAsync({
-                connector: wallet.connector,
-            });
-            const [firstAddress] = result.accounts;
-            return {
-                wallet,
-                address: firstAddress,
-            };
-        }
+    const connectEvm = useMutation(async ({ wallet, }) => {
+        const result = await connectAsync({
+            connector: wallet.connector,
+        });
+        const [firstAddress] = result.accounts;
+        return {
+            wallet,
+            address: firstAddress,
+        };
     });
     const disconnectEvm = useCallback(async () => {
         disconnect({ connector: connectedEvmWallet.wallet?.connector });
@@ -30441,23 +30543,21 @@ function useSolana() {
     const { wallets } = useSolanaWallets();
     const connectedSolanaWallet = useWalletStore((store) => store.connectedWalletsByChainType[ChainType.SOLANA]);
     const recentSolanaWalletId = useWalletStore((store) => store.recentConnectorIds[ChainType.SOLANA]);
-    const connectSolana = useMutation({
-        mutationFn: async ({ wallet, }) => {
-            try {
-                // try to connect silently first
-                await wallet.connector.autoConnect();
-            }
-            catch {
-                // if auto-connect fails (e.g. not authorized yet)
-                // fallback to connect via popup
-                await wallet.connector.connect();
-            }
-            const address = wallet.connector.wallet.accounts[0].address;
-            return {
-                wallet,
-                address,
-            };
+    const connectSolana = useMutation(async ({ wallet, }) => {
+        try {
+            // try to connect silently first
+            await wallet.connector.autoConnect();
+        }
+        catch {
+            // if auto-connect fails (e.g. not authorized yet)
+            // fallback to connect via popup
+            await wallet.connector.connect();
         }
+        const address = wallet.connector.wallet.accounts[0].address;
+        return {
+            wallet,
+            address,
+        };
     });
     const disconnectSolana = useCallback(async () => {
         await connectedSolanaWallet.wallet?.connector.disconnect();
@@ -30532,7 +30632,7 @@ function useStellarWallets() {
                 return;
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
-                const { formatStellarWallet } = await import('./stellarService.client-Dp4tvmUo.js');
+                const { formatStellarWallet } = await import('./stellarService.client-deOQBP3h.js');
                 const modules = initializeAllModules();
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -30560,14 +30660,12 @@ function useStellarWallets() {
 function useStellar() {
     const { wallets } = useStellarWallets();
     const connectedStellarWallet = useWalletStore((store) => store.connectedWalletsByChainType[ChainType.STELLAR]);
-    const connectStellar = useMutation({
-        mutationFn: async ({ wallet, }) => {
-            const { address } = await wallet.connector.getAddress();
-            return {
-                wallet,
-                address,
-            };
-        }
+    const connectStellar = useMutation(async ({ wallet, }) => {
+        const { address } = await wallet.connector.getAddress();
+        return {
+            wallet,
+            address,
+        };
     });
     const disconnectStellar = useCallback(async () => {
         await connectedStellarWallet.wallet?.connector.disconnect?.();
@@ -30619,24 +30717,22 @@ function useSui() {
     const recentSuiWalletId = useWalletStore((store) => store.recentConnectorIds[ChainType.SUI]);
     const setConnectedWallet = useWalletStore((store) => store.setConnectedWallet);
     const disconnectWallet = useWalletStore((store) => store.disconnectWallet);
-    const connectSui = useMutation({
-        mutationFn: async ({ wallet, }) => {
-            let account;
-            try {
-                // try to connect silently first
-                account = await wallet.connector.connect({ silent: true });
-            }
-            catch {
-                // if auto-connect fails (e.g. not authorized yet)
-                // fallback to connect via popup
-                account = await wallet.connector.connect();
-            }
-            return {
-                wallet,
-                address: account.account.address,
-                account: account.account,
-            };
+    const connectSui = useMutation(async ({ wallet, }) => {
+        let account;
+        try {
+            // try to connect silently first
+            account = await wallet.connector.connect({ silent: true });
         }
+        catch {
+            // if auto-connect fails (e.g. not authorized yet)
+            // fallback to connect via popup
+            account = await wallet.connector.connect();
+        }
+        return {
+            wallet,
+            address: account.account.address,
+            account: account.account,
+        };
     });
     const disconnectSui = useCallback(async () => {
         await connectedSuiWallet.wallet?.connector.disconnect();
@@ -30945,14 +31041,12 @@ function useXrpl() {
     const recentXrplWalletId = useWalletStore((store) => store.recentConnectorIds[ChainType.XRPL]);
     const setConnectedWallet = useWalletStore((store) => store.setConnectedWallet);
     const disconnectWallet = useWalletStore((store) => store.disconnectWallet);
-    const connectXrpl = useMutation({
-        mutationFn: async ({ wallet, }) => {
-            const xrplConnectedAddress = await wallet.connector.connect();
-            return {
-                wallet,
-                address: xrplConnectedAddress,
-            };
-        }
+    const connectXrpl = useMutation(async ({ wallet, }) => {
+        const xrplConnectedAddress = await wallet.connector.connect();
+        return {
+            wallet,
+            address: xrplConnectedAddress,
+        };
     });
     const disconnectXrpl = useCallback(async () => {
         await connectedXrplWallet?.wallet?.connector.disconnect?.();
@@ -31339,19 +31433,18 @@ const useMultiChainWallet = (chain) => {
     /**
      * Change current network for desired chain
      */
-    const changeNetworkIfNeeded = useMutation({
-        mutationFn: async () => {
-            const isNotOnDesiredChain = chain?.chainType === ChainType.EVM &&
-                currentEvmChain?.id !== Number(chain.chainId);
-            if (isNotOnDesiredChain) {
-                await switchChainAsync({
-                    chainId: Number(chain.chainId),
-                });
-            }
-            // Implement keplr change network
-            // Looks like there are no method to do that at the moment
-            return false;
-        },
+    const changeNetworkIfNeeded = useMutation(async () => {
+        const isNotOnDesiredChain = chain?.chainType === ChainType.EVM &&
+            currentEvmChain?.id !== Number(chain.chainId);
+        if (isNotOnDesiredChain) {
+            await switchChainAsync({
+                chainId: Number(chain.chainId),
+            });
+        }
+        // Implement keplr change network
+        // Looks like there are no method to do that at the moment
+        return false;
+    }, {
         onError: async (error) => {
             if (error instanceof UserRejectedRequestError) {
                 return;
@@ -31363,7 +31456,7 @@ const useMultiChainWallet = (chain) => {
                     provider,
                 });
             }
-        }
+        },
     });
     const isChainTypeConnected = useCallback((chainType) => {
         if (isGnosisConnected && chainType === ChainType.EVM) {
@@ -31711,53 +31804,51 @@ const useCosmos = () => {
             clientWindow?.removeEventListener("keplr_keystorechange", () => handleKeplrAccountChanged());
         };
     }, [handleKeplrAccountChanged, clientWindow]);
-    const connectCosmos = useMutation({
-        mutationFn: async ({ chain, wallet, approveAllChains = true, }) => {
-            const chainInfos = getCosmosChainInfosObject(chain);
-            const cosmosWalletObject = wallet.connector().provider;
-            if (cosmosWalletObject) {
-                setCosmosChainId(chainInfos.chainId.toString());
-                try {
-                    if (approveAllChains &&
-                        typeof cosmosWalletObject.getChainInfosWithoutEndpoints ===
-                            "function") {
-                        try {
-                            const addedChains = await cosmosWalletObject.getChainInfosWithoutEndpoints();
-                            const addedChainIds = addedChains?.map((addedChain) => addedChain.chainId);
-                            const chainsToEnable = cosmosChains
-                                .filter((c) => addedChainIds?.includes(c.chainId.toString()))
-                                .map((c) => c.chainId.toString());
-                            await cosmosWalletObject.enable(chainsToEnable);
-                        }
-                        catch (error) {
-                            console.warn("Failed to get chain infos, falling back to single chain enable", error);
-                            await cosmosWalletObject.enable(chainInfos.chainId);
-                        }
+    const connectCosmos = useMutation(async ({ chain, wallet, approveAllChains = true, }) => {
+        const chainInfos = getCosmosChainInfosObject(chain);
+        const cosmosWalletObject = wallet.connector().provider;
+        if (cosmosWalletObject) {
+            setCosmosChainId(chainInfos.chainId.toString());
+            try {
+                if (approveAllChains &&
+                    typeof cosmosWalletObject.getChainInfosWithoutEndpoints ===
+                        "function") {
+                    try {
+                        const addedChains = await cosmosWalletObject.getChainInfosWithoutEndpoints();
+                        const addedChainIds = addedChains?.map((addedChain) => addedChain.chainId);
+                        const chainsToEnable = cosmosChains
+                            .filter((c) => addedChainIds?.includes(c.chainId.toString()))
+                            .map((c) => c.chainId.toString());
+                        await cosmosWalletObject.enable(chainsToEnable);
                     }
-                    else {
+                    catch (error) {
+                        console.warn("Failed to get chain infos, falling back to single chain enable", error);
                         await cosmosWalletObject.enable(chainInfos.chainId);
                     }
-                    const address = await getAddress({
-                        chainId: chain.chainId.toString(),
-                        cosmosWalletObject,
-                        wallet,
-                    });
-                    if (address) {
-                        updateWalletStore(wallet, cosmosWalletObject, address);
-                        return address;
-                    }
                 }
-                catch (error) {
-                    await suggestChainOrThrow({
-                        chain,
-                        error,
-                        keplrTypeWallet: cosmosWalletObject,
-                    });
-                    return connectCosmos.mutateAsync({ chain, wallet });
+                else {
+                    await cosmosWalletObject.enable(chainInfos.chainId);
+                }
+                const address = await getAddress({
+                    chainId: chain.chainId.toString(),
+                    cosmosWalletObject,
+                    wallet,
+                });
+                if (address) {
+                    updateWalletStore(wallet, cosmosWalletObject, address);
+                    return address;
                 }
             }
-            return undefined;
+            catch (error) {
+                await suggestChainOrThrow({
+                    chain,
+                    error,
+                    keplrTypeWallet: cosmosWalletObject,
+                });
+                return connectCosmos.mutateAsync({ chain, wallet });
+            }
         }
+        return undefined;
     });
     const clearData = () => {
         disconnectWallet(ChainType.COSMOS);
@@ -31841,64 +31932,13 @@ function useTrackSearchEmpty({ searchQuery, resultsLength, context, debounceMs =
     }, [context, debounceMs, resultsLength, searchQuery]);
 }
 
-const useKeyboardNavigation = (props) => {
-    const { itemsListRef, activeListItemClassName = "", onEscape } = props ?? {};
+const useKeyboardNavigation = ({ onEscape }) => {
     const onKeyDown = useCallback((event) => {
         if (event.key === "Escape") {
             onEscape?.();
             return;
         }
-        if (activeListItemClassName.trim() === "")
-            return;
-        const itemsList = itemsListRef?.current;
-        const separatedActiveItemClassNames = activeListItemClassName.split(" ");
-        const defaultActiveItem = itemsList?.querySelector(`.${separatedActiveItemClassNames.join(".")}`);
-        if (event.key === "ArrowUp") {
-            if (!itemsList)
-                return;
-            event.preventDefault();
-            const activeItem = defaultActiveItem ?? itemsList.lastElementChild;
-            if (!activeItem)
-                return;
-            const previousItem = activeItem.previousElementSibling;
-            if (previousItem) {
-                activeItem.classList.remove(...separatedActiveItemClassNames);
-                previousItem.classList.add(...separatedActiveItemClassNames);
-                // scroll to previous item
-                itemsList.scrollTo({
-                    top: (previousItem.offsetTop ?? 0) -
-                        itemsList.clientHeight,
-                    behavior: "smooth",
-                });
-            }
-        }
-        else if (event.key === "ArrowDown") {
-            if (!itemsList)
-                return;
-            event.preventDefault();
-            const activeItem = defaultActiveItem ?? itemsList.firstElementChild;
-            if (!activeItem)
-                return;
-            const nextItem = activeItem.nextElementSibling;
-            if (nextItem) {
-                activeItem.classList.remove(...separatedActiveItemClassNames);
-                nextItem.classList.add(...separatedActiveItemClassNames);
-                // scroll to next item
-                itemsList.scrollTo({
-                    top: (nextItem.offsetTop ?? 0) -
-                        itemsList.clientHeight,
-                    behavior: "smooth",
-                });
-            }
-        }
-        else if (event.key === "Enter") {
-            event.preventDefault();
-            if (defaultActiveItem) {
-                // select active item
-                defaultActiveItem.querySelector("button")?.click();
-            }
-        }
-    }, [itemsListRef, activeListItemClassName]);
+    }, [onEscape]);
     useEffect(() => {
         document.addEventListener("keydown", onKeyDown, false);
         return () => {
@@ -31911,11 +31951,11 @@ const useSquidQueryClient = () => {
     const queryClient = useQueryClient();
     const invalidateQueries = (key) => {
         const prefixKey = getPrefixKey(key);
-        queryClient.invalidateQueries({ queryKey: prefixKey });
+        queryClient.invalidateQueries(prefixKey);
     };
     const refetchQueries = (key) => {
         const prefixKey = getPrefixKey(key);
-        queryClient.refetchQueries({ queryKey: prefixKey });
+        queryClient.refetchQueries(prefixKey);
     };
     const invalidateAndRefetchQueries = (key) => {
         invalidateQueries(key);
@@ -33422,19 +33462,17 @@ function useDepositAddress(squidRoute) {
         toggleDepositFlow(false);
         setDeposit(null);
     }, [toggleDepositFlow, setDeposit]);
-    const getRouteWithDeposit = useMutation({
-        mutationFn: async ({ route }) => {
-            if (!squid)
-                throw new Error("Squid SDK not initialized");
-            const depositAddressResponse = (await squid.executeRoute({
-                signer: {},
-                route,
-            }));
-            setDeposit(depositAddressResponse);
-            return {
-                depositAddress: depositAddressResponse,
-            };
-        }
+    const getRouteWithDeposit = useMutation(async ({ route }) => {
+        if (!squid)
+            throw new Error("Squid SDK not initialized");
+        const depositAddressResponse = (await squid.executeRoute({
+            signer: {},
+            route,
+        }));
+        setDeposit(depositAddressResponse);
+        return {
+            depositAddress: depositAddressResponse,
+        };
     });
     return {
         isEnabled,
@@ -33518,55 +33556,53 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         xrplTokens.length,
         stellarTokens.length,
     ]);
-    const query = useQuery({
-        queryKey: keys().allTokensBalance(address, chainType, direction),
-        queryFn: async () => {
-            // Return zero balances if no address
-            if (!address) {
-                const defaultTokens = placeholderData.tokens;
-                return {
-                    tokens: defaultTokens,
-                    totalUsdBalance: calculateTotalUsdBalanceUSD(defaultTokens),
-                };
-            }
-            let fetchedTokens = [];
-            // Fetch tokens based on chain type
-            switch (chainType) {
-                case ChainType.EVM:
-                    fetchedTokens = await getAllEvmTokensBalance(evmTokens, address, evmChains);
-                    break;
-                case ChainType.COSMOS:
-                    const addresses = await getAllKeysForSupportedCosmosChains(cosmosChains.map((c) => c.chainId), keplrTypeWallet);
-                    fetchedTokens = await getAllCosmosBalances({
-                        addresses,
-                        cosmosChains,
-                        cosmosTokens,
-                    });
-                    break;
-                case ChainType.SOLANA:
-                    fetchedTokens = await getAllSolanaTokensBalance(solanaTokens, address);
-                    break;
-                case ChainType.BTC:
-                    fetchedTokens = await getAllBitcoinTokensBalance(address, bitcoinTokens);
-                    break;
-                case ChainType.SUI:
-                    fetchedTokens = await getAllSuiTokensBalance(address, suiTokens, suiChains);
-                    break;
-                case ChainType.XRPL:
-                    fetchedTokens = await getAllXrplTokensBalance(address, xrplTokens, xrplChains);
-                    break;
-                case ChainType.STELLAR:
-                    fetchedTokens = await getAllStellarTokensBalance(address, stellarTokens, stellarChains);
-                    break;
-                default:
-                    fetchedTokens = placeholderData.tokens;
-                    break;
-            }
+    const query = useQuery(keys().allTokensBalance(address, chainType, direction), async () => {
+        // Return zero balances if no address
+        if (!address) {
+            const defaultTokens = placeholderData.tokens;
             return {
-                tokens: fetchedTokens,
-                totalUsdBalance: calculateTotalUsdBalanceUSD(fetchedTokens),
+                tokens: defaultTokens,
+                totalUsdBalance: calculateTotalUsdBalanceUSD(defaultTokens),
             };
-        },
+        }
+        let fetchedTokens = [];
+        // Fetch tokens based on chain type
+        switch (chainType) {
+            case ChainType.EVM:
+                fetchedTokens = await getAllEvmTokensBalance(evmTokens, address, evmChains);
+                break;
+            case ChainType.COSMOS:
+                const addresses = await getAllKeysForSupportedCosmosChains(cosmosChains.map((c) => c.chainId), keplrTypeWallet);
+                fetchedTokens = await getAllCosmosBalances({
+                    addresses,
+                    cosmosChains,
+                    cosmosTokens,
+                });
+                break;
+            case ChainType.SOLANA:
+                fetchedTokens = await getAllSolanaTokensBalance(solanaTokens, address);
+                break;
+            case ChainType.BTC:
+                fetchedTokens = await getAllBitcoinTokensBalance(address, bitcoinTokens);
+                break;
+            case ChainType.SUI:
+                fetchedTokens = await getAllSuiTokensBalance(address, suiTokens, suiChains);
+                break;
+            case ChainType.XRPL:
+                fetchedTokens = await getAllXrplTokensBalance(address, xrplTokens, xrplChains);
+                break;
+            case ChainType.STELLAR:
+                fetchedTokens = await getAllStellarTokensBalance(address, stellarTokens, stellarChains);
+                break;
+            default:
+                fetchedTokens = placeholderData.tokens;
+                break;
+        }
+        return {
+            tokens: fetchedTokens,
+            totalUsdBalance: calculateTotalUsdBalanceUSD(fetchedTokens),
+        };
+    }, {
         ...queryOptions,
         enabled: isQueryEnabled,
     });
@@ -33581,7 +33617,7 @@ const BALANCE_STALE_TIME = 60000; // 1 minute
 const BALANCE_CACHE_TIME = 300000; // 5 minutes
 const useAllConnectedWalletBalances = ({ direction, queryOptions = {
     staleTime: BALANCE_STALE_TIME,
-    gcTime: BALANCE_CACHE_TIME,
+    cacheTime: BALANCE_CACHE_TIME,
     refetchOnWindowFocus: true,
     refetchOnMount: true,
 }, } = {}) => {
@@ -33662,9 +33698,9 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
     }, [balanceQueries]);
     // Aggregate loading states
     const queryStates = useMemo(() => ({
-        isLoading: Object.values(balanceQueries).some((q) => q.isLoading),
+        isInitialLoading: Object.values(balanceQueries).some((q) => q.isInitialLoading),
         isFetching: Object.values(balanceQueries).some((q) => q.isFetching),
-        isPending: Object.values(balanceQueries).some((q) => q.isPending),
+        isLoading: Object.values(balanceQueries).some((q) => q.isLoading),
         isRefetching: Object.values(balanceQueries).some((q) => q.isRefetching),
         isError: Object.values(balanceQueries).some((q) => q.isError),
         isSuccess: Object.values(balanceQueries).every((q) => q.isSuccess),
@@ -33706,7 +33742,7 @@ function useNativeTokenForChain(chain) {
 
 const useEvmNativeBalance = ({ address, chain, }) => {
     const { isChainTypeConnected } = useWallet();
-    const { data: nativeEvmBalance, isPending } = useBalance({
+    const { data: nativeEvmBalance, isLoading } = useBalance({
         address: address,
         chainId: Number(chain?.chainId),
         query: {
@@ -33728,13 +33764,13 @@ const useEvmNativeBalance = ({ address, chain, }) => {
     }, [nativeEvmBalance?.decimals, nativeEvmBalance?.value]);
     return {
         balance,
-        isPending,
+        isLoading,
     };
 };
 const useCosmosNativeBalance = ({ address, chain, }) => {
     const { isConnected: isCosmosConnected } = useCosmosContext();
     const { nativeToken: nativeCosmosToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isPending } = useCosmosBalance({
+    const { balance: rawBalance, isLoading } = useCosmosBalance({
         chain,
         token: nativeCosmosToken,
         userAddress: address,
@@ -33749,18 +33785,16 @@ const useCosmosNativeBalance = ({ address, chain, }) => {
             };
         }
     }, [nativeCosmosToken?.decimals, rawBalance]);
-    return { balance, isPending };
+    return { balance, isLoading };
 };
 const useBitcoinNativeBalance = ({ chain, address, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
-    const { data: rawBalance = "0", isPending } = useQuery({
-        queryKey: keys().balance(chain?.chainId, nativeToken?.address, address),
-        queryFn: async () => {
-            if (!address || !nativeToken)
-                return "0";
-            const balance = await getBitcoinNativeBalance(address);
-            return formatBNToReadable(balance, nativeToken.decimals);
-        },
+    const { data: rawBalance = "0", isLoading } = useQuery(keys().balance(chain?.chainId, nativeToken?.address, address), async () => {
+        if (!address || !nativeToken)
+            return "0";
+        const balance = await getBitcoinNativeBalance(address);
+        return formatBNToReadable(balance, nativeToken.decimals);
+    }, {
         enabled: chain?.chainType === ChainType.BTC &&
             nativeToken?.decimals != null &&
             isWalletAddressValid(chain, address),
@@ -33779,17 +33813,15 @@ const useBitcoinNativeBalance = ({ chain, address, }) => {
     }, [nativeToken?.decimals, rawBalance]);
     return {
         balance,
-        isPending,
+        isLoading,
     };
 };
 const useSolanaNativeBalance = ({ chain, address, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
-    const { data: rawBalance, isPending } = useQuery({
-        queryKey: keys().balance(chain?.chainId, nativeToken?.address, address),
-        queryFn: async () => {
-            const balance = await getSolanaNativeBalance(address);
-            return formatBNToReadable(balance, nativeToken.decimals);
-        },
+    const { data: rawBalance, isLoading } = useQuery(keys().balance(chain?.chainId, nativeToken?.address, address), async () => {
+        const balance = await getSolanaNativeBalance(address);
+        return formatBNToReadable(balance, nativeToken.decimals);
+    }, {
         enabled: !!address &&
             nativeToken?.decimals != null &&
             chain?.chainType === ChainType.SOLANA,
@@ -33808,12 +33840,12 @@ const useSolanaNativeBalance = ({ chain, address, }) => {
     }, [nativeToken?.decimals, rawBalance]);
     return {
         balance,
-        isPending,
+        isLoading,
     };
 };
 const useSuiNativeBalance = ({ address, chain, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isPending } = useSuiBalance({
+    const { balance: rawBalance, isLoading } = useSuiBalance({
         chain,
         token: nativeToken,
         userAddress: address,
@@ -33828,12 +33860,12 @@ const useSuiNativeBalance = ({ address, chain, }) => {
     }, [nativeToken?.decimals, rawBalance]);
     return {
         balance,
-        isPending,
+        isLoading,
     };
 };
 const useXrplNativeBalance = ({ address, chain, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isPending } = useXrplBalance({
+    const { balance: rawBalance, isLoading } = useXrplBalance({
         chain,
         token: nativeToken,
         userAddress: address,
@@ -33849,12 +33881,12 @@ const useXrplNativeBalance = ({ address, chain, }) => {
     }, [nativeToken?.decimals, rawBalance]);
     return {
         balance,
-        isPending,
+        isLoading,
     };
 };
 const useStellarNativeBalance = ({ address, chain, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isPending } = useStellarBalance({
+    const { balance: rawBalance, isLoading } = useStellarBalance({
         chain,
         token: nativeToken,
         userAddress: address,
@@ -33870,7 +33902,7 @@ const useStellarNativeBalance = ({ address, chain, }) => {
     }, [nativeToken?.decimals, rawBalance]);
     return {
         balance,
-        isPending,
+        isLoading,
     };
 };
 const useNativeBalance = (chain) => {
@@ -33878,28 +33910,28 @@ const useNativeBalance = (chain) => {
     const { data: cosmosAddressForChain } = useCosmosForChain(chain);
     // Cosmos is a special case because the address changes on every chain
     // so we can't use the default cosmos connected address
-    const { balance: nativeCosmosBalance, isPending: isCosmosPending } = useCosmosNativeBalance({
+    const { balance: nativeCosmosBalance, isLoading: isCosmosLoading } = useCosmosNativeBalance({
         address: cosmosAddressForChain,
         chain,
     });
-    const { balance: nativeEvmBalance, isPending: isEvmPending } = useEvmNativeBalance({ address: connectedAddresses[ChainType.EVM], chain });
-    const { balance: nativeBitcoinBalance, isPending: isBitcoinPending } = useBitcoinNativeBalance({
+    const { balance: nativeEvmBalance, isLoading: isEvmLoading } = useEvmNativeBalance({ address: connectedAddresses[ChainType.EVM], chain });
+    const { balance: nativeBitcoinBalance, isLoading: isBitcoinLoading } = useBitcoinNativeBalance({
         address: connectedAddresses[ChainType.BTC],
         chain,
     });
-    const { balance: nativeSolanaBalance, isPending: isSolanaPending } = useSolanaNativeBalance({
+    const { balance: nativeSolanaBalance, isLoading: isSolanaLoading } = useSolanaNativeBalance({
         address: connectedAddresses[ChainType.SOLANA],
         chain,
     });
-    const { balance: nativeSuiBalance, isPending: isSuiPending } = useSuiNativeBalance({
+    const { balance: nativeSuiBalance, isLoading: isSuiLoading } = useSuiNativeBalance({
         address: connectedAddresses[ChainType.SUI],
         chain,
     });
-    const { balance: nativeXrplBalance, isPending: isXrplPending } = useXrplNativeBalance({
+    const { balance: nativeXrplBalance, isLoading: isXrpLoading } = useXrplNativeBalance({
         address: connectedAddresses[ChainType.XRPL],
         chain,
     });
-    const { balance: nativeStellarBalance, isPending: isStellarPending } = useStellarNativeBalance({
+    const { balance: nativeStellarBalance, isLoading: isStellarLoading } = useStellarNativeBalance({
         address: connectedAddresses[ChainType.STELLAR],
         chain,
     });
@@ -33944,36 +33976,36 @@ const useNativeBalance = (chain) => {
         nativeXrplBalance,
         nativeStellarBalance,
     ]);
-    const isPending = useMemo(() => {
+    const isLoading = useMemo(() => {
         if (!chain?.chainType)
             return false;
         switch (chain.chainType) {
             case ChainType.EVM:
-                return isEvmPending;
+                return isEvmLoading;
             case ChainType.COSMOS:
-                return isCosmosPending;
+                return isCosmosLoading;
             case ChainType.BTC:
-                return isBitcoinPending;
+                return isBitcoinLoading;
             case ChainType.SOLANA:
-                return isSolanaPending;
+                return isSolanaLoading;
             case ChainType.SUI:
-                return isSuiPending;
+                return isSuiLoading;
             case ChainType.XRPL:
-                return isXrplPending;
+                return isXrpLoading;
             case ChainType.STELLAR:
-                return isStellarPending;
+                return isStellarLoading;
         }
     }, [
         chain?.chainType,
-        isEvmPending,
-        isCosmosPending,
-        isBitcoinPending,
-        isSolanaPending,
-        isSuiPending,
-        isXrplPending,
-        isStellarPending,
+        isEvmLoading,
+        isCosmosLoading,
+        isBitcoinLoading,
+        isSolanaLoading,
+        isSuiLoading,
+        isXrpLoading,
+        isStellarLoading,
     ]);
-    return { nativeBalance, nativeBalanceFormatted, isPending };
+    return { nativeBalance, nativeBalanceFormatted, isLoading };
 };
 
 const DEFAULT_REFRESH_INTERVAL_MS = 15000;
@@ -33982,7 +34014,7 @@ const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshInter
     const isNativeToken = token?.address.toLowerCase() === nativeEvmTokenAddress.toLowerCase();
     const userAddressParsed = userAddress;
     // Only fetch using useBalance if it's a native token
-    const { data: nativeBalance, isPending: isNativeTokenPending } = useBalance({
+    const { data: nativeBalance, isLoading: isNativeTokenLoading } = useBalance({
         address: userAddressParsed,
         chainId: Number(chain?.chainId),
         query: {
@@ -33998,7 +34030,7 @@ const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshInter
     });
     // Only fetch using useReadContract if it's not a native token
     // This is temporary, because of wagmi error: https://github.com/wevm/wagmi/issues/4353
-    const { data: erc20Balance, isPending: isErc20Pending } = useReadContract({
+    const { data: erc20Balance, isLoading: isErc20Loading } = useReadContract({
         address: token?.address,
         abi: erc20Abi,
         functionName: "balanceOf",
@@ -34014,15 +34046,15 @@ const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshInter
         },
     });
     const balance = isNativeToken ? nativeBalance?.value : erc20Balance;
-    const isPending = isNativeToken ? isNativeTokenPending : isErc20Pending;
+    const isLoading = isNativeToken ? isNativeTokenLoading : isErc20Loading;
     const formattedBalance = balance != null && token?.decimals != null
         ? formatBNToReadable(balance, token.decimals)
         : "0";
-    return { balance: formattedBalance, isPending };
+    return { balance: formattedBalance, isLoading };
 };
 const useCosmosBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
     const { isConnected } = useCosmosContext();
-    const { data: balance = "0", isPending } = useQuery({
+    const { data: balance = "0", isLoading } = useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token || chain?.chainType !== ChainType.COSMOS) {
@@ -34042,10 +34074,10 @@ const useCosmosBalance = ({ chain, token, userAddress, enabled = true, refreshIn
         refetchInterval: refreshIntervalMs,
         retry: 2,
     });
-    return { balance, isPending };
+    return { balance, isLoading };
 };
 const useSolanaBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isPending } = useQuery({
+    const { data: balance = "0", isLoading } = useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token)
@@ -34060,11 +34092,11 @@ const useSolanaBalance = ({ chain, token, userAddress, enabled = true, refreshIn
         refetchInterval: refreshIntervalMs,
         retry: 2,
     });
-    return { balance, isPending };
+    return { balance, isLoading };
 };
 // TODO: implement fetching balances for all bitcoin tokens
 const useBitcoinBalance = ({ userAddress, chain, }) => {
-    const { balance: balanceBn, isPending } = useBitcoinNativeBalance({
+    const { balance: balanceBn, isLoading } = useBitcoinNativeBalance({
         address: userAddress,
         chain,
     });
@@ -34073,10 +34105,10 @@ const useBitcoinBalance = ({ userAddress, chain, }) => {
             return "0";
         return formatBNToReadable(balanceBn?.value, balanceBn?.decimals);
     }, [balanceBn]);
-    return { balance, isPending };
+    return { balance, isLoading };
 };
 const useSuiBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isPending } = useQuery({
+    const { data: balance = "0", isLoading } = useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress ||
@@ -34096,10 +34128,10 @@ const useSuiBalance = ({ chain, token, userAddress, enabled = true, refreshInter
         refetchInterval: refreshIntervalMs,
         retry: 2,
     });
-    return { balance, isPending };
+    return { balance, isLoading };
 };
 const useXrplBalance = ({ userAddress, chain, enabled, token, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isPending } = useQuery({
+    const { data: balance = "0", isLoading } = useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token || !chain)
@@ -34116,10 +34148,10 @@ const useXrplBalance = ({ userAddress, chain, enabled, token, refreshIntervalMs
         refetchInterval: refreshIntervalMs,
         retry: 2,
     });
-    return { balance, isPending };
+    return { balance, isLoading };
 };
 const useStellarBalance = ({ userAddress, chain, enabled, token, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isPending } = useQuery({
+    const { data: balance = "0", isLoading } = useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token || !chain)
@@ -34136,7 +34168,7 @@ const useStellarBalance = ({ userAddress, chain, enabled, token, refreshInterval
         refetchInterval: refreshIntervalMs,
         retry: 2,
     });
-    return { balance, isPending };
+    return { balance, isLoading };
 };
 
 /**
@@ -34257,7 +34289,7 @@ const useMultipleTokenPrices = (tokens) => {
     return {
         tokenPrices,
         getTokenPrice,
-        isPending: coinGeckoQuery.isPending,
+        isLoading: coinGeckoQuery.isLoading,
         isError: coinGeckoQuery.isError,
         error: coinGeckoQuery.error,
         refetch: coinGeckoQuery.refetch,
@@ -34406,17 +34438,13 @@ const fetchTokensData = async (tokens) => {
 
 // Coingecko has a limit for some queries for multiple tokens, not sure what it is, but let's use 100 for now
 const useHistoricalData = (coingeckoId, timeFrame) => {
-    return useQuery({
-        queryKey: keys().historicalData(coingeckoId, timeFrame),
-        queryFn: () => fetchHistoricalData(coingeckoId, timeFrame),
+    return useQuery(keys().historicalData(coingeckoId, timeFrame), () => fetchHistoricalData(coingeckoId, timeFrame), {
         staleTime: 5 * 60 * 1000,
         enabled: !!coingeckoId,
     });
 };
 const useTokensData = (tokens) => {
-    return useQuery({
-        queryKey: keys().tokensData(tokens),
-        queryFn: () => fetchTokensData(tokens),
+    return useQuery(keys().tokensData(tokens), () => fetchTokensData(tokens), {
         staleTime: 60 * 1000,
         enabled: !!tokens && tokens.length > 0,
     });
@@ -34721,7 +34749,7 @@ function useSendTransactionGas({ chain, token, from, }) {
 }
 
 function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
-    const { data: estimatedGas = BigInt(0), isPending } = useSendTransactionGas({
+    const { data: estimatedGas = BigInt(0), isLoading } = useSendTransactionGas({
         chain,
         token,
         from,
@@ -34766,7 +34794,7 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
     return {
         estimatedGas,
         isBalanceEnough,
-        isPending,
+        isLoading,
         isNativeBalanceEnoughToPayGasFees,
         minAmountValueWarnMsg,
     };
@@ -35173,12 +35201,10 @@ function useSendTransaction({ to, amount, token, chain, }) {
             // amount is already formatted with the token decimals
             amount,
             toAddress: to,
-            token: {
-                address: token.address,
-                chainId: token.chainId,
-                symbol: token.symbol,
-                type: token.type,
-            },
+            tokenAddress: token.address,
+            tokenChainId: token.chainId,
+            tokenSymbol: token.symbol,
+            tokenType: token.type,
         });
     }, [
         allEventParamsDefined,
@@ -35198,12 +35224,10 @@ function useSendTransaction({ to, amount, token, chain, }) {
             // amount is already formatted with the token decimals
             amount,
             toAddress: to,
-            token: {
-                address: token.address,
-                chainId: token.chainId,
-                symbol: token.symbol,
-                type: token.type,
-            },
+            tokenAddress: token.address,
+            tokenChainId: token.chainId,
+            tokenSymbol: token.symbol,
+            tokenType: token.type,
             txHash,
         });
     }, [
@@ -35349,9 +35373,7 @@ function useSendTransaction({ to, amount, token, chain, }) {
             });
         },
         onSuccess: (tx, variables) => {
-            queryClient.invalidateQueries({
-                queryKey: getPrefixKey(QueryKeys.Balance),
-            });
+            queryClient.invalidateQueries(getPrefixKey(QueryKeys.Balance));
             setTransactionState(variables.id, tx);
             persistTransaction({
                 txType: HistoryTxType.SEND,
@@ -35678,10 +35700,9 @@ const useAllTransactionsStatus = ({ enabled }) => {
                     queryKey: keys().fiatToCryptoStatus(data.orderId),
                     retry: TX_STATUS_CONSTANTS.RETRY_COUNT,
                     retryDelay: TX_STATUS_CONSTANTS.RETRY_DELAY,
-                    refetchInterval: (query) => {
-                        const { state } = query;
-                        if (state.data?.status &&
-                            FINAL_TRANSACTION_STATUSES.includes(state.data.status)) {
+                    refetchInterval: (data) => {
+                        if (data?.status &&
+                            FINAL_TRANSACTION_STATUSES.includes(data.status)) {
                             return false;
                         }
                         return TX_STATUS_CONSTANTS.REFETCH_INTERVAL;
@@ -35741,7 +35762,7 @@ const useAllTransactionsStatus = ({ enabled }) => {
         queries: enabled && config.apiUrl ? statusQueries : [],
     });
     return {
-        isPending: queries.some((q) => q.isPending),
+        isLoading: queries.some((q) => q.isLoading),
         isError: queries.some((q) => q.isError),
         data: queries.map((q) => q.data).filter(Boolean),
     };
@@ -36000,18 +36021,16 @@ const useApproval = ({ squidRoute, }) => {
      * On Error: Showing the error message if any
      * @returns {boolean} approved
      */
-    const routeApproved = useQuery({
-        queryKey: keys().routeApproved(squidRoute, allowanceInWei),
-        queryFn: async () => {
-            // Approval is only needed for EVM chains
-            if (getChainType(squidRoute?.params.fromChain) === ChainType.EVM) {
-                return hasAllowance;
-            }
-            return true;
-        },
+    const routeApproved = useQuery(keys().routeApproved(squidRoute, allowanceInWei), async () => {
+        // Approval is only needed for EVM chains
+        if (getChainType(squidRoute?.params.fromChain) === ChainType.EVM) {
+            return hasAllowance;
+        }
+        return true;
+    }, {
         enabled: !!squidRoute &&
             !!sourceUserAddress &&
-            !allowanceQuery?.isPending &&
+            !allowanceQuery?.isLoading &&
             allowanceQuery?.isFetched,
     });
     // USDT has a very specific way of handling approvals
@@ -36100,84 +36119,81 @@ const useApproval = ({ squidRoute, }) => {
     /**
      * Manually approve route if necessary
      */
-    const approveRoute = useMutation({
-        mutationFn: async () => {
-            try {
-                if (fromToken?.address === nativeEvmTokenAddress) {
-                    return true;
+    const approveRoute = useMutation(async () => {
+        try {
+            if (fromToken?.address === nativeEvmTokenAddress) {
+                return true;
+            }
+            if (!!squidRoute && walletClient && fromToken && evmSigner && squid) {
+                await approveSpecificTokenToZero(fromToken);
+                try {
+                    // If needed, we can switch the chain here
+                    // If already on the correct chain, this will do nothing
+                    await switchChainAsync({ chainId: Number(fromChain?.chainId) });
                 }
-                if (!!squidRoute && walletClient && fromToken && evmSigner && squid) {
-                    await approveSpecificTokenToZero(fromToken);
-                    try {
-                        // If needed, we can switch the chain here
-                        // If already on the correct chain, this will do nothing
-                        await switchChainAsync({ chainId: Number(fromChain?.chainId) });
-                    }
-                    catch (error) {
-                        console.error("Error switching network:", error);
-                    }
-                    let approveTx;
-                    if (useIcs20) {
-                        const channel = squidRoute.estimate.actions[0].data
-                            .ibcChannel;
-                        const ics20Interface = new ethers.Interface(ics20Abi);
-                        const approveData = ics20Interface.encodeFunctionData("approve", [
-                            squidRoute.params.fromAddress,
-                            [
-                                {
-                                    sourcePort: "transfer",
-                                    sourceChannel: channel,
-                                    spendLimit: [
-                                        {
-                                            denom: squidRoute.estimate.actions[0].fromToken
-                                                .originalAddress,
-                                            amount: squidRoute.params.fromAmount,
-                                        },
-                                    ],
-                                    allowList: [],
-                                    allowedPacketData: ["*"],
-                                },
-                            ],
-                        ]);
-                        approveTx = await evmSigner.sendTransaction({
-                            to: squidRoute.transactionRequest.target,
-                            data: approveData,
-                            value: "0",
-                            gasLimit: squidRoute.transactionRequest
-                                .gasLimit,
-                            gasPrice: squidRoute.transactionRequest
-                                .gasPrice,
-                        });
-                    }
-                    else {
-                        approveTx = await squid.approveRoute({
-                            route: squidRoute,
-                            signer: evmSigner,
-                            // For security reasons, we don't want to allow infinite approvals in our frontends
-                            executionSettings: {
-                                infiniteApproval: false,
+                catch (error) {
+                    console.error("Error switching network:", error);
+                }
+                let approveTx;
+                if (useIcs20) {
+                    const channel = squidRoute.estimate.actions[0].data
+                        .ibcChannel;
+                    const ics20Interface = new ethers.Interface(ics20Abi);
+                    const approveData = ics20Interface.encodeFunctionData("approve", [
+                        squidRoute.params.fromAddress,
+                        [
+                            {
+                                sourcePort: "transfer",
+                                sourceChannel: channel,
+                                spendLimit: [
+                                    {
+                                        denom: squidRoute.estimate.actions[0].fromToken
+                                            .originalAddress,
+                                        amount: squidRoute.params.fromAmount,
+                                    },
+                                ],
+                                allowList: [],
+                                allowedPacketData: ["*"],
                             },
-                        });
-                    }
-                    if (isProblematicConnector(activeConnector)) {
-                        await sleep(3_000);
-                    }
-                    await approveTx?.wait();
-                    return true;
+                        ],
+                    ]);
+                    approveTx = await evmSigner.sendTransaction({
+                        to: squidRoute.transactionRequest.target,
+                        data: approveData,
+                        value: "0",
+                        gasLimit: squidRoute.transactionRequest
+                            .gasLimit,
+                        gasPrice: squidRoute.transactionRequest
+                            .gasPrice,
+                    });
                 }
-                return false;
-            }
-            catch (error) {
-                // Keep the error in the console to debug future issues
-                console.error(error);
-                return false;
+                else {
+                    approveTx = await squid.approveRoute({
+                        route: squidRoute,
+                        signer: evmSigner,
+                        // For security reasons, we don't want to allow infinite approvals in our frontends
+                        executionSettings: {
+                            infiniteApproval: false,
+                        },
+                    });
+                }
+                if (isProblematicConnector(activeConnector)) {
+                    await sleep(3_000);
+                }
+                await approveTx?.wait();
+                return true;
             }
-        },
+            return false;
+        }
+        catch (error) {
+            // Keep the error in the console to debug future issues
+            console.error(error);
+            return false;
+        }
+    }, {
         onSuccess: async () => {
             await allowanceQuery?.refetch();
-            queryClient.invalidateQueries({
-                queryKey: getPrefixKey(QueryKeys.RouteApproved),
-            });
+            queryClient.invalidateQueries(getPrefixKey(QueryKeys.RouteApproved));
             // After an approval, we refetch the transaction query with all required parameters
             // This is to ensure we're using the latest expiry timestamp
             if (squidRoute) {
@@ -39297,10 +39313,8 @@ const useExecuteTransaction = (squidRoute) => {
         }
     }, [cosmosSigner, fromChain]);
     const resetQueriesAfterTxSigned = () => {
-        queryClient.refetchQueries({ queryKey: getPrefixKey(QueryKeys.Balance) });
-        queryClient.invalidateQueries({
-            queryKey: getPrefixKey(QueryKeys.Transaction),
-        });
+        queryClient.refetchQueries(getPrefixKey(QueryKeys.Balance));
+        queryClient.invalidateQueries(getPrefixKey(QueryKeys.Transaction));
     };
     const dispatchSignatureRequestEvent = useCallback((route) => {
         WidgetEvents.getInstance().dispatchSwapTxSignatureRequested({
@@ -39318,64 +39332,62 @@ const useExecuteTransaction = (squidRoute) => {
             txHash,
         }, findToken);
     }, [findToken]);
-    const swapMutationCosmos = useMutation({
-        mutationFn: async ({ id, route }) => {
-            const fromChainId = route?.params.fromChain;
-            if (cosmosSigner && fromChainId) {
-                try {
-                    const signingClient = await getCosmosSignerClient();
-                    const signerAddress = (await cosmosSigner.getAccounts())[0].address;
-                    if (signerAddress && signingClient && route) {
-                        dispatchSignatureRequestEvent(route);
-                        const tx$1 = (await squid?.executeRoute({
-                            signer: signingClient,
-                            signerAddress,
-                            route,
-                        }));
-                        // set the tx state to loading, as soon as user signed the tx
-                        setTransactionState({
-                            txHash: "",
-                            route,
-                            status: TransactionStatus.ONGOING,
-                            sourceStatus: TransactionStatus.ONGOING,
-                            id,
-                        });
-                        // broadcast the signed tx to get hash and listen to events
-                        const response = await signingClient.broadcastTx(tx.TxRaw.encode(tx$1).finish());
-                        const hash = response.transactionHash;
-                        if (hash) {
-                            resetQueriesAfterTxSigned();
-                        }
-                        // Dispatch event so it can be listened from outside the widget
-                        WidgetEvents.getInstance().dispatchSwapExecuteCall(route, hash);
-                        const txParams = setTransactionState({
-                            route,
-                            txHash: hash,
-                            userAddress: sourceUserAddress,
-                            status: TransactionStatus.ONGOING,
-                            sourceStatus: TransactionStatus.ONGOING,
-                            axelarUrl: undefined,
-                            id,
+    const swapMutationCosmos = useMutation(async ({ id, route }) => {
+        const fromChainId = route?.params.fromChain;
+        if (cosmosSigner && fromChainId) {
+            try {
+                const signingClient = await getCosmosSignerClient();
+                const signerAddress = (await cosmosSigner.getAccounts())[0].address;
+                if (signerAddress && signingClient && route) {
+                    dispatchSignatureRequestEvent(route);
+                    const tx$1 = (await squid?.executeRoute({
+                        signer: signingClient,
+                        signerAddress,
+                        route,
+                    }));
+                    // set the tx state to loading, as soon as user signed the tx
+                    setTransactionState({
+                        txHash: "",
+                        route,
+                        status: TransactionStatus.ONGOING,
+                        sourceStatus: TransactionStatus.ONGOING,
+                        id,
+                    });
+                    // broadcast the signed tx to get hash and listen to events
+                    const response = await signingClient.broadcastTx(tx.TxRaw.encode(tx$1).finish());
+                    const hash = response.transactionHash;
+                    if (hash) {
+                        resetQueriesAfterTxSigned();
+                    }
+                    // Dispatch event so it can be listened from outside the widget
+                    WidgetEvents.getInstance().dispatchSwapExecuteCall(route, hash);
+                    const txParams = setTransactionState({
+                        route,
+                        txHash: hash,
+                        userAddress: sourceUserAddress,
+                        status: TransactionStatus.ONGOING,
+                        sourceStatus: TransactionStatus.ONGOING,
+                        axelarUrl: undefined,
+                        id,
+                    });
+                    if (txParams) {
+                        addSwapTransaction({
+                            ...txParams,
+                            params: route.params,
+                            estimate: route.estimate,
                         });
-                        if (txParams) {
-                            addSwapTransaction({
-                                ...txParams,
-                                params: route.params,
-                                estimate: route.estimate,
-                            });
-                        }
-                        return response.code === 0;
                     }
+                    return response.code === 0;
                 }
-                catch (error) {
-                    console.error("Error executing Cosmos transaction", error);
-                    if (isUserRejectionError(normalizeError(error))) {
-                        throw new Error("Request rejected");
-                    }
+            }
+            catch (error) {
+                console.error("Error executing Cosmos transaction", error);
+                if (isUserRejectionError(normalizeError(error))) {
+                    throw new Error("Request rejected");
                 }
             }
-            throw new Error("Need all parameters");
-        },
+        }
+        throw new Error("Need all parameters");
     });
     // If the transaction is replaced, we need to update the transaction hash
     // Transaction replaced can mean that the user has speed up the transaction for example
@@ -39428,126 +39440,97 @@ const useExecuteTransaction = (squidRoute) => {
             throw error;
         }
     }, [replaceSwapTransactionNonce, setTransactionState, sourceUserAddress]);
-    const swapMutationEvm = useMutation({
-        mutationFn: async ({ id, route }) => {
-            await changeNetworkIfNeeded.mutateAsync();
-            if (!route || !squid || !evmSigner) {
-                throw new Error("Need all parameters");
-            }
-            dispatchSignatureRequestEvent(route);
-            const txResponse = (await squid.executeRoute({
-                bypassBalanceChecks: true,
-                signer: evmSigner,
+    const swapMutationEvm = useMutation(async ({ id, route }) => {
+        await changeNetworkIfNeeded.mutateAsync();
+        if (!route || !squid || !evmSigner) {
+            throw new Error("Need all parameters");
+        }
+        dispatchSignatureRequestEvent(route);
+        const txResponse = (await squid.executeRoute({
+            bypassBalanceChecks: true,
+            signer: evmSigner,
+            route,
+        }));
+        let hash = txResponse.hash;
+        if (activeConnector?.id === "safe") {
+            hash = await getGnosisTransactionHash(txResponse.hash);
+        }
+        if (hash) {
+            resetQueriesAfterTxSigned();
+        }
+        // Dispatch event so it can be listened from outside the widget
+        WidgetEvents.getInstance().dispatchSwapExecuteCall(route, hash);
+        if (route.transactionRequest) {
+            const txParams = setTransactionState({
                 route,
-            }));
-            let hash = txResponse.hash;
-            if (activeConnector?.id === "safe") {
-                hash = await getGnosisTransactionHash(txResponse.hash);
+                txHash: hash,
+                nonce: txResponse.nonce,
+                userAddress: sourceUserAddress,
+                status: TransactionStatus.INITIAL_LOADING,
+                sourceStatus: TransactionStatus.ONGOING,
+                axelarUrl: undefined,
+                id,
+            });
+            if (txParams) {
+                addSwapTransaction({
+                    ...txParams,
+                    params: route.params,
+                    estimate: route.estimate,
+                });
             }
-            if (hash) {
-                resetQueriesAfterTxSigned();
+        }
+        try {
+            if (isProblematicConnector(activeConnector)) {
+                await sleep(3_000);
             }
-            // Dispatch event so it can be listened from outside the widget
-            WidgetEvents.getInstance().dispatchSwapExecuteCall(route, hash);
-            if (route.transactionRequest) {
-                const txParams = setTransactionState({
-                    route,
-                    txHash: hash,
-                    nonce: txResponse.nonce,
-                    userAddress: sourceUserAddress,
-                    status: TransactionStatus.INITIAL_LOADING,
-                    sourceStatus: TransactionStatus.ONGOING,
-                    axelarUrl: undefined,
-                    id,
-                });
-                if (txParams) {
-                    addSwapTransaction({
-                        ...txParams,
-                        params: route.params,
-                        estimate: route.estimate,
-                    });
-                }
+            const response = await txResponse.wait();
+            return response;
+        }
+        catch (error) {
+            return handleTransactionReplacementError({
+                error,
+                route,
+                status: TransactionStatus.INITIAL_LOADING,
+                sourceStatus: TransactionStatus.ONGOING,
+                userAddress: sourceUserAddress,
+                axelarUrl: undefined,
+                id,
+            });
+        }
+    });
+    const swapMutationSolana = useMutation(async ({ id, route }) => {
+        try {
+            if (!route) {
+                throw new Error("Route is required");
             }
-            try {
-                if (isProblematicConnector(activeConnector)) {
-                    await sleep(3_000);
-                }
-                const response = await txResponse.wait();
-                return response;
+            if (!solanaSigner) {
+                throw new Error("Solana signer is required");
             }
-            catch (error) {
-                return handleTransactionReplacementError({
-                    error,
-                    route,
-                    status: TransactionStatus.INITIAL_LOADING,
-                    sourceStatus: TransactionStatus.ONGOING,
-                    userAddress: sourceUserAddress,
-                    axelarUrl: undefined,
-                    id,
-                });
+            if (!route.params.fromAddress || !route.params.toAddress) {
+                throw new Error("From or to address is required");
             }
-        },
-    });
-    const swapMutationSolana = useMutation({
-        mutationFn: async ({ id, route }) => {
-            try {
-                if (!route) {
-                    throw new Error("Route is required");
-                }
-                if (!solanaSigner) {
-                    throw new Error("Solana signer is required");
+            const isDirectTransfer = isDepositRoute(route);
+            // Means it's a transfer to a deposit address
+            // Instead of a Swap/Contract call using a DEX like Jupiter
+            if (isDirectTransfer) {
+                // Get the deposit address from the squidRoute
+                const depositData = useDepositAddressStore.getState().deposit;
+                // Validate params
+                if (!depositData?.depositAddress) {
+                    throw new Error("Deposit address is required");
                 }
-                if (!route.params.fromAddress || !route.params.toAddress) {
-                    throw new Error("From or to address is required");
-                }
-                const isDirectTransfer = isDepositRoute(route);
-                // Means it's a transfer to a deposit address
-                // Instead of a Swap/Contract call using a DEX like Jupiter
-                if (isDirectTransfer) {
-                    // Get the deposit address from the squidRoute
-                    const depositData = useDepositAddressStore.getState().deposit;
-                    // Validate params
-                    if (!depositData?.depositAddress) {
-                        throw new Error("Deposit address is required");
-                    }
-                    const signature = await executeSolanaTransfer({
-                        amount: BigInt(route.params.fromAmount),
-                        target: depositData.depositAddress,
-                        signer: solanaSigner,
-                        connection: solanaConnection,
-                        sourceToken: findToken(route.params.fromToken, route?.params?.fromChain),
-                        onSigned: (txHash) => {
-                            WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
-                            const txParams = setTransactionState({
-                                route,
-                                txHash,
-                                transactionIdForStatus: depositData.chainflipStatusTrackingId,
-                                userAddress: sourceUserAddress,
-                                status: TransactionStatus.INITIAL_LOADING,
-                                sourceStatus: TransactionStatus.ONGOING,
-                                id,
-                            });
-                            if (txParams) {
-                                addSwapTransaction({
-                                    ...txParams,
-                                    params: route.params,
-                                    estimate: route.estimate,
-                                });
-                            }
-                        },
-                    });
-                    return signature;
-                }
-                const signature = await executeSolanaSwap({
-                    route,
+                const signature = await executeSolanaTransfer({
+                    amount: BigInt(route.params.fromAmount),
+                    target: depositData.depositAddress,
                     signer: solanaSigner,
                     connection: solanaConnection,
+                    sourceToken: findToken(route.params.fromToken, route?.params?.fromChain),
                     onSigned: (txHash) => {
                         WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
                         const txParams = setTransactionState({
                             route,
                             txHash,
-                            transactionIdForStatus: undefined,
+                            transactionIdForStatus: depositData.chainflipStatusTrackingId,
                             userAddress: sourceUserAddress,
                             status: TransactionStatus.INITIAL_LOADING,
                             sourceStatus: TransactionStatus.ONGOING,
@@ -39564,13 +39547,39 @@ const useExecuteTransaction = (squidRoute) => {
                 });
                 return signature;
             }
-            catch (error) {
-                console.error("Solana transaction failed:", error);
-                throw error instanceof Error
-                    ? error
-                    : new Error("Failed to execute Solana transaction");
-            }
-        },
+            const signature = await executeSolanaSwap({
+                route,
+                signer: solanaSigner,
+                connection: solanaConnection,
+                onSigned: (txHash) => {
+                    WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
+                    const txParams = setTransactionState({
+                        route,
+                        txHash,
+                        transactionIdForStatus: undefined,
+                        userAddress: sourceUserAddress,
+                        status: TransactionStatus.INITIAL_LOADING,
+                        sourceStatus: TransactionStatus.ONGOING,
+                        id,
+                    });
+                    if (txParams) {
+                        addSwapTransaction({
+                            ...txParams,
+                            params: route.params,
+                            estimate: route.estimate,
+                        });
+                    }
+                },
+            });
+            return signature;
+        }
+        catch (error) {
+            console.error("Solana transaction failed:", error);
+            throw error instanceof Error
+                ? error
+                : new Error("Failed to execute Solana transaction");
+        }
+    }, {
         onError: (error, variables) => {
             const currentTx = getTransaction(variables.id);
             const errorObject = getTransactionError(error);
@@ -39591,9 +39600,7 @@ const useExecuteTransaction = (squidRoute) => {
         },
         onSuccess: (_data, variables) => {
             const currentTx = getTransaction(variables.id);
-            queryClient.invalidateQueries({
-                queryKey: getPrefixKey(QueryKeys.Balances),
-            });
+            queryClient.invalidateQueries(getPrefixKey(QueryKeys.Balances));
             if (isSameChain && currentTx?.transactionId) {
                 replaceSwapTransactionStatus({
                     transactionId: currentTx.transactionId,
@@ -39610,207 +39617,197 @@ const useExecuteTransaction = (squidRoute) => {
             });
         },
     });
-    const swapMutationBitcoin = useMutation({
-        mutationFn: async ({ id, route }) => {
-            const { depositAddress, amount: sendAmount, chainflipStatusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
-            if (!depositAddress) {
-                throw new Error(`Invalid deposit address: ${depositAddress}`);
-            }
-            if (!sendAmount) {
-                throw new Error(`Invalid send amount: ${sendAmount}`);
-            }
-            const allParamsValid = route && bitcoinSigner && depositAddress && sendAmount;
-            await changeNetworkIfNeeded.mutateAsync();
-            if (allParamsValid) {
-                dispatchSignatureRequestEvent(route);
-                const { txHash } = await bitcoinSigner.sendBTC(depositAddress, Number(sendAmount));
-                if (txHash) {
-                    resetQueriesAfterTxSigned();
-                }
-                // Dispatch event so it can be listened from outside the widget
-                WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
-                if (route.transactionRequest) {
-                    const txParams = setTransactionState({
-                        route,
-                        txHash,
-                        // When bridging from Bitcoin we need to send the chainflipId to the status endpoint
-                        // instead of the Bitcoin transaction hash
-                        transactionIdForStatus: chainflipStatusTrackingId,
-                        userAddress: sourceUserAddress,
-                        status: TransactionStatus.INITIAL_LOADING,
-                        sourceStatus: TransactionStatus.ONGOING,
-                        axelarUrl: undefined,
-                        id,
-                    });
-                    if (txParams) {
-                        addSwapTransaction({
-                            ...txParams,
-                            params: route.params,
-                            estimate: route.estimate,
-                        });
-                    }
-                }
-            }
-            else {
-                throw new Error("Need all parameters");
-            }
-        },
-    });
-    const swapMutationXrpl = useMutation({
-        mutationFn: async ({ id, route }) => {
-            if (!route?.transactionRequest || !xrplSigner) {
-                throw new Error("Need all parameters");
-            }
-            if (route.transactionRequest.type !== SquidDataType.OnChainExecution) {
-                throw new Error("Invalid route type");
-            }
-            const { data } = route.transactionRequest;
-            const paymentTx = parseXrplPaymentTx(data);
-            if (!paymentTx)
-                throw new Error("Could not parse transaction");
-            const fromChainId = route.params.fromChain;
-            const xrplNetwork = getXrplNetwork(fromChainId);
-            if (xrplNetwork == null) {
-                throw new Error(`No XRPL network found for chainId '${fromChainId}'`);
-            }
-            const txRes = await xrplSigner.signAndSubmit({
-                tx: paymentTx,
-                network: xrplNetwork,
-            });
-            const txParams = setTransactionState({
-                txHash: txRes.hash,
-                id,
-                sourceStatus: TransactionStatus.ONGOING,
-                status: TransactionStatus.ONGOING,
-                route: route,
-                userAddress: sourceUserAddress,
-            });
-            if (txParams && route) {
-                addSwapTransaction({
-                    ...txParams,
-                    params: route.params,
-                    estimate: route.estimate,
-                });
-            }
-            if (txRes.status !== XrplTxStatus.SUCCESS) {
-                throw new Error(`Transaction failed with status: ${txRes.status}`);
-            }
-        },
-    });
-    const swapMutationSui = useMutation({
-        mutationFn: async ({ id, route }) => {
-            if (!route || !suiSigner || !fromChain) {
-                throw new Error("Need all parameters");
-            }
-            if (route.transactionRequest?.type !== SquidDataType.OnChainExecution) {
-                throw new Error("Invalid route type");
-            }
-            const suiWalletState = connectedWalletsByChainType[ChainType.SUI];
-            if (!suiWalletState.account) {
-                throw new Error("Sui wallet is missing account data");
-            }
-            const fromChainId = route.params.fromChain;
-            const suiChain = getSuiChain(fromChainId);
-            if (!suiChain) {
-                throw new Error(`Source chain (${fromChainId}) does not match any Sui chain`);
-            }
-            const suiClient = await getClient(fromChain);
-            const txJson = route.transactionRequest.data;
-            const tx = Transaction$2.from(txJson);
-            const signedTx = await suiSigner.signTransaction({
-                transaction: tx,
-                account: suiWalletState.account,
-                chain: suiChain,
-            });
-            // execute transaction without waiting for confirmation
-            const txResponse = await suiClient.executeTransactionBlock({
-                signature: signedTx.signature,
-                transactionBlock: signedTx.bytes,
-            });
-            const txHash = txResponse.digest;
+    const swapMutationBitcoin = useMutation(async ({ id, route }) => {
+        const { depositAddress, amount: sendAmount, chainflipStatusTrackingId, } = useDepositAddressStore.getState().deposit ?? {};
+        if (!depositAddress) {
+            throw new Error(`Invalid deposit address: ${depositAddress}`);
+        }
+        if (!sendAmount) {
+            throw new Error(`Invalid send amount: ${sendAmount}`);
+        }
+        const allParamsValid = route && bitcoinSigner && depositAddress && sendAmount;
+        await changeNetworkIfNeeded.mutateAsync();
+        if (allParamsValid) {
+            dispatchSignatureRequestEvent(route);
+            const { txHash } = await bitcoinSigner.sendBTC(depositAddress, Number(sendAmount));
             if (txHash) {
                 resetQueriesAfterTxSigned();
             }
+            // Dispatch event so it can be listened from outside the widget
             WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
-            const txParams = setTransactionState({
-                route,
-                txHash,
-                userAddress: sourceUserAddress,
-                status: TransactionStatus.INITIAL_LOADING,
-                sourceStatus: TransactionStatus.ONGOING,
-                id,
-            });
-            if (txParams) {
-                addSwapTransaction({
-                    ...txParams,
-                    params: route.params,
-                    estimate: route.estimate,
+            if (route.transactionRequest) {
+                const txParams = setTransactionState({
+                    route,
+                    txHash,
+                    // When bridging from Bitcoin we need to send the chainflipId to the status endpoint
+                    // instead of the Bitcoin transaction hash
+                    transactionIdForStatus: chainflipStatusTrackingId,
+                    userAddress: sourceUserAddress,
+                    status: TransactionStatus.INITIAL_LOADING,
+                    sourceStatus: TransactionStatus.ONGOING,
+                    axelarUrl: undefined,
+                    id,
                 });
+                if (txParams) {
+                    addSwapTransaction({
+                        ...txParams,
+                        params: route.params,
+                        estimate: route.estimate,
+                    });
+                }
             }
-            // wait for transaction confirmation
-            await suiClient.waitForTransaction({
-                digest: txHash,
-            });
-        },
+        }
+        else {
+            throw new Error("Need all parameters");
+        }
     });
-    const swapMutationStellar = useMutation({
-        mutationFn: async ({ id, route }) => {
-            if (!stellarSigner || !route || !squid || !fromChain) {
-                throw new Error("Need all parameters");
-            }
-            const fromChainId = route.params.fromChain;
-            const stellarNetwork = getStellarNetwork(fromChainId);
-            if (stellarNetwork == null) {
-                throw new Error(`No Stellar network found for chainId ${fromChainId}`);
-            }
-            const { data: xdrHex, gasPrice } = route.transactionRequest;
-            const { address } = await stellarSigner.getAddress();
-            const client = await getClient(fromChain);
-            const account = await client.getAccount(address);
-            const operation = xdr.Operation.fromXDR(xdrHex, "hex");
-            const builtTransaction = new TransactionBuilder(account, {
-                fee: gasPrice || (BigInt(BASE_FEE) * BigInt(2)).toString(),
-                networkPassphrase: stellarNetwork,
-            })
-                .addOperation(operation)
-                .setTimeout(300)
-                .build();
-            const preparedTransaction = await client.prepareTransaction(builtTransaction);
-            const { signedTxXdr } = await stellarSigner.signTransaction(preparedTransaction.toXDR(), {
-                networkPassphrase: stellarNetwork,
+    const swapMutationXrpl = useMutation(async ({ id, route }) => {
+        if (!route?.transactionRequest || !xrplSigner) {
+            throw new Error("Need all parameters");
+        }
+        if (route.transactionRequest.type !== SquidDataType.OnChainExecution) {
+            throw new Error("Invalid route type");
+        }
+        const { data } = route.transactionRequest;
+        const paymentTx = parseXrplPaymentTx(data);
+        if (!paymentTx)
+            throw new Error("Could not parse transaction");
+        const fromChainId = route.params.fromChain;
+        const xrplNetwork = getXrplNetwork(fromChainId);
+        if (xrplNetwork == null) {
+            throw new Error(`No XRPL network found for chainId '${fromChainId}'`);
+        }
+        const txRes = await xrplSigner.signAndSubmit({
+            tx: paymentTx,
+            network: xrplNetwork,
+        });
+        const txParams = setTransactionState({
+            txHash: txRes.hash,
+            id,
+            sourceStatus: TransactionStatus.ONGOING,
+            status: TransactionStatus.ONGOING,
+            route: route,
+            userAddress: sourceUserAddress,
+        });
+        if (txParams && route) {
+            addSwapTransaction({
+                ...txParams,
+                params: route.params,
+                estimate: route.estimate,
             });
-            const signedTransaction = new Transaction$1(signedTxXdr, stellarNetwork);
-            // get hash before submitting
-            const hash = signedTransaction.hash().toString("hex");
-            if (hash) {
-                resetQueriesAfterTxSigned();
-            }
-            // Dispatch event so it can be listened from outside the widget
-            WidgetEvents.getInstance().dispatchSwapExecuteCall(route, hash);
-            const txParams = setTransactionState({
-                route,
-                txHash: hash,
-                userAddress: sourceUserAddress,
-                status: TransactionStatus.INITIAL_LOADING,
-                sourceStatus: TransactionStatus.ONGOING,
-                id,
+        }
+        if (txRes.status !== XrplTxStatus.SUCCESS) {
+            throw new Error(`Transaction failed with status: ${txRes.status}`);
+        }
+    }, {});
+    const swapMutationSui = useMutation(async ({ id, route }) => {
+        if (!route || !suiSigner || !fromChain) {
+            throw new Error("Need all parameters");
+        }
+        if (route.transactionRequest?.type !== SquidDataType.OnChainExecution) {
+            throw new Error("Invalid route type");
+        }
+        const suiWalletState = connectedWalletsByChainType[ChainType.SUI];
+        if (!suiWalletState.account) {
+            throw new Error("Sui wallet is missing account data");
+        }
+        const fromChainId = route.params.fromChain;
+        const suiChain = getSuiChain(fromChainId);
+        if (!suiChain) {
+            throw new Error(`Source chain (${fromChainId}) does not match any Sui chain`);
+        }
+        const suiClient = await getClient(fromChain);
+        const txJson = route.transactionRequest.data;
+        const tx = Transaction$2.from(txJson);
+        const signedTx = await suiSigner.signTransaction({
+            transaction: tx,
+            account: suiWalletState.account,
+            chain: suiChain,
+        });
+        // execute transaction without waiting for confirmation
+        const txResponse = await suiClient.executeTransactionBlock({
+            signature: signedTx.signature,
+            transactionBlock: signedTx.bytes,
+        });
+        const txHash = txResponse.digest;
+        if (txHash) {
+            resetQueriesAfterTxSigned();
+        }
+        WidgetEvents.getInstance().dispatchSwapExecuteCall(route, txHash);
+        const txParams = setTransactionState({
+            route,
+            txHash,
+            userAddress: sourceUserAddress,
+            status: TransactionStatus.INITIAL_LOADING,
+            sourceStatus: TransactionStatus.ONGOING,
+            id,
+        });
+        if (txParams) {
+            addSwapTransaction({
+                ...txParams,
+                params: route.params,
+                estimate: route.estimate,
             });
-            if (txParams) {
-                addSwapTransaction({
-                    ...txParams,
-                    params: route.params,
-                    estimate: route.estimate,
-                });
-            }
-            const sentTransaction = await client.sendTransaction(signedTransaction);
-            await client.waitForTransaction(sentTransaction.hash);
-        },
-    });
+        }
+        // wait for transaction confirmation
+        await suiClient.waitForTransaction({
+            digest: txHash,
+        });
+    }, {});
+    const swapMutationStellar = useMutation(async ({ id, route }) => {
+        if (!stellarSigner || !route || !squid || !fromChain) {
+            throw new Error("Need all parameters");
+        }
+        const fromChainId = route.params.fromChain;
+        const stellarNetwork = getStellarNetwork(fromChainId);
+        if (stellarNetwork == null) {
+            throw new Error(`No Stellar network found for chainId ${fromChainId}`);
+        }
+        const { data: xdrHex, gasPrice } = route.transactionRequest;
+        const { address } = await stellarSigner.getAddress();
+        const client = await getClient(fromChain);
+        const account = await client.getAccount(address);
+        const operation = xdr.Operation.fromXDR(xdrHex, "hex");
+        const builtTransaction = new TransactionBuilder(account, {
+            fee: gasPrice || (BigInt(BASE_FEE) * BigInt(2)).toString(),
+            networkPassphrase: stellarNetwork,
+        })
+            .addOperation(operation)
+            .setTimeout(300)
+            .build();
+        const preparedTransaction = await client.prepareTransaction(builtTransaction);
+        const { signedTxXdr } = await stellarSigner.signTransaction(preparedTransaction.toXDR(), {
+            networkPassphrase: stellarNetwork,
+        });
+        const signedTransaction = new Transaction$1(signedTxXdr, stellarNetwork);
+        // get hash before submitting
+        const hash = signedTransaction.hash().toString("hex");
+        if (hash) {
+            resetQueriesAfterTxSigned();
+        }
+        // Dispatch event so it can be listened from outside the widget
+        WidgetEvents.getInstance().dispatchSwapExecuteCall(route, hash);
+        const txParams = setTransactionState({
+            route,
+            txHash: hash,
+            userAddress: sourceUserAddress,
+            status: TransactionStatus.INITIAL_LOADING,
+            sourceStatus: TransactionStatus.ONGOING,
+            id,
+        });
+        if (txParams) {
+            addSwapTransaction({
+                ...txParams,
+                params: route.params,
+                estimate: route.estimate,
+            });
+        }
+        const sentTransaction = await client.sendTransaction(signedTransaction);
+        await client.waitForTransaction(sentTransaction.hash);
+    }, {});
     const handleTransactionSuccess = useCallback((id) => {
         const currentTx = getTransaction(id);
-        queryClient.invalidateQueries({
-            queryKey: getPrefixKey(QueryKeys.Balances),
-        });
+        queryClient.invalidateQueries(getPrefixKey(QueryKeys.Balances));
         if (isSameChain && currentTx?.transactionId) {
             replaceSwapTransactionStatus({
                 transactionId: currentTx.transactionId,
@@ -39862,39 +39859,38 @@ const useExecuteTransaction = (squidRoute) => {
         setTransactionStoreState,
         squidRoute,
     ]);
-    const swapMutation = useMutation({
-        mutationFn: async (mutationParams) => {
-            if (!mutationParams.route)
-                throw new Error("route is required");
-            const sourceChain = findChain(mutationParams.route.params?.fromChain);
-            if (!sourceChain)
-                throw new Error("Could not find source chain");
-            switch (sourceChain.chainType) {
-                case ChainType.COSMOS: {
-                    return swapMutationCosmos.mutateAsync(mutationParams);
-                }
-                case ChainType.EVM: {
-                    return swapMutationEvm.mutateAsync(mutationParams);
-                }
-                case ChainType.BTC: {
-                    return swapMutationBitcoin.mutateAsync(mutationParams);
-                }
-                case ChainType.SOLANA: {
-                    return swapMutationSolana.mutateAsync(mutationParams);
-                }
-                case ChainType.SUI: {
-                    return swapMutationSui.mutateAsync(mutationParams);
-                }
-                case ChainType.XRPL: {
-                    return swapMutationXrpl.mutateAsync(mutationParams);
-                }
-                case ChainType.STELLAR: {
-                    return swapMutationStellar.mutateAsync(mutationParams);
-                }
-                default:
-                    throw new Error(`Swap mutation not implemented for chain type: ${sourceChain.chainType}`);
+    const swapMutation = useMutation(async (mutationParams) => {
+        if (!mutationParams.route)
+            throw new Error("route is required");
+        const sourceChain = findChain(mutationParams.route.params?.fromChain);
+        if (!sourceChain)
+            throw new Error("Could not find source chain");
+        switch (sourceChain.chainType) {
+            case ChainType.COSMOS: {
+                return swapMutationCosmos.mutateAsync(mutationParams);
             }
-        },
+            case ChainType.EVM: {
+                return swapMutationEvm.mutateAsync(mutationParams);
+            }
+            case ChainType.BTC: {
+                return swapMutationBitcoin.mutateAsync(mutationParams);
+            }
+            case ChainType.SOLANA: {
+                return swapMutationSolana.mutateAsync(mutationParams);
+            }
+            case ChainType.SUI: {
+                return swapMutationSui.mutateAsync(mutationParams);
+            }
+            case ChainType.XRPL: {
+                return swapMutationXrpl.mutateAsync(mutationParams);
+            }
+            case ChainType.STELLAR: {
+                return swapMutationStellar.mutateAsync(mutationParams);
+            }
+            default:
+                throw new Error(`Swap mutation not implemented for chain type: ${sourceChain.chainType}`);
+        }
+    }, {
         onMutate: (variables) => {
             useTransactionStore.setState({
                 txLocalId: variables.id,
@@ -39943,7 +39939,7 @@ const useExecuteTransaction = (squidRoute) => {
         toToken,
         toChain,
         fromChain,
-        isPending: swapMutation.isPending,
+        isLoading: swapMutation.isLoading,
         error: swapMutation.error,
     };
 };
@@ -40004,59 +40000,57 @@ const useGetRoute = () => {
      * These data will be used to trigger the transaction
      * @returns {Route} Route data
      */
-    return useMutation({
-        mutationFn: async ({ fromChain, toChain, fromToken, toToken, sourceUserAddress, destinationAddress, fromPrice, bypassGuardrails, quoteOnly, fromChainType, postHook, preHook, }) => {
-            if (!fromChain || !toChain || !fromToken || !toToken || !fromPrice) {
-                return undefined;
-            }
-            // Dispatch requestQuote event
-            dispatchRequestQuoteEvent({
-                fromChain,
-                toChain,
-                fromToken: fromToken.address,
-                toToken: toToken.address,
-                fromAmount: fromPrice,
-                fromAddress: sourceUserAddress,
-                toAddress: destinationAddress,
-            });
-            const isEvmSwap = Number(fromChain) > 0 && Number(toChain) > 0;
-            const cosmosFallbackAddresses = quoteOnly || isEvmSwap ? undefined : await getCosmosFallbackAddresses();
-            const fromTokenAddress = fromToken.address;
-            const toTokenAddress = toToken.address;
-            const fromAmount = parseToBigInt(fromPrice?.toString() ?? "0", fromToken?.decimals).toString();
-            const fromAddress = sourceUserAddress ??
-                chainTypeToZeroAddressMap[fromChainType ?? ChainType.EVM];
-            const params = {
-                fromChain,
-                fromToken: fromTokenAddress,
-                fromAddress,
-                fromAmount,
-                toChain,
-                toToken: toTokenAddress,
-                toAddress: destinationAddress ?? "",
-                quoteOnly,
-                slippage: config.slippage === 0 ? undefined : config.slippage,
-                bypassGuardrails,
-                preHook,
-                postHook,
-            };
-            // If the swap is involving cosmos chains, we need to add the fallback addresses (if any)
-            if (cosmosFallbackAddresses &&
-                cosmosFallbackAddresses.length > 0 &&
-                cosmosFallbackAddresses[0].address) {
-                params.fallbackAddresses = cosmosFallbackAddresses;
-            }
-            const { route } = await squid.getRoute({
-                ...params,
-            });
-            // Cache the route data
-            // Useful when the getRoute mutation is called from another hook
-            queryClient.setQueryData(keys().transaction(fromChain, toChain, toToken.address, fromToken.address, fromPrice, config.slippage, config.enableGetGasOnDestination, sourceUserAddress, config.degenMode, destinationAddress, swapRoute?.fallbackAddress, quoteOnly, fromChainType, config.preHook, config.postHook), route);
-            return route;
-        },
+    return useMutation(async ({ fromChain, toChain, fromToken, toToken, sourceUserAddress, destinationAddress, fromPrice, bypassGuardrails, quoteOnly, fromChainType, postHook, preHook, }) => {
+        if (!fromChain || !toChain || !fromToken || !toToken || !fromPrice) {
+            return undefined;
+        }
+        // Dispatch requestQuote event
+        dispatchRequestQuoteEvent({
+            fromChain,
+            toChain,
+            fromToken: fromToken.address,
+            toToken: toToken.address,
+            fromAmount: fromPrice,
+            fromAddress: sourceUserAddress,
+            toAddress: destinationAddress,
+        });
+        const isEvmSwap = Number(fromChain) > 0 && Number(toChain) > 0;
+        const cosmosFallbackAddresses = quoteOnly || isEvmSwap ? undefined : await getCosmosFallbackAddresses();
+        const fromTokenAddress = fromToken.address;
+        const toTokenAddress = toToken.address;
+        const fromAmount = parseToBigInt(fromPrice?.toString() ?? "0", fromToken?.decimals).toString();
+        const fromAddress = sourceUserAddress ??
+            chainTypeToZeroAddressMap[fromChainType ?? ChainType.EVM];
+        const params = {
+            fromChain,
+            fromToken: fromTokenAddress,
+            fromAddress,
+            fromAmount,
+            toChain,
+            toToken: toTokenAddress,
+            toAddress: destinationAddress ?? "",
+            quoteOnly,
+            slippage: config.slippage === 0 ? undefined : config.slippage,
+            bypassGuardrails,
+            preHook,
+            postHook,
+        };
+        // If the swap is involving cosmos chains, we need to add the fallback addresses (if any)
+        if (cosmosFallbackAddresses &&
+            cosmosFallbackAddresses.length > 0 &&
+            cosmosFallbackAddresses[0].address) {
+            params.fallbackAddresses = cosmosFallbackAddresses;
+        }
+        const { route } = await squid.getRoute({
+            ...params,
+        });
+        // Cache the route data
+        // Useful when the getRoute mutation is called from another hook
+        queryClient.setQueryData(keys().transaction(fromChain, toChain, toToken.address, fromToken.address, fromPrice, config.slippage, config.enableGetGasOnDestination, sourceUserAddress, config.degenMode, destinationAddress, swapRoute?.fallbackAddress, quoteOnly, fromChainType, config.preHook, config.postHook), route);
+        return route;
     });
 };
-const useGetRouteWrapper = ({ enabled, gcTime = 5 * 60 * 1000, // 5 minutes
+const useGetRouteWrapper = ({ enabled, cacheTime = 5 * 60 * 1000, // 5 minutes
 staleTime = 60 * 1000, // 1 minute
 refetchOnWindowFocus = (query) => Date.now() - query.state.dataUpdatedAt > 30000, // Update if older than 30 seconds, when window is focused
 refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true, }) => {
@@ -40106,27 +40100,25 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
      * These data will be used to trigger the transaction
      * @returns {Route} Route data
      */
-    const squidRoute = useQuery({
-        queryKey: squidRouteQueryKeys,
-        queryFn: async () => {
-            const route = await getRouteMutation.mutateAsync({
-                fromChain: fromChain?.chainId,
-                toChain: toChain?.chainId,
-                fromToken,
-                toToken,
-                sourceUserAddress,
-                destinationAddress,
-                fromPrice,
-                bypassGuardrails: config.degenMode,
-                quoteOnly,
-                fromChainType: fromChain?.chainType,
-                postHook: config.postHook,
-                preHook: config.preHook,
-            });
-            return route;
-        },
+    const squidRoute = useQuery(squidRouteQueryKeys, async () => {
+        const route = await getRouteMutation.mutateAsync({
+            fromChain: fromChain?.chainId,
+            toChain: toChain?.chainId,
+            fromToken,
+            toToken,
+            sourceUserAddress,
+            destinationAddress,
+            fromPrice,
+            bypassGuardrails: config.degenMode,
+            quoteOnly,
+            fromChainType: fromChain?.chainType,
+            postHook: config.postHook,
+            preHook: config.preHook,
+        });
+        return route;
+    }, {
         enabled: queryEnabled,
-        gcTime,
+        cacheTime,
         staleTime,
         refetchOnWindowFocus,
         refetchIntervalInBackground,
@@ -40135,7 +40127,7 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
     /**
      * If last updated data is older than X seconds and the query is currently loading, show loading indicator
      */
-    const showLoading = squidRoute.isFetching || squidRoute.isRefetching;
+    const showLoading = useMemo(() => squidRoute.isFetching || squidRoute.isRefetching, [squidRoute.isFetching, squidRoute.isRefetching]);
     return {
         squidRoute,
         showLoading,
@@ -40167,7 +40159,7 @@ function useSendTransactionStatus({ chain, txHash, }) {
         transactionId: txHash,
         txType: HistoryTxType.SEND,
     });
-    const { data: status, isSuccess, isError, } = useQuery({
+    const { data: status } = useQuery({
         queryKey: keys().sendTransactionStatus(txHash, chain?.chainId),
         queryFn: async () => {
             if (!chain || !txHash)
@@ -40177,30 +40169,17 @@ function useSendTransactionStatus({ chain, txHash, }) {
                 txHash,
             });
         },
-        refetchInterval: chain
-            ? getSendTxStatusRefetchInterval(chain.chainType)
-            : false,
-        enabled: !!chain &&
-            !!txHash &&
-            !isTransactionComplete &&
-            !!currentHistoryItem &&
-            !isHistoryTransactionEnded({
-                data: currentHistoryItem?.data,
-                txType: HistoryTxType.SEND,
-            }),
-    });
-    useEffect(() => {
-        if (isSuccess) {
-            setIsTransactionComplete(status !== SendTransactionStatus.ONGOING);
-            if (status != null && !!txHash) {
+        onSuccess: (txStatus) => {
+            setIsTransactionComplete(txStatus !== SendTransactionStatus.ONGOING);
+            if (txStatus != null && !!txHash) {
                 replaceTransactionStatus({
                     txType: HistoryTxType.SEND,
-                    status: status,
+                    status: txStatus,
                     hash: txHash,
                 });
             }
-        }
-        if (isError) {
+        },
+        onError() {
             setIsTransactionComplete(true);
             if (txHash) {
                 replaceTransactionStatus({
@@ -40209,8 +40188,19 @@ function useSendTransactionStatus({ chain, txHash, }) {
                     hash: txHash,
                 });
             }
-        }
-    }, [isError, isSuccess, replaceTransactionStatus, status, txHash]);
+        },
+        refetchInterval: chain
+            ? getSendTxStatusRefetchInterval(chain.chainType)
+            : false,
+        enabled: !!chain &&
+            !!txHash &&
+            !isTransactionComplete &&
+            !!currentHistoryItem &&
+            !isHistoryTransactionEnded({
+                data: currentHistoryItem?.data,
+                txType: HistoryTxType.SEND,
+            }),
+    });
     return {
         status: status ?? currentHistoryItem?.data?.status,
     };
@@ -40244,9 +40234,7 @@ const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocu
             apiUrl: latestConfig.apiUrl,
         });
     }, [transaction]);
-    const transactionStatusQuery = useQuery({
-        queryKey: keys().swapTransactionStatus(transaction?.transactionId),
-        queryFn: fetchTransactionStatusWithLatestConfig,
+    const transactionStatusQuery = useQuery(keys().swapTransactionStatus(transaction?.transactionId), fetchTransactionStatusWithLatestConfig, {
         enabled: enabled &&
             transaction?.transactionId !== "0" &&
             !!transaction?.transactionId &&
@@ -40260,12 +40248,12 @@ const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocu
                 data: currentHistoryItem?.data,
                 txType: HistoryTxType.SWAP,
             }),
-        refetchInterval({ state }) {
+        refetchInterval(statusResponse) {
             // If the status response is something telling that the transaction
             // is finished, then store transaction history state if success
             // And return false to indicate refetcher to stop
-            if (state.data &&
-                transactionEndStatuses.includes(getTransactionStatus(state.data) ?? "")) {
+            if (statusResponse &&
+                transactionEndStatuses.includes(getTransactionStatus(statusResponse) ?? "")) {
                 return false;
             }
             return refetchInterval; // Had to handle a variable here because after onError, we want the interval to stop
@@ -40274,10 +40262,7 @@ const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocu
         retryDelay: getChainType(transaction?.fromChain) === ChainType.COSMOS ? 5000 : 3000,
         retry: getChainType(transaction?.fromChain) === ChainType.COSMOS ? 6 : retry,
         refetchOnWindowFocus,
-    });
-    useEffect(() => {
-        if (transactionStatusQuery.isSuccess && transactionStatusQuery.data) {
-            const statusResponse = transactionStatusQuery.data;
+        onSuccess: (statusResponse) => {
             // Dispatch event
             WidgetEvents.getInstance().dispatchSwapStatus(statusResponse.squidTransactionStatus ?? "");
             const endStatus = getTransactionEndStatus({ statusResponse });
@@ -40289,9 +40274,8 @@ const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocu
                     status: endStatus,
                 });
             }
-        }
-        if (transactionStatusQuery.isError) {
-            const error = transactionStatusQuery.error;
+        },
+        onError: (error) => {
             // `fetchTransactionStatus` throws an error with a cause being an AxiosError
             const is404 = is404Error(error.cause);
             if (!transaction?.transactionId)
@@ -40312,15 +40296,8 @@ const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocu
                     status: TransactionStatus.ERROR,
                 });
             }
-        }
-    }, [
-        transactionStatusQuery.isSuccess,
-        transactionStatusQuery.isError,
-        transaction?.transactionId,
-        transactionStatusQuery.error,
-        replaceSwapTransactionStatus,
-        transactionStatusQuery.data,
-    ]);
+        },
+    });
     return {
         transactionStatusQuery,
         latestStatus: transactionStatusQuery.data
@@ -40363,7 +40340,7 @@ const useAvatar = (seed = zeroAddress) => {
         },
         // data is static, so no need to refetch
         refetchOnWindowFocus: false,
-        gcTime: Infinity,
+        cacheTime: Infinity,
         staleTime: Infinity,
     });
     return avatar || "";
@@ -40405,40 +40382,38 @@ const useAddToken = (chainToCompare, tokenToCompare) => {
     /**
      * Add token to wallet
      */
-    const addToken = useMutation({
-        mutationFn: async ({ chain: _chain, token: _token, }) => {
-            const token = _token ?? tokenToCompare;
-            const chain = _chain ?? chainToCompare;
-            if (token && chain?.chainType === ChainType.EVM) {
-                const provider = await connector?.getProvider();
-                // Switch network if needed
-                if (currentEvmChain?.id.toString() !== token?.chainId) {
-                    try {
+    const addToken = useMutation(async ({ chain: _chain, token: _token, }) => {
+        const token = _token ?? tokenToCompare;
+        const chain = _chain ?? chainToCompare;
+        if (token && chain?.chainType === ChainType.EVM) {
+            const provider = await connector?.getProvider();
+            // Switch network if needed
+            if (currentEvmChain?.id.toString() !== token?.chainId) {
+                try {
+                    await switchChainAsync({
+                        chainId: +token.chainId,
+                    });
+                }
+                catch (error) {
+                    console.debug("Error switching network:", error);
+                    if (isEvmChainNotSupportedError(error)) {
+                        await addEthereumChain({
+                            chain,
+                            provider,
+                        });
                         await switchChainAsync({
                             chainId: +token.chainId,
                         });
                     }
-                    catch (error) {
-                        console.debug("Error switching network:", error);
-                        if (isEvmChainNotSupportedError(error)) {
-                            await addEthereumChain({
-                                chain,
-                                provider,
-                            });
-                            await switchChainAsync({
-                                chainId: +token.chainId,
-                            });
-                        }
-                    }
-                    // Metamask is not popping the second modal if we don't wait a bit
-                    // eslint-disable-next-line no-promise-executor-return
-                    await new Promise((resolve) => setTimeout(resolve, 100));
                 }
-                await addTokenToWallet({ token, provider });
+                // Metamask is not popping the second modal if we don't wait a bit
+                // eslint-disable-next-line no-promise-executor-return
+                await new Promise((resolve) => setTimeout(resolve, 100));
             }
-            // TODO: Implement keplr add token
-            return false;
+            await addTokenToWallet({ token, provider });
         }
+        // TODO: Implement keplr add token
+        return false;
     });
     return {
         addToken,
@@ -40643,9 +40618,7 @@ function useXrplTrustLine({ address, chain, token, amount }) {
             }
         },
         async onSuccess() {
-            queryClient.invalidateQueries({
-                queryKey: getPrefixKey(QueryKeys.XrplTrustLine),
-            });
+            queryClient.invalidateQueries(getPrefixKey(QueryKeys.XrplTrustLine));
         },
     });
     /**
@@ -40823,5 +40796,5 @@ const SquidProvider = ({ children, config, placeholder, }) => {
                                     React.createElement(CosmosProvider, null, children)))))))))) : (placeholder);
 };
 
-export { useNativeBalance as $, AxelarStatusResponseType as A, useAddressBookStore as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useAssetsColorsStore as E, useFavoriteTokensStore as F, useHistoryStore as G, HistoryTxType as H, useSendTransactionStore as I, useConfigStore as J, useSquidStore as K, useSwapRoutePersistStore as L, useTransactionStore as M, ConnectingWalletStatus as N, useWalletStore as O, useDepositAddress as P, useSwap as Q, useAllConnectedWalletBalances as R, SquidStatusErrorType as S, TransactionErrorType as T, useAllTokensWithBalanceForChainType as U, useCosmosBalance as V, WindowWalletFlag as W, XamanXrplNetwork as X, useEvmBalance as Y, useMultiChainBalance as Z, useMultipleTokenPrices as _, chainTypeToZeroAddressMap as a, groupTokensBySymbol as a$, useNativeTokenForChain as a0, useSingleTokenPrice as a1, useSquidTokens as a2, useHistoricalData as a3, useTokensData as a4, useEstimateSendTransaction as a5, useSendTransaction as a6, useSendTransactionGas as a7, useAllTransactionsStatus as a8, useApproval as a9, useGetFiatQuote as aA, useGetOnRampConfig as aB, useExecuteFiatQuote as aC, useCurrencyDetails as aD, useCountryDetails as aE, useAvailableQuotes as aF, useGetOnrampPaymentTypes as aG, useSuggestedFiatAmounts as aH, SquidProvider as aI, EnsService as aJ, getXummClient as aK, isXamanXAppContext as aL, getQueryHeaders as aM, getStatusCode as aN, is404Error as aO, assetsBaseUrl as aP, shareSubgraphId as aQ, sortTokensBySharedSubgraphIds as aR, getSupportedChainIdsForDirection as aS, filterChains as aT, filterTokens as aU, getTokenImage as aV, getNewSwapParamsFromInput as aW, sortAllTokens as aX, findToken as aY, findNativeToken as aZ, normalizeIbcAddress as a_, useEstimate as aa, useEstimatePriceImpact as ab, useExecuteTransaction as ac, useGetRoute as ad, useGetRouteWrapper as ae, useRouteWarnings as af, useSendTransactionStatus as ag, useSwapTransactionStatus as ah, useAvatar as ai, useHistory as aj, useUserParams as ak, useDebouncedValue as al, useAddToken as am, useAutoConnect as an, useEnsDataForAddress as ao, useEnsSearch as ap, useGnosisContext as aq, useIsSameAddressAndGnosisContext as ar, useIntegratorContext as as, useMultiChainWallet as at, useSigner as au, useWallet as av, useWallets as aw, useXrplTrustLine as ax, TX_STATUS_CONSTANTS as ay, FINAL_TRANSACTION_STATUSES as az, destinationAddressResetValue as b, formatTransactionHistoryDate as b$, groupTokensByChainId as b0, filterViewableTokens as b1, getSecretNetworkBalances as b2, getTokenAssetsKey as b3, fetchAssetsColors as b4, initializeSquidWithAssetsColors as b5, isEmptyObject as b6, normalizeTokenSymbol as b7, areTokenSymbolsCompatible as b8, isEvmosChain as b9, WidgetEvents as bA, EvmNetworkNotSupportedErrorCode as bB, addEthereumChain as bC, parseEvmAddress as bD, formatEvmWallet as bE, filterWagmiConnector as bF, getUserCountry as bG, getCountryData as bH, getCurrencyData as bI, adaptiveRound as bJ, getSuggestedAmountsForCurrency as bK, parseToBigInt as bL, roundNumericValue as bM, formatUnitsRounded as bN, formatTokenAmount as bO, formatUsdAmount as bP, trimExtraDecimals as bQ, getNumericValue as bR, cleanAmount as bS, convertTokenAmountToUSD as bT, convertUSDToTokenAmount as bU, calculateTotal24hChange as bV, searchTokens as bW, filterSolanaWallets as bX, isSolanaAddressValid as bY, executeSolanaSwap as bZ, executeSolanaTransfer as b_, getConfigWithDefaults as ba, randomIntFromInterval as bb, getTokensForChain as bc, getFirstAvailableChainId as bd, fetchHighestBalanceToken as be, getInitialOrDefaultTokenAddressForChain as bf, getInitialTokenAddressForChain as bg, filterTokensForDestination as bh, getInitialChainIdFromConfig as bi, getCosmosKey as bj, getKeysSettled as bk, getAllKeysForSupportedCosmosChains as bl, isCosmosAddressValid as bm, getCosmosSigningClient as bn, getCosmosChainInfosObject as bo, connectCosmosWallet as bp, isFallbackAddressNeeded as bq, suggestChainOrThrow as br, normalizeError as bs, transactionErrorCode as bt, isUserRejectionError as bu, getTransactionError as bv, handleTransactionErrorEvents as bw, isSwapRouteError as bx, isStatusError as by, createQuoteRequestParamsHash as bz, chainTypeToNativeTokenAddressMap as c, getAxelarExplorerTxUrl as c0, getSourceExplorerTxUrl as c1, getMainExplorerUrl as c2, formatDistance as c3, formatSeconds as c4, formatSwapTxStatusResponseForStorage as c5, simplifyRouteAction as c6, fetchSwapTransactionStatus as c7, compareTransactionIds as c8, isCoralBridgeAction as c9, calculateTotalUsdBalanceUSD as cA, addTokenToWallet as cB, isEvmChainNotSupportedError as cC, getWalletSupportedChainTypes as cD, getConnectorForChainType as cE, walletSupportsChainType as cF, connectWallet as cG, cancelConnectWallet as cH, isProblematicConnector as cI, mergeWallets as cJ, isXionSmartContractAddress as cK, isXrplAddressValid as cL, buildXrplTrustSetTx as cM, getXrplNetwork as cN, parseXrplPaymentTx as cO, sleep as ca, isDepositRoute as cb, isChainflipBridgeTransaction as cc, getHistoryTransactionId as cd, getStepStatuses as ce, getHalfSuccessState as cf, getStepsInfos as cg, getSwapTxStatusRefetchInterval as ch, getSendTxStatusRefetchInterval as ci, chainflipMultihopBridgeType as cj, getBridgeType as ck, getTransactionStatus as cl, getTransactionEndStatus as cm, isHistoryTransactionPending as cn, isHistoryTransactionFailed as co, isHistoryTransactionWarning as cp, isHistoryTransactionEnded as cq, formatHash as cr, isWalletAddressValid as cs, redirectToExtensionsStore as ct, accessProperty as cu, populateWallets as cv, getDefaultChain as cw, sortWallets as cx, areSameAddress as cy, sortAddressBook as cz, definedInWindow as d, fallbackAddressResetValue as e, formatBNToReadable as f, nativeCosmosTokenAddress as g, nativeEvmTokenAddress as h, nativeSolanaTokenAddress as i, nativeStellarTokenAddress as j, nativeSuiTokenAddress as k, nativeXrplTokenAddress as l, CosmosProvider as m, nativeBitcoinTokenAddress as n, SendTransactionStatus as o, TransactionStatus as p, useTrackSearchEmpty as q, useSquidChains as r, useClient as s, useCosmosForChain as t, useCosmosContext as u, useKeyboardNavigation as v, walletIconBaseUrl as w, useSquidQueryClient as x, useSquid as y, useStellarAccountActivation as z };
-//# sourceMappingURL=index-BA79s7uI.js.map
+export { useNativeBalance as $, AxelarStatusResponseType as A, useAddressBookStore as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useAssetsColorsStore as E, useFavoriteTokensStore as F, useHistoryStore as G, HistoryTxType as H, useSendTransactionStore as I, useConfigStore as J, useSquidStore as K, useSwapRoutePersistStore as L, useTransactionStore as M, ConnectingWalletStatus as N, useWalletStore as O, useDepositAddress as P, useSwap as Q, useAllConnectedWalletBalances as R, SquidStatusErrorType as S, TransactionErrorType as T, useAllTokensWithBalanceForChainType as U, useCosmosBalance as V, WindowWalletFlag as W, XamanXrplNetwork as X, useEvmBalance as Y, useMultiChainBalance as Z, useMultipleTokenPrices as _, chainTypeToZeroAddressMap as a, findToken as a$, useNativeTokenForChain as a0, useSingleTokenPrice as a1, useSquidTokens as a2, useHistoricalData as a3, useTokensData as a4, useEstimateSendTransaction as a5, useSendTransaction as a6, useSendTransactionGas as a7, useAllTransactionsStatus as a8, useApproval as a9, useGetFiatQuote as aA, useGetOnRampConfig as aB, useExecuteFiatQuote as aC, useFiatOnRampTxStatus as aD, useFiatTransactions as aE, useCurrencyDetails as aF, useCountryDetails as aG, useAvailableQuotes as aH, useRecommendedQuote as aI, useGetOnrampPaymentTypes as aJ, useSuggestedFiatAmounts as aK, SquidProvider as aL, EnsService as aM, getXummClient as aN, isXamanXAppContext as aO, getQueryHeaders as aP, getStatusCode as aQ, is404Error as aR, assetsBaseUrl as aS, shareSubgraphId as aT, sortTokensBySharedSubgraphIds as aU, getSupportedChainIdsForDirection as aV, filterChains as aW, filterTokens as aX, getTokenImage as aY, getNewSwapParamsFromInput as aZ, sortAllTokens as a_, useEstimate as aa, useEstimatePriceImpact as ab, useExecuteTransaction as ac, useGetRoute as ad, useGetRouteWrapper as ae, useRouteWarnings as af, useSendTransactionStatus as ag, useSwapTransactionStatus as ah, useAvatar as ai, useHistory as aj, useUserParams as ak, useDebouncedValue as al, useAddToken as am, useAutoConnect as an, useEnsDataForAddress as ao, useEnsSearch as ap, useGnosisContext as aq, useIsSameAddressAndGnosisContext as ar, useIntegratorContext as as, useMultiChainWallet as at, useSigner as au, useWallet as av, useWallets as aw, useXrplTrustLine as ax, TX_STATUS_CONSTANTS as ay, FINAL_TRANSACTION_STATUSES as az, destinationAddressResetValue as b, isSolanaAddressValid as b$, findNativeToken as b0, normalizeIbcAddress as b1, groupTokensBySymbol as b2, groupTokensByChainId as b3, filterViewableTokens as b4, getSecretNetworkBalances as b5, getTokenAssetsKey as b6, fetchAssetsColors as b7, initializeSquidWithAssetsColors as b8, isEmptyObject as b9, isSwapRouteError as bA, isStatusError as bB, createQuoteRequestParamsHash as bC, WidgetEvents as bD, EvmNetworkNotSupportedErrorCode as bE, addEthereumChain as bF, parseEvmAddress as bG, formatEvmWallet as bH, filterWagmiConnector as bI, getUserCountry as bJ, getCountryData as bK, getCurrencyData as bL, adaptiveRound as bM, getSuggestedAmountsForCurrency as bN, parseToBigInt as bO, roundNumericValue as bP, formatUnitsRounded as bQ, formatTokenAmount as bR, formatUsdAmount as bS, trimExtraDecimals as bT, getNumericValue as bU, cleanAmount as bV, convertTokenAmountToUSD as bW, convertUSDToTokenAmount as bX, calculateTotal24hChange as bY, searchTokens as bZ, filterSolanaWallets as b_, normalizeTokenSymbol as ba, areTokenSymbolsCompatible as bb, isEvmosChain as bc, getConfigWithDefaults as bd, randomIntFromInterval as be, getTokensForChain as bf, getFirstAvailableChainId as bg, fetchHighestBalanceToken as bh, getInitialOrDefaultTokenAddressForChain as bi, getInitialTokenAddressForChain as bj, filterTokensForDestination as bk, getInitialChainIdFromConfig as bl, getCosmosKey as bm, getKeysSettled as bn, getAllKeysForSupportedCosmosChains as bo, isCosmosAddressValid as bp, getCosmosSigningClient as bq, getCosmosChainInfosObject as br, connectCosmosWallet as bs, isFallbackAddressNeeded as bt, suggestChainOrThrow as bu, normalizeError as bv, transactionErrorCode as bw, isUserRejectionError as bx, getTransactionError as by, handleTransactionErrorEvents as bz, chainTypeToNativeTokenAddressMap as c, executeSolanaSwap as c0, executeSolanaTransfer as c1, formatTransactionHistoryDate as c2, getAxelarExplorerTxUrl as c3, getSourceExplorerTxUrl as c4, getMainExplorerUrl as c5, formatDistance as c6, formatSeconds as c7, formatSwapTxStatusResponseForStorage as c8, simplifyRouteAction as c9, sortWallets as cA, areSameAddress as cB, sortAddressBook as cC, calculateTotalUsdBalanceUSD as cD, addTokenToWallet as cE, isEvmChainNotSupportedError as cF, getWalletSupportedChainTypes as cG, getConnectorForChainType as cH, walletSupportsChainType as cI, connectWallet as cJ, cancelConnectWallet as cK, isProblematicConnector as cL, mergeWallets as cM, isXionSmartContractAddress as cN, isXrplAddressValid as cO, buildXrplTrustSetTx as cP, getXrplNetwork as cQ, parseXrplPaymentTx as cR, fetchSwapTransactionStatus as ca, compareTransactionIds as cb, isCoralBridgeAction as cc, sleep as cd, isDepositRoute as ce, isChainflipBridgeTransaction as cf, getHistoryTransactionId as cg, getStepStatuses as ch, getHalfSuccessState as ci, getStepsInfos as cj, getSwapTxStatusRefetchInterval as ck, getSendTxStatusRefetchInterval as cl, chainflipMultihopBridgeType as cm, getBridgeType as cn, getTransactionStatus as co, getTransactionEndStatus as cp, isHistoryTransactionPending as cq, isHistoryTransactionFailed as cr, isHistoryTransactionWarning as cs, isHistoryTransactionEnded as ct, formatHash as cu, isWalletAddressValid as cv, redirectToExtensionsStore as cw, accessProperty as cx, populateWallets as cy, getDefaultChain as cz, definedInWindow as d, fallbackAddressResetValue as e, formatBNToReadable as f, nativeCosmosTokenAddress as g, nativeEvmTokenAddress as h, nativeSolanaTokenAddress as i, nativeStellarTokenAddress as j, nativeSuiTokenAddress as k, nativeXrplTokenAddress as l, CosmosProvider as m, nativeBitcoinTokenAddress as n, SendTransactionStatus as o, TransactionStatus as p, useTrackSearchEmpty as q, useSquidChains as r, useClient as s, useCosmosForChain as t, useCosmosContext as u, useKeyboardNavigation as v, walletIconBaseUrl as w, useSquidQueryClient as x, useSquid as y, useStellarAccountActivation as z };
+//# sourceMappingURL=index-BKmIOD3t.js.map