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

package/dist/{index-CS74WzWX.js → index-BjIFR_GS.js}

@@ -4002,6 +4002,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) {
@@ -4052,7 +4066,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
@@ -4131,7 +4145,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
@@ -26816,9 +26841,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)) ? squidTypes.ChainType.EVM : squidTypes.ChainType.COSMOS),
-        });
+        const cache = queryCache?.find(keys().allTokensBalance(fetchCachedBalance?.address, !isNaN(Number(chainId)) ? squidTypes.ChainType.EVM : squidTypes.ChainType.COSMOS));
         // Parse result to TokenWithBalance[]
         const cacheResult = cache?.state.data ?? [];
         if (cacheResult.length > 0) {
@@ -27474,7 +27497,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 Promise.resolve().then(function () { return require('./secretService-U8WiVPay.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-DT8cWLsm.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -29233,16 +29256,13 @@ const useSquid = () => {
      * Fetch squid info
      * Will refetch every minute
      */
-    const squidInfoQuery = reactQuery.useQuery({
-        queryKey: keys().squidInfo(),
-        queryFn: async () => {
-            if (squid) {
-                await squid?.init();
-                initializeSquidWithAssetsColors(squid, assetsColors);
-                return squid;
-            }
-            return null;
+    const squidInfoQuery = reactQuery.useQuery(keys().squidInfo(), async () => {
+        if (squid) {
+            await squid?.init();
+            initializeSquidWithAssetsColors(squid, assetsColors);
+            return squid;
         }
+        return null;
     });
     const tokens = React.useMemo(() => {
         if ((squidInfoQuery?.data?.tokens ?? []).length > 0) {
@@ -29358,11 +29378,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: exports.HistoryTxType.BUY,
+                    orderId: transactionId,
+                    status: data.status,
+                    transactionHash: data.transactionHash,
+                });
+            }
+        },
+        onError: () => {
+            replaceTransactionStatus({
+                txType: exports.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 = React.useMemo(() => new OnrampService(), []);
     const { data: config } = useGetOnRampConfig();
     return reactQuery.useQuery({
@@ -29398,6 +29454,7 @@ const useGetFiatQuote = ({ fiatCurrency, cryptoCurrencyID, amount, region, payme
             return quoteResponse;
         },
         enabled: enabled && !!fiatCurrency && !!cryptoCurrencyID && amount > 0,
+        onSuccess,
     });
 };
 /**
@@ -29414,7 +29471,7 @@ const useGetOnRampConfig = () => {
             chains,
             tokens,
         }),
-        gcTime: 1000 * 60 * 60,
+        cacheTime: 1000 * 60 * 60,
         staleTime: 1000 * 60 * 30, // 30 minutes
     });
 };
@@ -29472,11 +29529,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 reactQuery.useQuery({
+        ...createTransactionStatusConfig({
+            transactionId,
+            walletAddress,
+            providerId,
+            replaceTransactionStatus,
+        }),
+    });
+};
+/**
+ * Tracks all pending fiat transactions.
+ */
+const useFiatTransactions = () => {
+    const transactions = useHistoryStore((state) => state.transactions.filter((tx) => tx.txType === exports.HistoryTxType.BUY));
+    const replaceTransactionStatus = useHistoryStore((state) => state.replaceTransactionStatus);
+    const pendingTransactions = React.useMemo(() => transactions?.filter((tx) => !FINAL_TRANSACTION_STATUSES.includes(tx.data.status)) ?? [], [transactions]);
+    const queries = reactQuery.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 React.useMemo(() => {
         if (!currencyCode)
             return undefined;
@@ -29489,7 +29584,7 @@ const useCurrencyDetails = (currencyCode) => {
             };
         }
         return undefined;
-    }, [currencyCode]);
+    }, [currencyCode, config?.supportedFiats]);
 };
 /**
  * Gets country details with flag URL and localized name.
@@ -29516,6 +29611,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 React.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.
@@ -29618,7 +29730,7 @@ const middleStepChecker = (statusResponse) => {
         }
         return exports.TransactionStatus.ERROR;
     }
-    if (statusResponse?.isLoading) {
+    if (statusResponse?.isInitialLoading) {
         return exports.TransactionStatus.INITIAL_LOADING;
     }
     return exports.TransactionStatus.ONGOING;
@@ -30063,7 +30175,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;
@@ -30164,13 +30276,11 @@ function useDebouncedValue(value, delay) {
  * @returns the ENS data of the given address
  */
 function useEnsDataForAddress({ address, options, }) {
-    const ensQuery = reactQuery.useQuery({
-        queryKey: keys().ensData(address?.toLowerCase()),
-        queryFn: () => EnsService.getEnsDataFromAddress(address),
+    const ensQuery = reactQuery.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;
 }
@@ -30186,16 +30296,14 @@ function useEnsDataForAddress({ address, options, }) {
  */
 function useEnsSearch({ name, enabled = true, delayMs = 500, }) {
     const debouncedName = useDebouncedValue(enabled ? name : undefined, delayMs);
-    const ensSearchQuery = reactQuery.useQuery({
-        queryKey: keys().ensSearch(debouncedName),
-        queryFn: () => {
-            const isExactEnsSearch = checkIsExactEns(debouncedName);
-            return isExactEnsSearch
-                ? EnsService.getExactEns(debouncedName)
-                : EnsService.searchEnsNames(debouncedName);
-        },
+    const ensSearchQuery = reactQuery.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;
 }
@@ -30216,25 +30324,23 @@ function checkIsExactEns(name = "") {
 
 const useCosmosForChain = (chain) => {
     const { keplrTypeWallet } = useCosmosSigner({ chain });
-    const cosmosAddressQuery = reactQuery.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 = reactQuery.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 === squidTypes.ChainType.COSMOS,
     });
     return cosmosAddressQuery;
@@ -30311,14 +30417,12 @@ const useIsSameAddressAndGnosisContext = () => {
 
 function useBitcoin() {
     const connectedBitcoinWallet = useWalletStore((store) => store.connectedWalletsByChainType[squidTypes.ChainType.BTC]);
-    const connectBitcoin = reactQuery.useMutation({
-        mutationFn: async ({ wallet, }) => {
-            const { address } = await wallet.connector.requestAccount();
-            return {
-                wallet,
-                address,
-            };
-        }
+    const connectBitcoin = reactQuery.useMutation(async ({ wallet, }) => {
+        const { address } = await wallet.connector.requestAccount();
+        return {
+            wallet,
+            address,
+        };
     });
     return {
         connectBitcoin,
@@ -30358,17 +30462,15 @@ function useEvm() {
     const { wallets } = useEvmWallets();
     const connectedEvmWallet = useWalletStore((store) => store.connectedWalletsByChainType[squidTypes.ChainType.EVM]);
     const recentEvmWalletId = useWalletStore((store) => store.recentConnectorIds[squidTypes.ChainType.EVM]);
-    const connectEvm = reactQuery.useMutation({
-        mutationFn: async ({ wallet, }) => {
-            const result = await connectAsync({
-                connector: wallet.connector,
-            });
-            const [firstAddress] = result.accounts;
-            return {
-                wallet,
-                address: firstAddress,
-            };
-        }
+    const connectEvm = reactQuery.useMutation(async ({ wallet, }) => {
+        const result = await connectAsync({
+            connector: wallet.connector,
+        });
+        const [firstAddress] = result.accounts;
+        return {
+            wallet,
+            address: firstAddress,
+        };
     });
     const disconnectEvm = React.useCallback(async () => {
         disconnect({ connector: connectedEvmWallet.wallet?.connector });
@@ -30462,23 +30564,21 @@ function useSolana() {
     const { wallets } = useSolanaWallets();
     const connectedSolanaWallet = useWalletStore((store) => store.connectedWalletsByChainType[squidTypes.ChainType.SOLANA]);
     const recentSolanaWalletId = useWalletStore((store) => store.recentConnectorIds[squidTypes.ChainType.SOLANA]);
-    const connectSolana = reactQuery.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 = reactQuery.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 = React.useCallback(async () => {
         await connectedSolanaWallet.wallet?.connector.disconnect();
@@ -30553,7 +30653,7 @@ function useStellarWallets() {
                 return;
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-BUdrOP04.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-DH1Yp2nE.js'); });
                 const modules = initializeAllModules();
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -30581,14 +30681,12 @@ function useStellarWallets() {
 function useStellar() {
     const { wallets } = useStellarWallets();
     const connectedStellarWallet = useWalletStore((store) => store.connectedWalletsByChainType[squidTypes.ChainType.STELLAR]);
-    const connectStellar = reactQuery.useMutation({
-        mutationFn: async ({ wallet, }) => {
-            const { address } = await wallet.connector.getAddress();
-            return {
-                wallet,
-                address,
-            };
-        }
+    const connectStellar = reactQuery.useMutation(async ({ wallet, }) => {
+        const { address } = await wallet.connector.getAddress();
+        return {
+            wallet,
+            address,
+        };
     });
     const disconnectStellar = React.useCallback(async () => {
         await connectedStellarWallet.wallet?.connector.disconnect?.();
@@ -30640,24 +30738,22 @@ function useSui() {
     const recentSuiWalletId = useWalletStore((store) => store.recentConnectorIds[squidTypes.ChainType.SUI]);
     const setConnectedWallet = useWalletStore((store) => store.setConnectedWallet);
     const disconnectWallet = useWalletStore((store) => store.disconnectWallet);
-    const connectSui = reactQuery.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 = reactQuery.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 = React.useCallback(async () => {
         await connectedSuiWallet.wallet?.connector.disconnect();
@@ -30966,14 +31062,12 @@ function useXrpl() {
     const recentXrplWalletId = useWalletStore((store) => store.recentConnectorIds[squidTypes.ChainType.XRPL]);
     const setConnectedWallet = useWalletStore((store) => store.setConnectedWallet);
     const disconnectWallet = useWalletStore((store) => store.disconnectWallet);
-    const connectXrpl = reactQuery.useMutation({
-        mutationFn: async ({ wallet, }) => {
-            const xrplConnectedAddress = await wallet.connector.connect();
-            return {
-                wallet,
-                address: xrplConnectedAddress,
-            };
-        }
+    const connectXrpl = reactQuery.useMutation(async ({ wallet, }) => {
+        const xrplConnectedAddress = await wallet.connector.connect();
+        return {
+            wallet,
+            address: xrplConnectedAddress,
+        };
     });
     const disconnectXrpl = React.useCallback(async () => {
         await connectedXrplWallet?.wallet?.connector.disconnect?.();
@@ -31360,19 +31454,18 @@ const useMultiChainWallet = (chain) => {
     /**
      * Change current network for desired chain
      */
-    const changeNetworkIfNeeded = reactQuery.useMutation({
-        mutationFn: async () => {
-            const isNotOnDesiredChain = chain?.chainType === squidTypes.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 = reactQuery.useMutation(async () => {
+        const isNotOnDesiredChain = chain?.chainType === squidTypes.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 viem.UserRejectedRequestError) {
                 return;
@@ -31384,7 +31477,7 @@ const useMultiChainWallet = (chain) => {
                     provider,
                 });
             }
-        }
+        },
     });
     const isChainTypeConnected = React.useCallback((chainType) => {
         if (isGnosisConnected && chainType === squidTypes.ChainType.EVM) {
@@ -31732,53 +31825,51 @@ const useCosmos = () => {
             clientWindow?.removeEventListener("keplr_keystorechange", () => handleKeplrAccountChanged());
         };
     }, [handleKeplrAccountChanged, clientWindow]);
-    const connectCosmos = reactQuery.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 = reactQuery.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(squidTypes.ChainType.COSMOS);
@@ -31862,64 +31953,13 @@ function useTrackSearchEmpty({ searchQuery, resultsLength, context, debounceMs =
     }, [context, debounceMs, resultsLength, searchQuery]);
 }
 
-const useKeyboardNavigation = (props) => {
-    const { itemsListRef, activeListItemClassName = "", onEscape } = props ?? {};
+const useKeyboardNavigation = ({ onEscape }) => {
     const onKeyDown = React.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]);
     React.useEffect(() => {
         document.addEventListener("keydown", onKeyDown, false);
         return () => {
@@ -31932,11 +31972,11 @@ const useSquidQueryClient = () => {
     const queryClient = reactQuery.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);
@@ -33443,19 +33483,17 @@ function useDepositAddress(squidRoute) {
         toggleDepositFlow(false);
         setDeposit(null);
     }, [toggleDepositFlow, setDeposit]);
-    const getRouteWithDeposit = reactQuery.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 = reactQuery.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,
@@ -33539,55 +33577,53 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         xrplTokens.length,
         stellarTokens.length,
     ]);
-    const query = reactQuery.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 squidTypes.ChainType.EVM:
-                    fetchedTokens = await getAllEvmTokensBalance(evmTokens, address, evmChains);
-                    break;
-                case squidTypes.ChainType.COSMOS:
-                    const addresses = await getAllKeysForSupportedCosmosChains(cosmosChains.map((c) => c.chainId), keplrTypeWallet);
-                    fetchedTokens = await getAllCosmosBalances({
-                        addresses,
-                        cosmosChains,
-                        cosmosTokens,
-                    });
-                    break;
-                case squidTypes.ChainType.SOLANA:
-                    fetchedTokens = await getAllSolanaTokensBalance(solanaTokens, address);
-                    break;
-                case squidTypes.ChainType.BTC:
-                    fetchedTokens = await getAllBitcoinTokensBalance(address, bitcoinTokens);
-                    break;
-                case squidTypes.ChainType.SUI:
-                    fetchedTokens = await getAllSuiTokensBalance(address, suiTokens, suiChains);
-                    break;
-                case squidTypes.ChainType.XRPL:
-                    fetchedTokens = await getAllXrplTokensBalance(address, xrplTokens, xrplChains);
-                    break;
-                case squidTypes.ChainType.STELLAR:
-                    fetchedTokens = await getAllStellarTokensBalance(address, stellarTokens, stellarChains);
-                    break;
-                default:
-                    fetchedTokens = placeholderData.tokens;
-                    break;
-            }
+    const query = reactQuery.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 squidTypes.ChainType.EVM:
+                fetchedTokens = await getAllEvmTokensBalance(evmTokens, address, evmChains);
+                break;
+            case squidTypes.ChainType.COSMOS:
+                const addresses = await getAllKeysForSupportedCosmosChains(cosmosChains.map((c) => c.chainId), keplrTypeWallet);
+                fetchedTokens = await getAllCosmosBalances({
+                    addresses,
+                    cosmosChains,
+                    cosmosTokens,
+                });
+                break;
+            case squidTypes.ChainType.SOLANA:
+                fetchedTokens = await getAllSolanaTokensBalance(solanaTokens, address);
+                break;
+            case squidTypes.ChainType.BTC:
+                fetchedTokens = await getAllBitcoinTokensBalance(address, bitcoinTokens);
+                break;
+            case squidTypes.ChainType.SUI:
+                fetchedTokens = await getAllSuiTokensBalance(address, suiTokens, suiChains);
+                break;
+            case squidTypes.ChainType.XRPL:
+                fetchedTokens = await getAllXrplTokensBalance(address, xrplTokens, xrplChains);
+                break;
+            case squidTypes.ChainType.STELLAR:
+                fetchedTokens = await getAllStellarTokensBalance(address, stellarTokens, stellarChains);
+                break;
+            default:
+                fetchedTokens = placeholderData.tokens;
+                break;
+        }
+        return {
+            tokens: fetchedTokens,
+            totalUsdBalance: calculateTotalUsdBalanceUSD(fetchedTokens),
+        };
+    }, {
         ...queryOptions,
         enabled: isQueryEnabled,
     });
@@ -33602,7 +33638,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,
 }, } = {}) => {
@@ -33683,9 +33719,9 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
     }, [balanceQueries]);
     // Aggregate loading states
     const queryStates = React.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),
@@ -33727,7 +33763,7 @@ function useNativeTokenForChain(chain) {
 
 const useEvmNativeBalance = ({ address, chain, }) => {
     const { isChainTypeConnected } = useWallet();
-    const { data: nativeEvmBalance, isPending } = wagmi.useBalance({
+    const { data: nativeEvmBalance, isLoading } = wagmi.useBalance({
         address: address,
         chainId: Number(chain?.chainId),
         query: {
@@ -33749,13 +33785,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,
@@ -33770,18 +33806,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 } = reactQuery.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 } = reactQuery.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 === squidTypes.ChainType.BTC &&
             nativeToken?.decimals != null &&
             isWalletAddressValid(chain, address),
@@ -33800,17 +33834,15 @@ const useBitcoinNativeBalance = ({ chain, address, }) => {
     }, [nativeToken?.decimals, rawBalance]);
     return {
         balance,
-        isPending,
+        isLoading,
     };
 };
 const useSolanaNativeBalance = ({ chain, address, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
-    const { data: rawBalance, isPending } = reactQuery.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 } = reactQuery.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 === squidTypes.ChainType.SOLANA,
@@ -33829,12 +33861,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,
@@ -33849,12 +33881,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,
@@ -33870,12 +33902,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,
@@ -33891,7 +33923,7 @@ const useStellarNativeBalance = ({ address, chain, }) => {
     }, [nativeToken?.decimals, rawBalance]);
     return {
         balance,
-        isPending,
+        isLoading,
     };
 };
 const useNativeBalance = (chain) => {
@@ -33899,28 +33931,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[squidTypes.ChainType.EVM], chain });
-    const { balance: nativeBitcoinBalance, isPending: isBitcoinPending } = useBitcoinNativeBalance({
+    const { balance: nativeEvmBalance, isLoading: isEvmLoading } = useEvmNativeBalance({ address: connectedAddresses[squidTypes.ChainType.EVM], chain });
+    const { balance: nativeBitcoinBalance, isLoading: isBitcoinLoading } = useBitcoinNativeBalance({
         address: connectedAddresses[squidTypes.ChainType.BTC],
         chain,
     });
-    const { balance: nativeSolanaBalance, isPending: isSolanaPending } = useSolanaNativeBalance({
+    const { balance: nativeSolanaBalance, isLoading: isSolanaLoading } = useSolanaNativeBalance({
         address: connectedAddresses[squidTypes.ChainType.SOLANA],
         chain,
     });
-    const { balance: nativeSuiBalance, isPending: isSuiPending } = useSuiNativeBalance({
+    const { balance: nativeSuiBalance, isLoading: isSuiLoading } = useSuiNativeBalance({
         address: connectedAddresses[squidTypes.ChainType.SUI],
         chain,
     });
-    const { balance: nativeXrplBalance, isPending: isXrplPending } = useXrplNativeBalance({
+    const { balance: nativeXrplBalance, isLoading: isXrpLoading } = useXrplNativeBalance({
         address: connectedAddresses[squidTypes.ChainType.XRPL],
         chain,
     });
-    const { balance: nativeStellarBalance, isPending: isStellarPending } = useStellarNativeBalance({
+    const { balance: nativeStellarBalance, isLoading: isStellarLoading } = useStellarNativeBalance({
         address: connectedAddresses[squidTypes.ChainType.STELLAR],
         chain,
     });
@@ -33965,36 +33997,36 @@ const useNativeBalance = (chain) => {
         nativeXrplBalance,
         nativeStellarBalance,
     ]);
-    const isPending = React.useMemo(() => {
+    const isLoading = React.useMemo(() => {
         if (!chain?.chainType)
             return false;
         switch (chain.chainType) {
             case squidTypes.ChainType.EVM:
-                return isEvmPending;
+                return isEvmLoading;
             case squidTypes.ChainType.COSMOS:
-                return isCosmosPending;
+                return isCosmosLoading;
             case squidTypes.ChainType.BTC:
-                return isBitcoinPending;
+                return isBitcoinLoading;
             case squidTypes.ChainType.SOLANA:
-                return isSolanaPending;
+                return isSolanaLoading;
             case squidTypes.ChainType.SUI:
-                return isSuiPending;
+                return isSuiLoading;
             case squidTypes.ChainType.XRPL:
-                return isXrplPending;
+                return isXrpLoading;
             case squidTypes.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;
@@ -34003,7 +34035,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 } = wagmi.useBalance({
+    const { data: nativeBalance, isLoading: isNativeTokenLoading } = wagmi.useBalance({
         address: userAddressParsed,
         chainId: Number(chain?.chainId),
         query: {
@@ -34019,7 +34051,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 } = wagmi.useReadContract({
+    const { data: erc20Balance, isLoading: isErc20Loading } = wagmi.useReadContract({
         address: token?.address,
         abi: viem.erc20Abi,
         functionName: "balanceOf",
@@ -34035,15 +34067,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 } = reactQuery.useQuery({
+    const { data: balance = "0", isLoading } = reactQuery.useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token || chain?.chainType !== squidTypes.ChainType.COSMOS) {
@@ -34063,10 +34095,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 } = reactQuery.useQuery({
+    const { data: balance = "0", isLoading } = reactQuery.useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token)
@@ -34081,11 +34113,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,
     });
@@ -34094,10 +34126,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 } = reactQuery.useQuery({
+    const { data: balance = "0", isLoading } = reactQuery.useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress ||
@@ -34117,10 +34149,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 } = reactQuery.useQuery({
+    const { data: balance = "0", isLoading } = reactQuery.useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token || !chain)
@@ -34137,10 +34169,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 } = reactQuery.useQuery({
+    const { data: balance = "0", isLoading } = reactQuery.useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token || !chain)
@@ -34157,7 +34189,7 @@ const useStellarBalance = ({ userAddress, chain, enabled, token, refreshInterval
         refetchInterval: refreshIntervalMs,
         retry: 2,
     });
-    return { balance, isPending };
+    return { balance, isLoading };
 };
 
 /**
@@ -34278,7 +34310,7 @@ const useMultipleTokenPrices = (tokens) => {
     return {
         tokenPrices,
         getTokenPrice,
-        isPending: coinGeckoQuery.isPending,
+        isLoading: coinGeckoQuery.isLoading,
         isError: coinGeckoQuery.isError,
         error: coinGeckoQuery.error,
         refetch: coinGeckoQuery.refetch,
@@ -34427,17 +34459,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 reactQuery.useQuery({
-        queryKey: keys().historicalData(coingeckoId, timeFrame),
-        queryFn: () => fetchHistoricalData(coingeckoId, timeFrame),
+    return reactQuery.useQuery(keys().historicalData(coingeckoId, timeFrame), () => fetchHistoricalData(coingeckoId, timeFrame), {
         staleTime: 5 * 60 * 1000,
         enabled: !!coingeckoId,
     });
 };
 const useTokensData = (tokens) => {
-    return reactQuery.useQuery({
-        queryKey: keys().tokensData(tokens),
-        queryFn: () => fetchTokensData(tokens),
+    return reactQuery.useQuery(keys().tokensData(tokens), () => fetchTokensData(tokens), {
         staleTime: 60 * 1000,
         enabled: !!tokens && tokens.length > 0,
     });
@@ -34742,7 +34770,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,
@@ -34787,7 +34815,7 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
     return {
         estimatedGas,
         isBalanceEnough,
-        isPending,
+        isLoading,
         isNativeBalanceEnoughToPayGasFees,
         minAmountValueWarnMsg,
     };
@@ -35194,12 +35222,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,
@@ -35219,12 +35245,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,
         });
     }, [
@@ -35370,9 +35394,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: exports.HistoryTxType.SEND,
@@ -35699,10 +35721,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;
@@ -35762,7 +35783,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),
     };
@@ -36021,18 +36042,16 @@ const useApproval = ({ squidRoute, }) => {
      * On Error: Showing the error message if any
      * @returns {boolean} approved
      */
-    const routeApproved = reactQuery.useQuery({
-        queryKey: keys().routeApproved(squidRoute, allowanceInWei),
-        queryFn: async () => {
-            // Approval is only needed for EVM chains
-            if (getChainType(squidRoute?.params.fromChain) === squidTypes.ChainType.EVM) {
-                return hasAllowance;
-            }
-            return true;
-        },
+    const routeApproved = reactQuery.useQuery(keys().routeApproved(squidRoute, allowanceInWei), async () => {
+        // Approval is only needed for EVM chains
+        if (getChainType(squidRoute?.params.fromChain) === squidTypes.ChainType.EVM) {
+            return hasAllowance;
+        }
+        return true;
+    }, {
         enabled: !!squidRoute &&
             !!sourceUserAddress &&
-            !allowanceQuery?.isPending &&
+            !allowanceQuery?.isLoading &&
             allowanceQuery?.isFetched,
     });
     // USDT has a very specific way of handling approvals
@@ -36121,84 +36140,81 @@ const useApproval = ({ squidRoute, }) => {
     /**
      * Manually approve route if necessary
      */
-    const approveRoute = reactQuery.useMutation({
-        mutationFn: async () => {
-            try {
-                if (fromToken?.address === nativeEvmTokenAddress) {
-                    return true;
+    const approveRoute = reactQuery.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.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.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) {
@@ -39318,10 +39334,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 = React.useCallback((route) => {
         WidgetEvents.getInstance().dispatchSwapTxSignatureRequested({
@@ -39339,64 +39353,62 @@ const useExecuteTransaction = (squidRoute) => {
             txHash,
         }, findToken);
     }, [findToken]);
-    const swapMutationCosmos = reactQuery.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: exports.TransactionStatus.ONGOING,
-                            sourceStatus: exports.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: exports.TransactionStatus.ONGOING,
-                            sourceStatus: exports.TransactionStatus.ONGOING,
-                            axelarUrl: undefined,
-                            id,
+    const swapMutationCosmos = reactQuery.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: exports.TransactionStatus.ONGOING,
+                        sourceStatus: exports.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: exports.TransactionStatus.ONGOING,
+                        sourceStatus: exports.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
@@ -39449,126 +39461,97 @@ const useExecuteTransaction = (squidRoute) => {
             throw error;
         }
     }, [replaceSwapTransactionNonce, setTransactionState, sourceUserAddress]);
-    const swapMutationEvm = reactQuery.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 = reactQuery.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: exports.TransactionStatus.INITIAL_LOADING,
+                sourceStatus: exports.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: exports.TransactionStatus.INITIAL_LOADING,
-                    sourceStatus: exports.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: exports.TransactionStatus.INITIAL_LOADING,
+                sourceStatus: exports.TransactionStatus.ONGOING,
+                userAddress: sourceUserAddress,
+                axelarUrl: undefined,
+                id,
+            });
+        }
+    });
+    const swapMutationSolana = reactQuery.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: exports.TransactionStatus.INITIAL_LOADING,
-                    sourceStatus: exports.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 = reactQuery.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: exports.TransactionStatus.INITIAL_LOADING,
-                                sourceStatus: exports.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: exports.TransactionStatus.INITIAL_LOADING,
                             sourceStatus: exports.TransactionStatus.ONGOING,
@@ -39585,13 +39568,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: exports.TransactionStatus.INITIAL_LOADING,
+                        sourceStatus: exports.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);
@@ -39612,9 +39621,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,
@@ -39631,207 +39638,197 @@ const useExecuteTransaction = (squidRoute) => {
             });
         },
     });
-    const swapMutationBitcoin = reactQuery.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: exports.TransactionStatus.INITIAL_LOADING,
-                        sourceStatus: exports.TransactionStatus.ONGOING,
-                        axelarUrl: undefined,
-                        id,
-                    });
-                    if (txParams) {
-                        addSwapTransaction({
-                            ...txParams,
-                            params: route.params,
-                            estimate: route.estimate,
-                        });
-                    }
-                }
-            }
-            else {
-                throw new Error("Need all parameters");
-            }
-        },
-    });
-    const swapMutationXrpl = reactQuery.useMutation({
-        mutationFn: async ({ id, route }) => {
-            if (!route?.transactionRequest || !xrplSigner) {
-                throw new Error("Need all parameters");
-            }
-            if (route.transactionRequest.type !== squidTypes.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: exports.TransactionStatus.ONGOING,
-                status: exports.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 = reactQuery.useMutation({
-        mutationFn: async ({ id, route }) => {
-            if (!route || !suiSigner || !fromChain) {
-                throw new Error("Need all parameters");
-            }
-            if (route.transactionRequest?.type !== squidTypes.SquidDataType.OnChainExecution) {
-                throw new Error("Invalid route type");
-            }
-            const suiWalletState = connectedWalletsByChainType[squidTypes.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 = transactions.Transaction.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 = reactQuery.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: exports.TransactionStatus.INITIAL_LOADING,
-                sourceStatus: exports.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: exports.TransactionStatus.INITIAL_LOADING,
+                    sourceStatus: exports.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 = reactQuery.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 = stellarSdk.xdr.Operation.fromXDR(xdrHex, "hex");
-            const builtTransaction = new stellarSdk.TransactionBuilder(account, {
-                fee: gasPrice || (BigInt(stellarSdk.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 = reactQuery.useMutation(async ({ id, route }) => {
+        if (!route?.transactionRequest || !xrplSigner) {
+            throw new Error("Need all parameters");
+        }
+        if (route.transactionRequest.type !== squidTypes.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: exports.TransactionStatus.ONGOING,
+            status: exports.TransactionStatus.ONGOING,
+            route: route,
+            userAddress: sourceUserAddress,
+        });
+        if (txParams && route) {
+            addSwapTransaction({
+                ...txParams,
+                params: route.params,
+                estimate: route.estimate,
             });
-            const signedTransaction = new stellarSdk.Transaction(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: exports.TransactionStatus.INITIAL_LOADING,
-                sourceStatus: exports.TransactionStatus.ONGOING,
-                id,
+        }
+        if (txRes.status !== XrplTxStatus.SUCCESS) {
+            throw new Error(`Transaction failed with status: ${txRes.status}`);
+        }
+    }, {});
+    const swapMutationSui = reactQuery.useMutation(async ({ id, route }) => {
+        if (!route || !suiSigner || !fromChain) {
+            throw new Error("Need all parameters");
+        }
+        if (route.transactionRequest?.type !== squidTypes.SquidDataType.OnChainExecution) {
+            throw new Error("Invalid route type");
+        }
+        const suiWalletState = connectedWalletsByChainType[squidTypes.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 = transactions.Transaction.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: exports.TransactionStatus.INITIAL_LOADING,
+            sourceStatus: exports.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 = reactQuery.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 = stellarSdk.xdr.Operation.fromXDR(xdrHex, "hex");
+        const builtTransaction = new stellarSdk.TransactionBuilder(account, {
+            fee: gasPrice || (BigInt(stellarSdk.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 stellarSdk.Transaction(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: exports.TransactionStatus.INITIAL_LOADING,
+            sourceStatus: exports.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 = React.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,
@@ -39883,39 +39880,38 @@ const useExecuteTransaction = (squidRoute) => {
         setTransactionStoreState,
         squidRoute,
     ]);
-    const swapMutation = reactQuery.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 squidTypes.ChainType.COSMOS: {
-                    return swapMutationCosmos.mutateAsync(mutationParams);
-                }
-                case squidTypes.ChainType.EVM: {
-                    return swapMutationEvm.mutateAsync(mutationParams);
-                }
-                case squidTypes.ChainType.BTC: {
-                    return swapMutationBitcoin.mutateAsync(mutationParams);
-                }
-                case squidTypes.ChainType.SOLANA: {
-                    return swapMutationSolana.mutateAsync(mutationParams);
-                }
-                case squidTypes.ChainType.SUI: {
-                    return swapMutationSui.mutateAsync(mutationParams);
-                }
-                case squidTypes.ChainType.XRPL: {
-                    return swapMutationXrpl.mutateAsync(mutationParams);
-                }
-                case squidTypes.ChainType.STELLAR: {
-                    return swapMutationStellar.mutateAsync(mutationParams);
-                }
-                default:
-                    throw new Error(`Swap mutation not implemented for chain type: ${sourceChain.chainType}`);
+    const swapMutation = reactQuery.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 squidTypes.ChainType.COSMOS: {
+                return swapMutationCosmos.mutateAsync(mutationParams);
             }
-        },
+            case squidTypes.ChainType.EVM: {
+                return swapMutationEvm.mutateAsync(mutationParams);
+            }
+            case squidTypes.ChainType.BTC: {
+                return swapMutationBitcoin.mutateAsync(mutationParams);
+            }
+            case squidTypes.ChainType.SOLANA: {
+                return swapMutationSolana.mutateAsync(mutationParams);
+            }
+            case squidTypes.ChainType.SUI: {
+                return swapMutationSui.mutateAsync(mutationParams);
+            }
+            case squidTypes.ChainType.XRPL: {
+                return swapMutationXrpl.mutateAsync(mutationParams);
+            }
+            case squidTypes.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,
@@ -39964,7 +39960,7 @@ const useExecuteTransaction = (squidRoute) => {
         toToken,
         toChain,
         fromChain,
-        isPending: swapMutation.isPending,
+        isLoading: swapMutation.isLoading,
         error: swapMutation.error,
     };
 };
@@ -40025,59 +40021,57 @@ const useGetRoute = () => {
      * These data will be used to trigger the transaction
      * @returns {Route} Route data
      */
-    return reactQuery.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 ?? squidTypes.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 reactQuery.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 ?? squidTypes.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, }) => {
@@ -40127,27 +40121,25 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
      * These data will be used to trigger the transaction
      * @returns {Route} Route data
      */
-    const squidRoute = reactQuery.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 = reactQuery.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,
@@ -40156,7 +40148,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 = React.useMemo(() => squidRoute.isFetching || squidRoute.isRefetching, [squidRoute.isFetching, squidRoute.isRefetching]);
     return {
         squidRoute,
         showLoading,
@@ -40188,7 +40180,7 @@ function useSendTransactionStatus({ chain, txHash, }) {
         transactionId: txHash,
         txType: exports.HistoryTxType.SEND,
     });
-    const { data: status, isSuccess, isError, } = reactQuery.useQuery({
+    const { data: status } = reactQuery.useQuery({
         queryKey: keys().sendTransactionStatus(txHash, chain?.chainId),
         queryFn: async () => {
             if (!chain || !txHash)
@@ -40198,30 +40190,17 @@ function useSendTransactionStatus({ chain, txHash, }) {
                 txHash,
             });
         },
-        refetchInterval: chain
-            ? getSendTxStatusRefetchInterval(chain.chainType)
-            : false,
-        enabled: !!chain &&
-            !!txHash &&
-            !isTransactionComplete &&
-            !!currentHistoryItem &&
-            !isHistoryTransactionEnded({
-                data: currentHistoryItem?.data,
-                txType: exports.HistoryTxType.SEND,
-            }),
-    });
-    React.useEffect(() => {
-        if (isSuccess) {
-            setIsTransactionComplete(status !== exports.SendTransactionStatus.ONGOING);
-            if (status != null && !!txHash) {
+        onSuccess: (txStatus) => {
+            setIsTransactionComplete(txStatus !== exports.SendTransactionStatus.ONGOING);
+            if (txStatus != null && !!txHash) {
                 replaceTransactionStatus({
                     txType: exports.HistoryTxType.SEND,
-                    status: status,
+                    status: txStatus,
                     hash: txHash,
                 });
             }
-        }
-        if (isError) {
+        },
+        onError() {
             setIsTransactionComplete(true);
             if (txHash) {
                 replaceTransactionStatus({
@@ -40230,8 +40209,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: exports.HistoryTxType.SEND,
+            }),
+    });
     return {
         status: status ?? currentHistoryItem?.data?.status,
     };
@@ -40265,9 +40255,7 @@ const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocu
             apiUrl: latestConfig.apiUrl,
         });
     }, [transaction]);
-    const transactionStatusQuery = reactQuery.useQuery({
-        queryKey: keys().swapTransactionStatus(transaction?.transactionId),
-        queryFn: fetchTransactionStatusWithLatestConfig,
+    const transactionStatusQuery = reactQuery.useQuery(keys().swapTransactionStatus(transaction?.transactionId), fetchTransactionStatusWithLatestConfig, {
         enabled: enabled &&
             transaction?.transactionId !== "0" &&
             !!transaction?.transactionId &&
@@ -40281,12 +40269,12 @@ const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocu
                 data: currentHistoryItem?.data,
                 txType: exports.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
@@ -40295,10 +40283,7 @@ const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocu
         retryDelay: getChainType(transaction?.fromChain) === squidTypes.ChainType.COSMOS ? 5000 : 3000,
         retry: getChainType(transaction?.fromChain) === squidTypes.ChainType.COSMOS ? 6 : retry,
         refetchOnWindowFocus,
-    });
-    React.useEffect(() => {
-        if (transactionStatusQuery.isSuccess && transactionStatusQuery.data) {
-            const statusResponse = transactionStatusQuery.data;
+        onSuccess: (statusResponse) => {
             // Dispatch event
             WidgetEvents.getInstance().dispatchSwapStatus(statusResponse.squidTransactionStatus ?? "");
             const endStatus = getTransactionEndStatus({ statusResponse });
@@ -40310,9 +40295,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)
@@ -40333,15 +40317,8 @@ const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocu
                     status: exports.TransactionStatus.ERROR,
                 });
             }
-        }
-    }, [
-        transactionStatusQuery.isSuccess,
-        transactionStatusQuery.isError,
-        transaction?.transactionId,
-        transactionStatusQuery.error,
-        replaceSwapTransactionStatus,
-        transactionStatusQuery.data,
-    ]);
+        },
+    });
     return {
         transactionStatusQuery,
         latestStatus: transactionStatusQuery.data
@@ -40384,7 +40361,7 @@ const useAvatar = (seed = zeroAddress) => {
         },
         // data is static, so no need to refetch
         refetchOnWindowFocus: false,
-        gcTime: Infinity,
+        cacheTime: Infinity,
         staleTime: Infinity,
     });
     return avatar || "";
@@ -40426,40 +40403,38 @@ const useAddToken = (chainToCompare, tokenToCompare) => {
     /**
      * Add token to wallet
      */
-    const addToken = reactQuery.useMutation({
-        mutationFn: async ({ chain: _chain, token: _token, }) => {
-            const token = _token ?? tokenToCompare;
-            const chain = _chain ?? chainToCompare;
-            if (token && chain?.chainType === squidTypes.ChainType.EVM) {
-                const provider = await connector?.getProvider();
-                // Switch network if needed
-                if (currentEvmChain?.id.toString() !== token?.chainId) {
-                    try {
+    const addToken = reactQuery.useMutation(async ({ chain: _chain, token: _token, }) => {
+        const token = _token ?? tokenToCompare;
+        const chain = _chain ?? chainToCompare;
+        if (token && chain?.chainType === squidTypes.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,
@@ -40664,9 +40639,7 @@ function useXrplTrustLine({ address, chain, token, amount }) {
             }
         },
         async onSuccess() {
-            queryClient.invalidateQueries({
-                queryKey: getPrefixKey(QueryKeys.XrplTrustLine),
-            });
+            queryClient.invalidateQueries(getPrefixKey(QueryKeys.XrplTrustLine));
         },
     });
     /**
@@ -41024,6 +40997,8 @@ exports.useEvmBalance = useEvmBalance;
 exports.useExecuteFiatQuote = useExecuteFiatQuote;
 exports.useExecuteTransaction = useExecuteTransaction;
 exports.useFavoriteTokensStore = useFavoriteTokensStore;
+exports.useFiatOnRampTxStatus = useFiatOnRampTxStatus;
+exports.useFiatTransactions = useFiatTransactions;
 exports.useGetFiatQuote = useGetFiatQuote;
 exports.useGetOnRampConfig = useGetOnRampConfig;
 exports.useGetOnrampPaymentTypes = useGetOnrampPaymentTypes;
@@ -41041,6 +41016,7 @@ exports.useMultiChainWallet = useMultiChainWallet;
 exports.useMultipleTokenPrices = useMultipleTokenPrices;
 exports.useNativeBalance = useNativeBalance;
 exports.useNativeTokenForChain = useNativeTokenForChain;
+exports.useRecommendedQuote = useRecommendedQuote;
 exports.useRouteWarnings = useRouteWarnings;
 exports.useSendTransaction = useSendTransaction;
 exports.useSendTransactionGas = useSendTransactionGas;
@@ -41068,4 +41044,4 @@ exports.useWallets = useWallets;
 exports.useXrplTrustLine = useXrplTrustLine;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-CS74WzWX.js.map
+//# sourceMappingURL=index-BjIFR_GS.js.map