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

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

@@ -26816,7 +26816,9 @@ const fetchHighestBalanceToken = (fetchCachedBalance, chainId) => {
     if (fetchCachedBalance) {
         const queryCache = fetchCachedBalance?.queryClient?.getQueryCache();
         // get cached balance from key
-        const cache = queryCache?.find(keys().allTokensBalance(fetchCachedBalance?.address, !isNaN(Number(chainId)) ? squidTypes.ChainType.EVM : squidTypes.ChainType.COSMOS));
+        const cache = queryCache?.find({
+            queryKey: 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) {
@@ -27472,7 +27474,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-DdVLwd-q.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-U8WiVPay.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -29231,13 +29233,16 @@ const useSquid = () => {
      * Fetch squid info
      * Will refetch every minute
      */
-    const squidInfoQuery = reactQuery.useQuery(keys().squidInfo(), async () => {
-        if (squid) {
-            await squid?.init();
-            initializeSquidWithAssetsColors(squid, assetsColors);
-            return squid;
+    const squidInfoQuery = reactQuery.useQuery({
+        queryKey: keys().squidInfo(),
+        queryFn: async () => {
+            if (squid) {
+                await squid?.init();
+                initializeSquidWithAssetsColors(squid, assetsColors);
+                return squid;
+            }
+            return null;
         }
-        return null;
     });
     const tokens = React.useMemo(() => {
         if ((squidInfoQuery?.data?.tokens ?? []).length > 0) {
@@ -29353,47 +29358,11 @@ 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, onSuccess, }) => {
+const useGetFiatQuote = ({ fiatCurrency, cryptoCurrencyID, amount, region, paymentMethod, enabled = true, }) => {
     const service = React.useMemo(() => new OnrampService(), []);
     const { data: config } = useGetOnRampConfig();
     return reactQuery.useQuery({
@@ -29429,7 +29398,6 @@ const useGetFiatQuote = ({ fiatCurrency, cryptoCurrencyID, amount, region, payme
             return quoteResponse;
         },
         enabled: enabled && !!fiatCurrency && !!cryptoCurrencyID && amount > 0,
-        onSuccess,
     });
 };
 /**
@@ -29446,7 +29414,7 @@ const useGetOnRampConfig = () => {
             chains,
             tokens,
         }),
-        cacheTime: 1000 * 60 * 60,
+        gcTime: 1000 * 60 * 60,
         staleTime: 1000 * 60 * 30, // 30 minutes
     });
 };
@@ -29504,49 +29472,11 @@ 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;
@@ -29559,7 +29489,7 @@ const useCurrencyDetails = (currencyCode) => {
             };
         }
         return undefined;
-    }, [currencyCode, config?.supportedFiats]);
+    }, [currencyCode]);
 };
 /**
  * Gets country details with flag URL and localized name.
@@ -29586,23 +29516,6 @@ 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.
@@ -29705,7 +29618,7 @@ const middleStepChecker = (statusResponse) => {
         }
         return exports.TransactionStatus.ERROR;
     }
-    if (statusResponse?.isInitialLoading) {
+    if (statusResponse?.isLoading) {
         return exports.TransactionStatus.INITIAL_LOADING;
     }
     return exports.TransactionStatus.ONGOING;
@@ -30150,7 +30063,7 @@ const useClient = () => {
         queryFn: getUserCountry,
         enabled: isClient,
         retry: false,
-        cacheTime: CACHE_TIME,
+        gcTime: CACHE_TIME,
         staleTime: STALE_TIME,
     });
     const userCountry = countryData?.countryCode || DEFAULT_COUNTRY_CODE;
@@ -30251,11 +30164,13 @@ function useDebouncedValue(value, delay) {
  * @returns the ENS data of the given address
  */
 function useEnsDataForAddress({ address, options, }) {
-    const ensQuery = reactQuery.useQuery(keys().ensData(address?.toLowerCase()), () => EnsService.getEnsDataFromAddress(address), {
+    const ensQuery = reactQuery.useQuery({
+        queryKey: keys().ensData(address?.toLowerCase()),
+        queryFn: () => EnsService.getEnsDataFromAddress(address),
         ...options,
         enabled: Boolean(address?.trim()) &&
             (options?.enabled === undefined ? true : options.enabled),
-        cacheTime: Infinity,
+        gcTime: Infinity,
     });
     return ensQuery;
 }
@@ -30271,14 +30186,16 @@ function useEnsDataForAddress({ address, options, }) {
  */
 function useEnsSearch({ name, enabled = true, delayMs = 500, }) {
     const debouncedName = useDebouncedValue(enabled ? name : undefined, delayMs);
-    const ensSearchQuery = reactQuery.useQuery(keys().ensSearch(debouncedName), () => {
-        const isExactEnsSearch = checkIsExactEns(debouncedName);
-        return isExactEnsSearch
-            ? EnsService.getExactEns(debouncedName)
-            : EnsService.searchEnsNames(debouncedName);
-    }, {
+    const ensSearchQuery = reactQuery.useQuery({
+        queryKey: keys().ensSearch(debouncedName),
+        queryFn: () => {
+            const isExactEnsSearch = checkIsExactEns(debouncedName);
+            return isExactEnsSearch
+                ? EnsService.getExactEns(debouncedName)
+                : EnsService.searchEnsNames(debouncedName);
+        },
         enabled: Boolean(debouncedName?.trim()) && enabled,
-        cacheTime: Infinity,
+        gcTime: Infinity,
     });
     return ensSearchQuery;
 }
@@ -30299,23 +30216,25 @@ function checkIsExactEns(name = "") {
 
 const useCosmosForChain = (chain) => {
     const { keplrTypeWallet } = useCosmosSigner({ chain });
-    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 ?? "";
-        }
-    }, {
+    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 ?? "";
+            }
+        },
         enabled: !!keplrTypeWallet && chain?.chainType === squidTypes.ChainType.COSMOS,
     });
     return cosmosAddressQuery;
@@ -30392,12 +30311,14 @@ const useIsSameAddressAndGnosisContext = () => {
 
 function useBitcoin() {
     const connectedBitcoinWallet = useWalletStore((store) => store.connectedWalletsByChainType[squidTypes.ChainType.BTC]);
-    const connectBitcoin = reactQuery.useMutation(async ({ wallet, }) => {
-        const { address } = await wallet.connector.requestAccount();
-        return {
-            wallet,
-            address,
-        };
+    const connectBitcoin = reactQuery.useMutation({
+        mutationFn: async ({ wallet, }) => {
+            const { address } = await wallet.connector.requestAccount();
+            return {
+                wallet,
+                address,
+            };
+        }
     });
     return {
         connectBitcoin,
@@ -30437,15 +30358,17 @@ 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(async ({ wallet, }) => {
-        const result = await connectAsync({
-            connector: wallet.connector,
-        });
-        const [firstAddress] = result.accounts;
-        return {
-            wallet,
-            address: firstAddress,
-        };
+    const connectEvm = reactQuery.useMutation({
+        mutationFn: 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 });
@@ -30539,21 +30462,23 @@ 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(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 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 address = wallet.connector.wallet.accounts[0].address;
-        return {
-            wallet,
-            address,
-        };
     });
     const disconnectSolana = React.useCallback(async () => {
         await connectedSolanaWallet.wallet?.connector.disconnect();
@@ -30628,7 +30553,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-7rBIc_IW.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-BUdrOP04.js'); });
                 const modules = initializeAllModules();
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -30656,12 +30581,14 @@ function useStellarWallets() {
 function useStellar() {
     const { wallets } = useStellarWallets();
     const connectedStellarWallet = useWalletStore((store) => store.connectedWalletsByChainType[squidTypes.ChainType.STELLAR]);
-    const connectStellar = reactQuery.useMutation(async ({ wallet, }) => {
-        const { address } = await wallet.connector.getAddress();
-        return {
-            wallet,
-            address,
-        };
+    const connectStellar = reactQuery.useMutation({
+        mutationFn: async ({ wallet, }) => {
+            const { address } = await wallet.connector.getAddress();
+            return {
+                wallet,
+                address,
+            };
+        }
     });
     const disconnectStellar = React.useCallback(async () => {
         await connectedStellarWallet.wallet?.connector.disconnect?.();
@@ -30713,22 +30640,24 @@ 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(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();
+    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,
+            };
         }
-        return {
-            wallet,
-            address: account.account.address,
-            account: account.account,
-        };
     });
     const disconnectSui = React.useCallback(async () => {
         await connectedSuiWallet.wallet?.connector.disconnect();
@@ -31037,12 +30966,14 @@ 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(async ({ wallet, }) => {
-        const xrplConnectedAddress = await wallet.connector.connect();
-        return {
-            wallet,
-            address: xrplConnectedAddress,
-        };
+    const connectXrpl = reactQuery.useMutation({
+        mutationFn: async ({ wallet, }) => {
+            const xrplConnectedAddress = await wallet.connector.connect();
+            return {
+                wallet,
+                address: xrplConnectedAddress,
+            };
+        }
     });
     const disconnectXrpl = React.useCallback(async () => {
         await connectedXrplWallet?.wallet?.connector.disconnect?.();
@@ -31429,18 +31360,19 @@ const useMultiChainWallet = (chain) => {
     /**
      * Change current network for desired chain
      */
-    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;
-    }, {
+    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;
+        },
         onError: async (error) => {
             if (error instanceof viem.UserRejectedRequestError) {
                 return;
@@ -31452,7 +31384,7 @@ const useMultiChainWallet = (chain) => {
                     provider,
                 });
             }
-        },
+        }
     });
     const isChainTypeConnected = React.useCallback((chainType) => {
         if (isGnosisConnected && chainType === squidTypes.ChainType.EVM) {
@@ -31800,51 +31732,53 @@ const useCosmos = () => {
             clientWindow?.removeEventListener("keplr_keystorechange", () => handleKeplrAccountChanged());
         };
     }, [handleKeplrAccountChanged, clientWindow]);
-    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);
+    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);
+                        }
                     }
-                    catch (error) {
-                        console.warn("Failed to get chain infos, falling back to single chain enable", error);
+                    else {
                         await cosmosWalletObject.enable(chainInfos.chainId);
                     }
+                    const address = await getAddress({
+                        chainId: chain.chainId.toString(),
+                        cosmosWalletObject,
+                        wallet,
+                    });
+                    if (address) {
+                        updateWalletStore(wallet, cosmosWalletObject, address);
+                        return address;
+                    }
                 }
-                else {
-                    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 });
                 }
             }
-            catch (error) {
-                await suggestChainOrThrow({
-                    chain,
-                    error,
-                    keplrTypeWallet: cosmosWalletObject,
-                });
-                return connectCosmos.mutateAsync({ chain, wallet });
-            }
+            return undefined;
         }
-        return undefined;
     });
     const clearData = () => {
         disconnectWallet(squidTypes.ChainType.COSMOS);
@@ -31998,11 +31932,11 @@ const useSquidQueryClient = () => {
     const queryClient = reactQuery.useQueryClient();
     const invalidateQueries = (key) => {
         const prefixKey = getPrefixKey(key);
-        queryClient.invalidateQueries(prefixKey);
+        queryClient.invalidateQueries({ queryKey: prefixKey });
     };
     const refetchQueries = (key) => {
         const prefixKey = getPrefixKey(key);
-        queryClient.refetchQueries(prefixKey);
+        queryClient.refetchQueries({ queryKey: prefixKey });
     };
     const invalidateAndRefetchQueries = (key) => {
         invalidateQueries(key);
@@ -33509,17 +33443,19 @@ function useDepositAddress(squidRoute) {
         toggleDepositFlow(false);
         setDeposit(null);
     }, [toggleDepositFlow, setDeposit]);
-    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,
-        };
+    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,
+            };
+        }
     });
     return {
         isEnabled,
@@ -33603,53 +33539,55 @@ const useAllTokensWithBalanceForChainType = ({ chainType, address, direction, qu
         xrplTokens.length,
         stellarTokens.length,
     ]);
-    const query = reactQuery.useQuery(keys().allTokensBalance(address, chainType, direction), async () => {
-        // Return zero balances if no address
-        if (!address) {
-            const defaultTokens = placeholderData.tokens;
+    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;
+            }
             return {
-                tokens: defaultTokens,
-                totalUsdBalance: calculateTotalUsdBalanceUSD(defaultTokens),
+                tokens: fetchedTokens,
+                totalUsdBalance: calculateTotalUsdBalanceUSD(fetchedTokens),
             };
-        }
-        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,
     });
@@ -33664,7 +33602,7 @@ const BALANCE_STALE_TIME = 60000; // 1 minute
 const BALANCE_CACHE_TIME = 300000; // 5 minutes
 const useAllConnectedWalletBalances = ({ direction, queryOptions = {
     staleTime: BALANCE_STALE_TIME,
-    cacheTime: BALANCE_CACHE_TIME,
+    gcTime: BALANCE_CACHE_TIME,
     refetchOnWindowFocus: true,
     refetchOnMount: true,
 }, } = {}) => {
@@ -33745,9 +33683,9 @@ const useAllConnectedWalletBalances = ({ direction, queryOptions = {
     }, [balanceQueries]);
     // Aggregate loading states
     const queryStates = React.useMemo(() => ({
-        isInitialLoading: Object.values(balanceQueries).some((q) => q.isInitialLoading),
-        isFetching: Object.values(balanceQueries).some((q) => q.isFetching),
         isLoading: Object.values(balanceQueries).some((q) => q.isLoading),
+        isFetching: Object.values(balanceQueries).some((q) => q.isFetching),
+        isPending: Object.values(balanceQueries).some((q) => q.isPending),
         isRefetching: Object.values(balanceQueries).some((q) => q.isRefetching),
         isError: Object.values(balanceQueries).some((q) => q.isError),
         isSuccess: Object.values(balanceQueries).every((q) => q.isSuccess),
@@ -33789,7 +33727,7 @@ function useNativeTokenForChain(chain) {
 
 const useEvmNativeBalance = ({ address, chain, }) => {
     const { isChainTypeConnected } = useWallet();
-    const { data: nativeEvmBalance, isLoading } = wagmi.useBalance({
+    const { data: nativeEvmBalance, isPending } = wagmi.useBalance({
         address: address,
         chainId: Number(chain?.chainId),
         query: {
@@ -33811,13 +33749,13 @@ const useEvmNativeBalance = ({ address, chain, }) => {
     }, [nativeEvmBalance?.decimals, nativeEvmBalance?.value]);
     return {
         balance,
-        isLoading,
+        isPending,
     };
 };
 const useCosmosNativeBalance = ({ address, chain, }) => {
     const { isConnected: isCosmosConnected } = useCosmosContext();
     const { nativeToken: nativeCosmosToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isLoading } = useCosmosBalance({
+    const { balance: rawBalance, isPending } = useCosmosBalance({
         chain,
         token: nativeCosmosToken,
         userAddress: address,
@@ -33832,16 +33770,18 @@ const useCosmosNativeBalance = ({ address, chain, }) => {
             };
         }
     }, [nativeCosmosToken?.decimals, rawBalance]);
-    return { balance, isLoading };
+    return { balance, isPending };
 };
 const useBitcoinNativeBalance = ({ chain, address, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
-    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);
-    }, {
+    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);
+        },
         enabled: chain?.chainType === squidTypes.ChainType.BTC &&
             nativeToken?.decimals != null &&
             isWalletAddressValid(chain, address),
@@ -33860,15 +33800,17 @@ const useBitcoinNativeBalance = ({ chain, address, }) => {
     }, [nativeToken?.decimals, rawBalance]);
     return {
         balance,
-        isLoading,
+        isPending,
     };
 };
 const useSolanaNativeBalance = ({ chain, address, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
-    const { data: rawBalance, isLoading } = reactQuery.useQuery(keys().balance(chain?.chainId, nativeToken?.address, address), async () => {
-        const balance = await getSolanaNativeBalance(address);
-        return formatBNToReadable(balance, nativeToken.decimals);
-    }, {
+    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);
+        },
         enabled: !!address &&
             nativeToken?.decimals != null &&
             chain?.chainType === squidTypes.ChainType.SOLANA,
@@ -33887,12 +33829,12 @@ const useSolanaNativeBalance = ({ chain, address, }) => {
     }, [nativeToken?.decimals, rawBalance]);
     return {
         balance,
-        isLoading,
+        isPending,
     };
 };
 const useSuiNativeBalance = ({ address, chain, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isLoading } = useSuiBalance({
+    const { balance: rawBalance, isPending } = useSuiBalance({
         chain,
         token: nativeToken,
         userAddress: address,
@@ -33907,12 +33849,12 @@ const useSuiNativeBalance = ({ address, chain, }) => {
     }, [nativeToken?.decimals, rawBalance]);
     return {
         balance,
-        isLoading,
+        isPending,
     };
 };
 const useXrplNativeBalance = ({ address, chain, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isLoading } = useXrplBalance({
+    const { balance: rawBalance, isPending } = useXrplBalance({
         chain,
         token: nativeToken,
         userAddress: address,
@@ -33928,12 +33870,12 @@ const useXrplNativeBalance = ({ address, chain, }) => {
     }, [nativeToken?.decimals, rawBalance]);
     return {
         balance,
-        isLoading,
+        isPending,
     };
 };
 const useStellarNativeBalance = ({ address, chain, }) => {
     const { nativeToken } = useNativeTokenForChain(chain);
-    const { balance: rawBalance, isLoading } = useStellarBalance({
+    const { balance: rawBalance, isPending } = useStellarBalance({
         chain,
         token: nativeToken,
         userAddress: address,
@@ -33949,7 +33891,7 @@ const useStellarNativeBalance = ({ address, chain, }) => {
     }, [nativeToken?.decimals, rawBalance]);
     return {
         balance,
-        isLoading,
+        isPending,
     };
 };
 const useNativeBalance = (chain) => {
@@ -33957,28 +33899,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, isLoading: isCosmosLoading } = useCosmosNativeBalance({
+    const { balance: nativeCosmosBalance, isPending: isCosmosPending } = useCosmosNativeBalance({
         address: cosmosAddressForChain,
         chain,
     });
-    const { balance: nativeEvmBalance, isLoading: isEvmLoading } = useEvmNativeBalance({ address: connectedAddresses[squidTypes.ChainType.EVM], chain });
-    const { balance: nativeBitcoinBalance, isLoading: isBitcoinLoading } = useBitcoinNativeBalance({
+    const { balance: nativeEvmBalance, isPending: isEvmPending } = useEvmNativeBalance({ address: connectedAddresses[squidTypes.ChainType.EVM], chain });
+    const { balance: nativeBitcoinBalance, isPending: isBitcoinPending } = useBitcoinNativeBalance({
         address: connectedAddresses[squidTypes.ChainType.BTC],
         chain,
     });
-    const { balance: nativeSolanaBalance, isLoading: isSolanaLoading } = useSolanaNativeBalance({
+    const { balance: nativeSolanaBalance, isPending: isSolanaPending } = useSolanaNativeBalance({
         address: connectedAddresses[squidTypes.ChainType.SOLANA],
         chain,
     });
-    const { balance: nativeSuiBalance, isLoading: isSuiLoading } = useSuiNativeBalance({
+    const { balance: nativeSuiBalance, isPending: isSuiPending } = useSuiNativeBalance({
         address: connectedAddresses[squidTypes.ChainType.SUI],
         chain,
     });
-    const { balance: nativeXrplBalance, isLoading: isXrpLoading } = useXrplNativeBalance({
+    const { balance: nativeXrplBalance, isPending: isXrplPending } = useXrplNativeBalance({
         address: connectedAddresses[squidTypes.ChainType.XRPL],
         chain,
     });
-    const { balance: nativeStellarBalance, isLoading: isStellarLoading } = useStellarNativeBalance({
+    const { balance: nativeStellarBalance, isPending: isStellarPending } = useStellarNativeBalance({
         address: connectedAddresses[squidTypes.ChainType.STELLAR],
         chain,
     });
@@ -34023,36 +33965,36 @@ const useNativeBalance = (chain) => {
         nativeXrplBalance,
         nativeStellarBalance,
     ]);
-    const isLoading = React.useMemo(() => {
+    const isPending = React.useMemo(() => {
         if (!chain?.chainType)
             return false;
         switch (chain.chainType) {
             case squidTypes.ChainType.EVM:
-                return isEvmLoading;
+                return isEvmPending;
             case squidTypes.ChainType.COSMOS:
-                return isCosmosLoading;
+                return isCosmosPending;
             case squidTypes.ChainType.BTC:
-                return isBitcoinLoading;
+                return isBitcoinPending;
             case squidTypes.ChainType.SOLANA:
-                return isSolanaLoading;
+                return isSolanaPending;
             case squidTypes.ChainType.SUI:
-                return isSuiLoading;
+                return isSuiPending;
             case squidTypes.ChainType.XRPL:
-                return isXrpLoading;
+                return isXrplPending;
             case squidTypes.ChainType.STELLAR:
-                return isStellarLoading;
+                return isStellarPending;
         }
     }, [
         chain?.chainType,
-        isEvmLoading,
-        isCosmosLoading,
-        isBitcoinLoading,
-        isSolanaLoading,
-        isSuiLoading,
-        isXrpLoading,
-        isStellarLoading,
+        isEvmPending,
+        isCosmosPending,
+        isBitcoinPending,
+        isSolanaPending,
+        isSuiPending,
+        isXrplPending,
+        isStellarPending,
     ]);
-    return { nativeBalance, nativeBalanceFormatted, isLoading };
+    return { nativeBalance, nativeBalanceFormatted, isPending };
 };
 
 const DEFAULT_REFRESH_INTERVAL_MS = 15000;
@@ -34061,7 +34003,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, isLoading: isNativeTokenLoading } = wagmi.useBalance({
+    const { data: nativeBalance, isPending: isNativeTokenPending } = wagmi.useBalance({
         address: userAddressParsed,
         chainId: Number(chain?.chainId),
         query: {
@@ -34077,7 +34019,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, isLoading: isErc20Loading } = wagmi.useReadContract({
+    const { data: erc20Balance, isPending: isErc20Pending } = wagmi.useReadContract({
         address: token?.address,
         abi: viem.erc20Abi,
         functionName: "balanceOf",
@@ -34093,15 +34035,15 @@ const useEvmBalance = ({ chain, token, userAddress, enabled = true, refreshInter
         },
     });
     const balance = isNativeToken ? nativeBalance?.value : erc20Balance;
-    const isLoading = isNativeToken ? isNativeTokenLoading : isErc20Loading;
+    const isPending = isNativeToken ? isNativeTokenPending : isErc20Pending;
     const formattedBalance = balance != null && token?.decimals != null
         ? formatBNToReadable(balance, token.decimals)
         : "0";
-    return { balance: formattedBalance, isLoading };
+    return { balance: formattedBalance, isPending };
 };
 const useCosmosBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
     const { isConnected } = useCosmosContext();
-    const { data: balance = "0", isLoading } = reactQuery.useQuery({
+    const { data: balance = "0", isPending } = reactQuery.useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token || chain?.chainType !== squidTypes.ChainType.COSMOS) {
@@ -34121,10 +34063,10 @@ const useCosmosBalance = ({ chain, token, userAddress, enabled = true, refreshIn
         refetchInterval: refreshIntervalMs,
         retry: 2,
     });
-    return { balance, isLoading };
+    return { balance, isPending };
 };
 const useSolanaBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isLoading } = reactQuery.useQuery({
+    const { data: balance = "0", isPending } = reactQuery.useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token)
@@ -34139,11 +34081,11 @@ const useSolanaBalance = ({ chain, token, userAddress, enabled = true, refreshIn
         refetchInterval: refreshIntervalMs,
         retry: 2,
     });
-    return { balance, isLoading };
+    return { balance, isPending };
 };
 // TODO: implement fetching balances for all bitcoin tokens
 const useBitcoinBalance = ({ userAddress, chain, }) => {
-    const { balance: balanceBn, isLoading } = useBitcoinNativeBalance({
+    const { balance: balanceBn, isPending } = useBitcoinNativeBalance({
         address: userAddress,
         chain,
     });
@@ -34152,10 +34094,10 @@ const useBitcoinBalance = ({ userAddress, chain, }) => {
             return "0";
         return formatBNToReadable(balanceBn?.value, balanceBn?.decimals);
     }, [balanceBn]);
-    return { balance, isLoading };
+    return { balance, isPending };
 };
 const useSuiBalance = ({ chain, token, userAddress, enabled = true, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isLoading } = reactQuery.useQuery({
+    const { data: balance = "0", isPending } = reactQuery.useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress ||
@@ -34175,10 +34117,10 @@ const useSuiBalance = ({ chain, token, userAddress, enabled = true, refreshInter
         refetchInterval: refreshIntervalMs,
         retry: 2,
     });
-    return { balance, isLoading };
+    return { balance, isPending };
 };
 const useXrplBalance = ({ userAddress, chain, enabled, token, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isLoading } = reactQuery.useQuery({
+    const { data: balance = "0", isPending } = reactQuery.useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token || !chain)
@@ -34195,10 +34137,10 @@ const useXrplBalance = ({ userAddress, chain, enabled, token, refreshIntervalMs
         refetchInterval: refreshIntervalMs,
         retry: 2,
     });
-    return { balance, isLoading };
+    return { balance, isPending };
 };
 const useStellarBalance = ({ userAddress, chain, enabled, token, refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, }) => {
-    const { data: balance = "0", isLoading } = reactQuery.useQuery({
+    const { data: balance = "0", isPending } = reactQuery.useQuery({
         queryKey: keys().balance(chain?.chainId, token?.address, userAddress),
         queryFn: async () => {
             if (!userAddress || !token || !chain)
@@ -34215,7 +34157,7 @@ const useStellarBalance = ({ userAddress, chain, enabled, token, refreshInterval
         refetchInterval: refreshIntervalMs,
         retry: 2,
     });
-    return { balance, isLoading };
+    return { balance, isPending };
 };
 
 /**
@@ -34336,7 +34278,7 @@ const useMultipleTokenPrices = (tokens) => {
     return {
         tokenPrices,
         getTokenPrice,
-        isLoading: coinGeckoQuery.isLoading,
+        isPending: coinGeckoQuery.isPending,
         isError: coinGeckoQuery.isError,
         error: coinGeckoQuery.error,
         refetch: coinGeckoQuery.refetch,
@@ -34485,13 +34427,17 @@ 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(keys().historicalData(coingeckoId, timeFrame), () => fetchHistoricalData(coingeckoId, timeFrame), {
+    return reactQuery.useQuery({
+        queryKey: keys().historicalData(coingeckoId, timeFrame),
+        queryFn: () => fetchHistoricalData(coingeckoId, timeFrame),
         staleTime: 5 * 60 * 1000,
         enabled: !!coingeckoId,
     });
 };
 const useTokensData = (tokens) => {
-    return reactQuery.useQuery(keys().tokensData(tokens), () => fetchTokensData(tokens), {
+    return reactQuery.useQuery({
+        queryKey: keys().tokensData(tokens),
+        queryFn: () => fetchTokensData(tokens),
         staleTime: 60 * 1000,
         enabled: !!tokens && tokens.length > 0,
     });
@@ -34796,7 +34742,7 @@ function useSendTransactionGas({ chain, token, from, }) {
 }
 
 function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
-    const { data: estimatedGas = BigInt(0), isLoading } = useSendTransactionGas({
+    const { data: estimatedGas = BigInt(0), isPending } = useSendTransactionGas({
         chain,
         token,
         from,
@@ -34841,7 +34787,7 @@ function useEstimateSendTransaction({ chain, token, amount, balance, from, }) {
     return {
         estimatedGas,
         isBalanceEnough,
-        isLoading,
+        isPending,
         isNativeBalanceEnoughToPayGasFees,
         minAmountValueWarnMsg,
     };
@@ -35424,7 +35370,9 @@ function useSendTransaction({ to, amount, token, chain, }) {
             });
         },
         onSuccess: (tx, variables) => {
-            queryClient.invalidateQueries(getPrefixKey(QueryKeys.Balance));
+            queryClient.invalidateQueries({
+                queryKey: getPrefixKey(QueryKeys.Balance),
+            });
             setTransactionState(variables.id, tx);
             persistTransaction({
                 txType: exports.HistoryTxType.SEND,
@@ -35751,9 +35699,10 @@ const useAllTransactionsStatus = ({ enabled }) => {
                     queryKey: keys().fiatToCryptoStatus(data.orderId),
                     retry: TX_STATUS_CONSTANTS.RETRY_COUNT,
                     retryDelay: TX_STATUS_CONSTANTS.RETRY_DELAY,
-                    refetchInterval: (data) => {
-                        if (data?.status &&
-                            FINAL_TRANSACTION_STATUSES.includes(data.status)) {
+                    refetchInterval: (query) => {
+                        const { state } = query;
+                        if (state.data?.status &&
+                            FINAL_TRANSACTION_STATUSES.includes(state.data.status)) {
                             return false;
                         }
                         return TX_STATUS_CONSTANTS.REFETCH_INTERVAL;
@@ -35813,7 +35762,7 @@ const useAllTransactionsStatus = ({ enabled }) => {
         queries: enabled && config.apiUrl ? statusQueries : [],
     });
     return {
-        isLoading: queries.some((q) => q.isLoading),
+        isPending: queries.some((q) => q.isPending),
         isError: queries.some((q) => q.isError),
         data: queries.map((q) => q.data).filter(Boolean),
     };
@@ -36072,16 +36021,18 @@ const useApproval = ({ squidRoute, }) => {
      * On Error: Showing the error message if any
      * @returns {boolean} approved
      */
-    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;
-    }, {
+    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;
+        },
         enabled: !!squidRoute &&
             !!sourceUserAddress &&
-            !allowanceQuery?.isLoading &&
+            !allowanceQuery?.isPending &&
             allowanceQuery?.isFetched,
     });
     // USDT has a very specific way of handling approvals
@@ -36170,81 +36121,84 @@ const useApproval = ({ squidRoute, }) => {
     /**
      * Manually approve route if necessary
      */
-    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) });
-                }
-                catch (error) {
-                    console.error("Error switching network:", error);
+    const approveRoute = reactQuery.useMutation({
+        mutationFn: async () => {
+            try {
+                if (fromToken?.address === nativeEvmTokenAddress) {
+                    return true;
                 }
-                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 (!!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,
                             },
-                        ],
-                    ]);
-                    approveTx = await evmSigner.sendTransaction({
-                        to: squidRoute.transactionRequest.target,
-                        data: approveData,
-                        value: "0",
-                        gasLimit: squidRoute.transactionRequest
-                            .gasLimit,
-                        gasPrice: squidRoute.transactionRequest
-                            .gasPrice,
-                    });
+                        });
+                    }
+                    if (isProblematicConnector(activeConnector)) {
+                        await sleep(3_000);
+                    }
+                    await approveTx?.wait();
+                    return true;
                 }
-                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;
             }
-            return false;
-        }
-        catch (error) {
-            // Keep the error in the console to debug future issues
-            console.error(error);
-            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(getPrefixKey(QueryKeys.RouteApproved));
+            queryClient.invalidateQueries({
+                queryKey: 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) {
@@ -39364,8 +39318,10 @@ const useExecuteTransaction = (squidRoute) => {
         }
     }, [cosmosSigner, fromChain]);
     const resetQueriesAfterTxSigned = () => {
-        queryClient.refetchQueries(getPrefixKey(QueryKeys.Balance));
-        queryClient.invalidateQueries(getPrefixKey(QueryKeys.Transaction));
+        queryClient.refetchQueries({ queryKey: getPrefixKey(QueryKeys.Balance) });
+        queryClient.invalidateQueries({
+            queryKey: getPrefixKey(QueryKeys.Transaction),
+        });
     };
     const dispatchSignatureRequestEvent = React.useCallback((route) => {
         WidgetEvents.getInstance().dispatchSwapTxSignatureRequested({
@@ -39383,62 +39339,64 @@ const useExecuteTransaction = (squidRoute) => {
             txHash,
         }, findToken);
     }, [findToken]);
-    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,
+    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,
+                        });
+                        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
@@ -39491,97 +39449,126 @@ const useExecuteTransaction = (squidRoute) => {
             throw error;
         }
     }, [replaceSwapTransactionNonce, setTransactionState, sourceUserAddress]);
-    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({
+    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,
                 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,
-                });
+            }));
+            let hash = txResponse.hash;
+            if (activeConnector?.id === "safe") {
+                hash = await getGnosisTransactionHash(txResponse.hash);
             }
-        }
-        try {
-            if (isProblematicConnector(activeConnector)) {
-                await sleep(3_000);
+            if (hash) {
+                resetQueriesAfterTxSigned();
             }
-            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");
+            // 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,
+                    });
+                }
             }
-            if (!solanaSigner) {
-                throw new Error("Solana signer is required");
+            try {
+                if (isProblematicConnector(activeConnector)) {
+                    await sleep(3_000);
+                }
+                const response = await txResponse.wait();
+                return response;
             }
-            if (!route.params.fromAddress || !route.params.toAddress) {
-                throw new Error("From or to address is required");
+            catch (error) {
+                return handleTransactionReplacementError({
+                    error,
+                    route,
+                    status: exports.TransactionStatus.INITIAL_LOADING,
+                    sourceStatus: exports.TransactionStatus.ONGOING,
+                    userAddress: sourceUserAddress,
+                    axelarUrl: undefined,
+                    id,
+                });
             }
-            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 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");
+                }
+                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 executeSolanaTransfer({
-                    amount: BigInt(route.params.fromAmount),
-                    target: depositData.depositAddress,
+                const signature = await executeSolanaSwap({
+                    route,
                     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,
+                            transactionIdForStatus: undefined,
                             userAddress: sourceUserAddress,
                             status: exports.TransactionStatus.INITIAL_LOADING,
                             sourceStatus: exports.TransactionStatus.ONGOING,
@@ -39598,39 +39585,13 @@ const useExecuteTransaction = (squidRoute) => {
                 });
                 return signature;
             }
-            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");
-        }
-    }, {
+            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);
@@ -39651,7 +39612,9 @@ const useExecuteTransaction = (squidRoute) => {
         },
         onSuccess: (_data, variables) => {
             const currentTx = getTransaction(variables.id);
-            queryClient.invalidateQueries(getPrefixKey(QueryKeys.Balances));
+            queryClient.invalidateQueries({
+                queryKey: getPrefixKey(QueryKeys.Balances),
+            });
             if (isSameChain && currentTx?.transactionId) {
                 replaceSwapTransactionStatus({
                     transactionId: currentTx.transactionId,
@@ -39668,197 +39631,207 @@ const useExecuteTransaction = (squidRoute) => {
             });
         },
     });
-    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));
+    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;
             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,
+            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,
-                    });
-                }
             }
-        }
-        else {
-            throw new Error("Need all parameters");
-        }
-    });
-    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,
+            // wait for transaction confirmation
+            await suiClient.waitForTransaction({
+                digest: txHash,
             });
-        }
-        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,
+        },
+    });
+    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,
             });
-        }
-        // 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 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,
             });
-        }
-        const sentTransaction = await client.sendTransaction(signedTransaction);
-        await client.waitForTransaction(sentTransaction.hash);
-    }, {});
+            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(getPrefixKey(QueryKeys.Balances));
+        queryClient.invalidateQueries({
+            queryKey: getPrefixKey(QueryKeys.Balances),
+        });
         if (isSameChain && currentTx?.transactionId) {
             replaceSwapTransactionStatus({
                 transactionId: currentTx.transactionId,
@@ -39910,38 +39883,39 @@ const useExecuteTransaction = (squidRoute) => {
         setTransactionStoreState,
         squidRoute,
     ]);
-    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);
+    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}`);
             }
-            default:
-                throw new Error(`Swap mutation not implemented for chain type: ${sourceChain.chainType}`);
-        }
-    }, {
+        },
         onMutate: (variables) => {
             useTransactionStore.setState({
                 txLocalId: variables.id,
@@ -39990,7 +39964,7 @@ const useExecuteTransaction = (squidRoute) => {
         toToken,
         toChain,
         fromChain,
-        isLoading: swapMutation.isLoading,
+        isPending: swapMutation.isPending,
         error: swapMutation.error,
     };
 };
@@ -40051,57 +40025,59 @@ const useGetRoute = () => {
      * These data will be used to trigger the transaction
      * @returns {Route} Route data
      */
-    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;
+    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;
+        },
     });
 };
-const useGetRouteWrapper = ({ enabled, cacheTime = 5 * 60 * 1000, // 5 minutes
+const useGetRouteWrapper = ({ enabled, gcTime = 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, }) => {
@@ -40151,25 +40127,27 @@ refetchIntervalInBackground = false, refetchInterval = 30000, quoteOnly = true,
      * These data will be used to trigger the transaction
      * @returns {Route} Route data
      */
-    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;
-    }, {
+    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;
+        },
         enabled: queryEnabled,
-        cacheTime,
+        gcTime,
         staleTime,
         refetchOnWindowFocus,
         refetchIntervalInBackground,
@@ -40178,7 +40156,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 = React.useMemo(() => squidRoute.isFetching || squidRoute.isRefetching, [squidRoute.isFetching, squidRoute.isRefetching]);
+    const showLoading = squidRoute.isFetching || squidRoute.isRefetching;
     return {
         squidRoute,
         showLoading,
@@ -40210,7 +40188,7 @@ function useSendTransactionStatus({ chain, txHash, }) {
         transactionId: txHash,
         txType: exports.HistoryTxType.SEND,
     });
-    const { data: status } = reactQuery.useQuery({
+    const { data: status, isSuccess, isError, } = reactQuery.useQuery({
         queryKey: keys().sendTransactionStatus(txHash, chain?.chainId),
         queryFn: async () => {
             if (!chain || !txHash)
@@ -40220,17 +40198,30 @@ function useSendTransactionStatus({ chain, txHash, }) {
                 txHash,
             });
         },
-        onSuccess: (txStatus) => {
-            setIsTransactionComplete(txStatus !== exports.SendTransactionStatus.ONGOING);
-            if (txStatus != null && !!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) {
                 replaceTransactionStatus({
                     txType: exports.HistoryTxType.SEND,
-                    status: txStatus,
+                    status: status,
                     hash: txHash,
                 });
             }
-        },
-        onError() {
+        }
+        if (isError) {
             setIsTransactionComplete(true);
             if (txHash) {
                 replaceTransactionStatus({
@@ -40239,19 +40230,8 @@ function useSendTransactionStatus({ chain, txHash, }) {
                     hash: txHash,
                 });
             }
-        },
-        refetchInterval: chain
-            ? getSendTxStatusRefetchInterval(chain.chainType)
-            : false,
-        enabled: !!chain &&
-            !!txHash &&
-            !isTransactionComplete &&
-            !!currentHistoryItem &&
-            !isHistoryTransactionEnded({
-                data: currentHistoryItem?.data,
-                txType: exports.HistoryTxType.SEND,
-            }),
-    });
+        }
+    }, [isError, isSuccess, replaceTransactionStatus, status, txHash]);
     return {
         status: status ?? currentHistoryItem?.data?.status,
     };
@@ -40285,7 +40265,9 @@ const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocu
             apiUrl: latestConfig.apiUrl,
         });
     }, [transaction]);
-    const transactionStatusQuery = reactQuery.useQuery(keys().swapTransactionStatus(transaction?.transactionId), fetchTransactionStatusWithLatestConfig, {
+    const transactionStatusQuery = reactQuery.useQuery({
+        queryKey: keys().swapTransactionStatus(transaction?.transactionId),
+        queryFn: fetchTransactionStatusWithLatestConfig,
         enabled: enabled &&
             transaction?.transactionId !== "0" &&
             !!transaction?.transactionId &&
@@ -40299,12 +40281,12 @@ const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocu
                 data: currentHistoryItem?.data,
                 txType: exports.HistoryTxType.SWAP,
             }),
-        refetchInterval(statusResponse) {
+        refetchInterval({ state }) {
             // 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 (statusResponse &&
-                transactionEndStatuses.includes(getTransactionStatus(statusResponse) ?? "")) {
+            if (state.data &&
+                transactionEndStatuses.includes(getTransactionStatus(state.data) ?? "")) {
                 return false;
             }
             return refetchInterval; // Had to handle a variable here because after onError, we want the interval to stop
@@ -40313,7 +40295,10 @@ 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,
-        onSuccess: (statusResponse) => {
+    });
+    React.useEffect(() => {
+        if (transactionStatusQuery.isSuccess && transactionStatusQuery.data) {
+            const statusResponse = transactionStatusQuery.data;
             // Dispatch event
             WidgetEvents.getInstance().dispatchSwapStatus(statusResponse.squidTransactionStatus ?? "");
             const endStatus = getTransactionEndStatus({ statusResponse });
@@ -40325,8 +40310,9 @@ const useSwapTransactionStatus = ({ transaction, retry = 25, refetchOnWindowFocu
                     status: endStatus,
                 });
             }
-        },
-        onError: (error) => {
+        }
+        if (transactionStatusQuery.isError) {
+            const error = transactionStatusQuery.error;
             // `fetchTransactionStatus` throws an error with a cause being an AxiosError
             const is404 = is404Error(error.cause);
             if (!transaction?.transactionId)
@@ -40347,8 +40333,15 @@ 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
@@ -40391,7 +40384,7 @@ const useAvatar = (seed = zeroAddress) => {
         },
         // data is static, so no need to refetch
         refetchOnWindowFocus: false,
-        cacheTime: Infinity,
+        gcTime: Infinity,
         staleTime: Infinity,
     });
     return avatar || "";
@@ -40433,38 +40426,40 @@ const useAddToken = (chainToCompare, tokenToCompare) => {
     /**
      * Add token to wallet
      */
-    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,
-                        });
+    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 {
                         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));
                 }
-                // 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 });
             }
-            await addTokenToWallet({ token, provider });
+            // TODO: Implement keplr add token
+            return false;
         }
-        // TODO: Implement keplr add token
-        return false;
     });
     return {
         addToken,
@@ -40669,7 +40664,9 @@ function useXrplTrustLine({ address, chain, token, amount }) {
             }
         },
         async onSuccess() {
-            queryClient.invalidateQueries(getPrefixKey(QueryKeys.XrplTrustLine));
+            queryClient.invalidateQueries({
+                queryKey: getPrefixKey(QueryKeys.XrplTrustLine),
+            });
         },
     });
     /**
@@ -41027,8 +41024,6 @@ 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;
@@ -41046,7 +41041,6 @@ exports.useMultiChainWallet = useMultiChainWallet;
 exports.useMultipleTokenPrices = useMultipleTokenPrices;
 exports.useNativeBalance = useNativeBalance;
 exports.useNativeTokenForChain = useNativeTokenForChain;
-exports.useRecommendedQuote = useRecommendedQuote;
 exports.useRouteWarnings = useRouteWarnings;
 exports.useSendTransaction = useSendTransaction;
 exports.useSendTransactionGas = useSendTransactionGas;
@@ -41074,4 +41068,4 @@ exports.useWallets = useWallets;
 exports.useXrplTrustLine = useXrplTrustLine;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-BtOPNnH5.js.map
+//# sourceMappingURL=index-CS74WzWX.js.map