@sodax/dapp-kit 1.5.7-beta → 2.0.0-rc.1

package/dist/index.mjs

@@ -1,10 +1,37 @@
-import React, { createContext, useContext, useState, useCallback, useMemo, useRef, useEffect } from 'react';
-import { SpokeService, deriveUserWalletAddress, STELLAR_MAINNET_CHAIN_ID, StellarSpokeProvider, StellarSpokeService, HubService, spokeChainConfig, BitcoinSpokeProvider, SONIC_MAINNET_CHAIN_ID, SonicSpokeProvider, EvmSpokeProvider, SuiSpokeProvider, IconSpokeProvider, InjectiveSpokeProvider, SolanaSpokeProvider, NearSpokeProvider, StacksSpokeProvider, BitcoinSpokeService, normalizePsbtToBase64, isLegacybnUSDToken, ClService, Sodax } from '@sodax/sdk';
-import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { isAddress, parseUnits } from 'viem';
-import { ICON_MAINNET_CHAIN_ID } from '@sodax/types';
+import { useMutation, useQuery, useQueryClient, QueryClient, MutationCache } from '@tanstack/react-query';
+import { createContext, useCallback, useContext, useState, useRef, useEffect, useMemo } from 'react';
+import { ChainKeys, RadfiApiError, normalizePsbtToBase64, ClService, Sodax } from '@sodax/sdk';
+export * from '@sodax/sdk';
+import { isAddress, erc20Abi, parseUnits } from 'viem';
+import { jsx } from 'react/jsx-runtime';
 
-// src/contexts/index.ts
+// src/hooks/shared/unwrapResult.ts
+function unwrapResult(result) {
+  if (!result.ok) {
+    if (result.error instanceof Error) throw result.error;
+    const e = result.error;
+    const msg = e?.detail?.code ?? e?.detail?.message ?? e?.message ?? "SDK call failed";
+    throw new Error(msg, { cause: result.error });
+  }
+  return result.value;
+}
+async function toResult(promise) {
+  try {
+    const value = await promise;
+    return { ok: true, value };
+  } catch (error) {
+    return { ok: false, error };
+  }
+}
+function useSafeMutation(options) {
+  const mutation = useMutation(options);
+  const { mutateAsync } = mutation;
+  const mutateAsyncSafe = useCallback(
+    (vars, opts) => toResult(mutateAsync(vars, opts)),
+    [mutateAsync]
+  );
+  return { ...mutation, mutateAsyncSafe };
+}
 var SodaxContext = createContext(null);
 var useSodaxContext = () => {
   const context = useContext(SodaxContext);
@@ -13,58 +40,61 @@ var useSodaxContext = () => {
   }
   return context;
 };
-function useEstimateGas(spokeProvider) {
-  return useMutation({
-    mutationFn: async (rawTx) => {
-      if (!spokeProvider) {
-        throw new Error("spokeProvider is not found");
-      }
-      const response = await SpokeService.estimateGas(rawTx, spokeProvider);
-      return response;
-    }
+
+// src/hooks/shared/useEstimateGas.ts
+function useEstimateGas({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  return useSafeMutation({
+    mutationKey: ["shared", "estimateGas"],
+    ...mutationOptions,
+    mutationFn: async (params) => unwrapResult(await sodax.spoke.estimateGas(params))
   });
 }
-function useDeriveUserWalletAddress(spokeChainId, spokeAddress) {
+function useDeriveUserWalletAddress({
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const spokeChainId = params?.spokeChainId;
+  const spokeAddress = params?.spokeAddress;
   return useQuery({
-    queryKey: ["deriveUserWalletAddress", spokeChainId, spokeAddress],
+    queryKey: ["shared", "deriveUserWalletAddress", spokeChainId, spokeAddress],
     queryFn: async () => {
       if (!spokeChainId || !spokeAddress) {
         throw new Error("Spoke chain id and address are required");
       }
-      spokeChainId = typeof spokeChainId === "object" ? spokeChainId.chainConfig.chain.id : spokeChainId;
-      return await deriveUserWalletAddress(sodax.hubProvider, spokeChainId, spokeAddress);
+      return await sodax.hubProvider.getUserHubWalletAddress(spokeAddress, spokeChainId);
     },
     enabled: !!spokeChainId && !!spokeAddress,
-    refetchInterval: false
-    // This is a deterministic operation, no need to refetch
+    refetchInterval: false,
+    ...queryOptions
   });
 }
-function useStellarTrustlineCheck(token, amount, spokeProvider, chainId) {
+function useStellarTrustlineCheck({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const token = params?.token;
+  const amount = params?.amount;
+  const chainId = params?.chainId;
+  const walletProvider = params?.walletProvider;
   return useQuery({
-    queryKey: ["stellar-trustline-check", token],
+    queryKey: ["shared", "stellarTrustlineCheck", token],
     queryFn: async () => {
-      if (chainId !== STELLAR_MAINNET_CHAIN_ID) {
-        return true;
-      }
-      if (!spokeProvider || !token || !amount || !(spokeProvider instanceof StellarSpokeProvider)) {
-        console.error(
-          "Spoke provider, token or amount not found. Details: spokeProvider:",
-          spokeProvider,
-          "token:",
-          token,
-          "amount:",
-          amount
-        );
-        return false;
-      }
-      const response = await StellarSpokeService.hasSufficientTrustline(token, amount, spokeProvider);
-      return response;
+      if (chainId !== ChainKeys.STELLAR_MAINNET) return true;
+      if (!walletProvider || !token || !amount) return false;
+      const walletAddress = await walletProvider.getWalletAddress();
+      return sodax.spoke.stellar.hasSufficientTrustline(token, amount, walletAddress);
     },
-    enabled: !!spokeProvider && !!token && !!amount
+    enabled: !!walletProvider && !!token && !!amount,
+    ...queryOptions
   });
 }
 function useRequestTrustline(token) {
+  const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
   const [isLoading, setIsLoading] = useState(false);
   const [isRequested, setIsRequested] = useState(false);
@@ -74,20 +104,29 @@ function useRequestTrustline(token) {
     async ({
       token: token2,
       amount,
-      spokeProvider
+      srcChainKey,
+      walletProvider
     }) => {
-      if (!spokeProvider || !token2 || !amount || !(spokeProvider instanceof StellarSpokeProvider)) {
-        const error2 = new Error("Spoke provider, token or amount not found");
+      if (!token2 || !amount) {
+        const error2 = new Error("Token and amount are required");
         setError(error2);
         throw error2;
       }
       setIsLoading(true);
       setError(null);
       try {
-        const result = await StellarSpokeService.requestTrustline(token2, amount, spokeProvider);
+        const srcAddress = await walletProvider.getWalletAddress();
+        const result = await sodax.spoke.stellar.requestTrustline({
+          raw: false,
+          srcChainKey,
+          srcAddress,
+          token: token2,
+          amount,
+          walletProvider
+        });
         setData(result);
         setIsRequested(true);
-        queryClient.invalidateQueries({ queryKey: ["stellar-trustline-check", token2] });
+        queryClient.invalidateQueries({ queryKey: ["shared", "stellarTrustlineCheck", token2] });
         return result;
       } catch (err) {
         const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
@@ -97,30 +136,56 @@ function useRequestTrustline(token) {
         setIsLoading(false);
       }
     },
-    [queryClient]
+    [queryClient, sodax]
   );
-  return {
-    requestTrustline,
-    isLoading,
-    isRequested,
-    error,
-    data
-  };
+  return { requestTrustline, isLoading, isRequested, error, data };
 }
-function useGetUserHubWalletAddress(spokeChainId, spokeAddress) {
+function useGetUserHubWalletAddress({
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const spokeChainId = params?.spokeChainId;
+  const spokeAddress = params?.spokeAddress;
   return useQuery({
-    queryKey: ["getUserHubWalletAddress", spokeChainId, spokeAddress],
+    queryKey: ["shared", "userHubWalletAddress", spokeChainId, spokeAddress],
     queryFn: async () => {
       if (!spokeChainId || !spokeAddress) {
         throw new Error("Spoke chain id and address are required");
       }
-      spokeChainId = typeof spokeChainId === "object" ? spokeChainId.chainConfig.chain.id : spokeChainId;
-      return await HubService.getUserHubWalletAddress(spokeAddress, spokeChainId, sodax.hubProvider);
+      return await sodax.hubProvider.getUserHubWalletAddress(spokeAddress, spokeChainId);
     },
     enabled: !!spokeChainId && !!spokeAddress,
-    refetchInterval: false
-    // This is a deterministic operation, no need to refetch
+    refetchInterval: false,
+    ...queryOptions
+  });
+}
+var REFETCH_INTERVAL_MS = 5e3;
+function getXBalancesQueryOptions({ xService, xChainId, xTokens, address }) {
+  return {
+    // Pair symbol + address: readable in devtools, unique on-chain (symbol alone
+    // can collide — e.g. scam tokens copying legitimate ticker).
+    queryKey: ["shared", "xBalances", xChainId, xTokens.map((x) => [x.symbol, x.address]), address],
+    queryFn: async () => {
+      if (!xService) return {};
+      return xService.getBalances(address, xTokens);
+    },
+    enabled: !!xService && !!address && xTokens.length > 0,
+    refetchInterval: REFETCH_INTERVAL_MS
+  };
+}
+function useXBalances({
+  params,
+  queryOptions
+} = {}) {
+  return useQuery({
+    ...getXBalancesQueryOptions({
+      xService: params?.xService,
+      xChainId: params?.xChainId,
+      xTokens: params?.xTokens ?? [],
+      address: params?.address
+    }),
+    ...queryOptions
   });
 }
 
@@ -129,100 +194,6 @@ function useHubProvider() {
   const { sodax } = useSodaxContext();
   return sodax.hubProvider;
 }
-function useSpokeProvider(spokeChainId, walletProvider) {
-  const { rpcConfig } = useSodaxContext();
-  const xChainType = spokeChainId ? spokeChainConfig[spokeChainId]?.chain.type : void 0;
-  const spokeProvider = useMemo(() => {
-    if (!walletProvider) return void 0;
-    if (!spokeChainId) return void 0;
-    if (!xChainType) return void 0;
-    if (!rpcConfig) return void 0;
-    if (xChainType === "BITCOIN") {
-      const bitcoinConfig = spokeChainConfig[spokeChainId];
-      const btcRpcOverride = rpcConfig[spokeChainId];
-      return new BitcoinSpokeProvider(
-        walletProvider,
-        bitcoinConfig,
-        {
-          url: btcRpcOverride?.radfiApiUrl || bitcoinConfig.radfiApiUrl,
-          apiKey: bitcoinConfig.radfiApiKey,
-          umsUrl: btcRpcOverride?.radfiUmsUrl || bitcoinConfig.radfiUmsUrl
-        },
-        "TRADING",
-        btcRpcOverride?.rpcUrl || bitcoinConfig.rpcUrl
-      );
-    }
-    if (xChainType === "EVM") {
-      if (spokeChainId === SONIC_MAINNET_CHAIN_ID) {
-        return new SonicSpokeProvider(
-          walletProvider,
-          spokeChainConfig[spokeChainId]
-        );
-      }
-      const evmRpcUrl = rpcConfig[spokeChainId];
-      return new EvmSpokeProvider(
-        walletProvider,
-        spokeChainConfig[spokeChainId],
-        typeof evmRpcUrl === "string" ? evmRpcUrl : void 0
-      );
-    }
-    if (xChainType === "SUI") {
-      return new SuiSpokeProvider(
-        spokeChainConfig[spokeChainId],
-        walletProvider
-      );
-    }
-    if (xChainType === "ICON") {
-      return new IconSpokeProvider(
-        walletProvider,
-        spokeChainConfig[spokeChainId]
-      );
-    }
-    if (xChainType === "INJECTIVE") {
-      return new InjectiveSpokeProvider(
-        spokeChainConfig[spokeChainId],
-        walletProvider
-      );
-    }
-    if (xChainType === "STELLAR") {
-      const stellarConfig = spokeChainConfig[spokeChainId];
-      return new StellarSpokeProvider(
-        walletProvider,
-        stellarConfig,
-        rpcConfig.stellar ? rpcConfig.stellar : {
-          horizonRpcUrl: stellarConfig.horizonRpcUrl,
-          sorobanRpcUrl: stellarConfig.sorobanRpcUrl
-        }
-      );
-    }
-    if (xChainType === "SOLANA") {
-      return new SolanaSpokeProvider(
-        walletProvider,
-        rpcConfig.solana ? {
-          ...spokeChainConfig[spokeChainId],
-          rpcUrl: rpcConfig.solana
-        } : spokeChainConfig[spokeChainId]
-      );
-    }
-    if (xChainType === "NEAR") {
-      return new NearSpokeProvider(
-        walletProvider,
-        spokeChainConfig[spokeChainId]
-      );
-    }
-    if (xChainType === "STACKS") {
-      return new StacksSpokeProvider(
-        rpcConfig[spokeChainId] ? {
-          ...spokeChainConfig[spokeChainId],
-          rpcUrl: rpcConfig[spokeChainId]
-        } : spokeChainConfig[spokeChainId],
-        walletProvider
-      );
-    }
-    return void 0;
-  }, [spokeChainId, xChainType, walletProvider, rpcConfig]);
-  return spokeProvider;
-}
 var SESSION_KEY = (address) => `radfi_session_${address}`;
 function saveRadfiSession(address, session) {
   try {
@@ -244,38 +215,41 @@ function clearRadfiSession(address) {
   } catch {
   }
 }
-function useRadfiAuth(spokeProvider) {
-  return useMutation({
-    mutationFn: async () => {
-      if (!spokeProvider) {
-        throw new Error("Bitcoin spoke provider not found");
-      }
-      const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
+function useRadfiAuth({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  return useSafeMutation({
+    mutationKey: ["bitcoin", "radfiAuth"],
+    ...mutationOptions,
+    mutationFn: async ({ walletProvider }) => {
+      const radfi = sodax.spoke.bitcoin.radfi;
+      const walletAddress = await walletProvider.getWalletAddress();
       const existingSession = loadRadfiSession(walletAddress);
       const cachedPublicKey = existingSession?.publicKey;
       try {
-        const { accessToken, refreshToken, tradingAddress, publicKey } = await spokeProvider.authenticateWithWallet(cachedPublicKey);
-        const session = {
-          accessToken,
-          refreshToken,
-          tradingAddress,
-          publicKey
-        };
-        saveRadfiSession(walletAddress, session);
+        const { accessToken, refreshToken, tradingAddress, publicKey } = await radfi.authenticateWithWallet(
+          walletProvider,
+          cachedPublicKey
+        );
+        saveRadfiSession(walletAddress, { accessToken, refreshToken, tradingAddress, publicKey });
         return { accessToken, refreshToken, tradingAddress };
       } catch (err) {
-        const isAlreadyRegistered = err instanceof Error && (err.message.includes("duplicatedPubKey") || err.message.includes("4008"));
+        const isAlreadyRegistered = err instanceof RadfiApiError && err.code === "4008";
         if (isAlreadyRegistered && existingSession?.refreshToken) {
           try {
-            const refreshed = await spokeProvider.radfi.refreshAccessToken(existingSession.refreshToken);
-            const session = {
+            const refreshed = await radfi.refreshAccessToken(existingSession.refreshToken);
+            radfi.setRadfiAccessToken(refreshed.accessToken, refreshed.refreshToken);
+            saveRadfiSession(walletAddress, {
               ...existingSession,
               accessToken: refreshed.accessToken,
               refreshToken: refreshed.refreshToken
+            });
+            return {
+              accessToken: refreshed.accessToken,
+              refreshToken: refreshed.refreshToken,
+              tradingAddress: existingSession.tradingAddress
             };
-            spokeProvider.setRadfiAccessToken(refreshed.accessToken, refreshed.refreshToken);
-            saveRadfiSession(walletAddress, session);
-            return { accessToken: refreshed.accessToken, refreshToken: refreshed.refreshToken, tradingAddress: existingSession.tradingAddress };
           } catch {
             clearRadfiSession(walletAddress);
           }
@@ -289,85 +263,103 @@ function useRadfiAuth(spokeProvider) {
   });
 }
 var REFRESH_INTERVAL = 5 * 60 * 1e3;
-function useRadfiSession(spokeProvider) {
+function useRadfiSession(walletProvider) {
+  const { sodax } = useSodaxContext();
   const [walletAddress, setWalletAddress] = useState();
   const [isAuthed, setIsAuthed] = useState(false);
   const [tradingAddress, setTradingAddress] = useState();
   const isRefreshingRef = useRef(false);
-  const silentRefresh = useCallback(async (address) => {
-    if (!spokeProvider || isRefreshingRef.current) return;
-    isRefreshingRef.current = true;
-    try {
-      const session = loadRadfiSession(address);
-      if (!session?.refreshToken) {
+  const silentRefresh = useCallback(
+    async (address) => {
+      if (!walletProvider || isRefreshingRef.current) return;
+      isRefreshingRef.current = true;
+      try {
+        const session = loadRadfiSession(address);
+        if (!session?.refreshToken) {
+          setIsAuthed(false);
+          return;
+        }
+        const radfi = sodax.spoke.bitcoin.radfi;
+        const { accessToken, refreshToken } = await radfi.refreshAccessToken(session.refreshToken);
+        const updated = { ...session, accessToken, refreshToken };
+        saveRadfiSession(address, updated);
+        radfi.setRadfiAccessToken(accessToken, refreshToken);
+        setIsAuthed(true);
+        setTradingAddress(updated.tradingAddress || void 0);
+      } catch {
+        clearRadfiSession(address);
+        sodax.spoke.bitcoin.radfi.setRadfiAccessToken("", "");
         setIsAuthed(false);
-        return;
+        setTradingAddress(void 0);
+      } finally {
+        isRefreshingRef.current = false;
       }
-      const { accessToken, refreshToken } = await spokeProvider.radfi.refreshAccessToken(session.refreshToken);
-      const updated = {
-        ...session,
-        accessToken,
-        refreshToken
-      };
-      saveRadfiSession(address, updated);
-      spokeProvider.setRadfiAccessToken(accessToken, refreshToken);
-      setIsAuthed(true);
-      setTradingAddress(updated.tradingAddress || void 0);
-    } catch {
-      clearRadfiSession(address);
-      spokeProvider.setRadfiAccessToken("", "");
-      setIsAuthed(false);
-      setTradingAddress(void 0);
-    } finally {
-      isRefreshingRef.current = false;
-    }
-  }, [spokeProvider]);
+    },
+    [walletProvider, sodax]
+  );
   useEffect(() => {
-    if (!spokeProvider) return;
+    if (!walletProvider) return;
     setIsAuthed(false);
     setTradingAddress(void 0);
     setWalletAddress(void 0);
-    spokeProvider.walletProvider.getWalletAddress().then((addr) => {
+    walletProvider.getWalletAddress().then((addr) => {
       setWalletAddress(addr);
       const session = loadRadfiSession(addr);
       if (!session?.refreshToken) return;
       silentRefresh(addr);
     }).catch(() => {
     });
-  }, [spokeProvider, silentRefresh]);
+  }, [walletProvider, silentRefresh]);
   useEffect(() => {
-    if (!walletAddress || !spokeProvider) return;
+    if (!walletAddress || !walletProvider) return;
     const id = setInterval(() => {
       silentRefresh(walletAddress);
     }, REFRESH_INTERVAL);
     return () => clearInterval(id);
-  }, [walletAddress, spokeProvider, silentRefresh]);
-  const { mutateAsync: loginMutate, isPending: isLoginPending } = useRadfiAuth(spokeProvider);
+  }, [walletAddress, walletProvider, silentRefresh]);
+  const { mutateAsyncSafe: loginMutateSafe, isPending: isLoginPending } = useRadfiAuth();
   const login = useCallback(async () => {
-    const result = await loginMutate();
+    if (!walletProvider) {
+      return;
+    }
+    const result = await loginMutateSafe({ walletProvider });
+    if (!result.ok) {
+      return;
+    }
     setIsAuthed(true);
-    setTradingAddress(result.tradingAddress || void 0);
-  }, [loginMutate]);
+    setTradingAddress(result.value.tradingAddress || void 0);
+  }, [loginMutateSafe, walletProvider]);
   return { walletAddress, isAuthed, tradingAddress, login, isLoginPending };
 }
-function useFundTradingWallet(spokeProvider) {
+function useFundTradingWallet({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async (amount) => {
-      if (!spokeProvider) {
-        throw new Error("Bitcoin spoke provider not found");
-      }
-      return BitcoinSpokeService.fundTradingWallet(amount, spokeProvider);
+  return useSafeMutation({
+    mutationKey: ["bitcoin", "fundTradingWallet"],
+    ...mutationOptions,
+    mutationFn: async ({ amount, walletProvider }) => {
+      const walletAddress = await walletProvider.getWalletAddress();
+      return sodax.spoke.bitcoin.fundTradingWallet(amount, walletAddress, walletProvider);
     },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["btc-balance"] });
-      queryClient.invalidateQueries({ queryKey: ["xBalances"] });
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["bitcoin", "balance"] });
+      queryClient.invalidateQueries({ queryKey: ["bitcoin", "tradingWalletBalance"] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", ChainKeys.BITCOIN_MAINNET] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useBitcoinBalance(address, rpcUrl = "https://mempool.space/api") {
+var DEFAULT_RPC_URL = "https://mempool.space/api";
+function useBitcoinBalance({
+  params,
+  queryOptions
+} = {}) {
+  const address = params?.address;
+  const rpcUrl = params?.rpcUrl ?? DEFAULT_RPC_URL;
   return useQuery({
-    queryKey: ["btc-balance", address],
+    queryKey: ["bitcoin", "balance", address],
     queryFn: async () => {
       if (!address) return 0n;
       const response = await fetch(`${rpcUrl}/address/${address}/utxo`);
@@ -375,300 +367,310 @@ function useBitcoinBalance(address, rpcUrl = "https://mempool.space/api") {
       const utxos = await response.json();
       return BigInt(utxos.reduce((sum, utxo) => sum + utxo.value, 0));
     },
-    enabled: !!address
+    enabled: !!address,
+    ...queryOptions
   });
 }
-function useTradingWalletBalance(spokeProvider, tradingAddress) {
+
+// src/hooks/bitcoin/useTradingWallet.ts
+function useTradingWallet(walletAddress) {
+  if (!walletAddress) return { tradingAddress: void 0 };
+  const session = loadRadfiSession(walletAddress);
+  return { tradingAddress: session?.tradingAddress || void 0 };
+}
+function useTradingWalletBalance({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const walletProvider = params?.walletProvider;
+  const tradingAddress = params?.tradingAddress;
   return useQuery({
-    queryKey: ["trading-wallet-balance", tradingAddress],
+    queryKey: ["bitcoin", "tradingWalletBalance", tradingAddress],
     queryFn: () => {
-      if (!spokeProvider || !tradingAddress) {
-        throw new Error("spokeProvider and tradingAddress are required");
+      if (!walletProvider || !tradingAddress) {
+        throw new Error("walletProvider and tradingAddress are required");
       }
-      return spokeProvider.radfi.getBalance(tradingAddress);
+      return sodax.spoke.bitcoin.radfi.getBalance(tradingAddress);
     },
-    enabled: !!spokeProvider && !!tradingAddress
+    enabled: !!walletProvider && !!tradingAddress,
+    ...queryOptions
   });
 }
-function useExpiredUtxos(spokeProvider, tradingAddress) {
+function useExpiredUtxos({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const walletProvider = params?.walletProvider;
+  const tradingAddress = params?.tradingAddress;
   return useQuery({
-    queryKey: ["expired-utxos", tradingAddress],
+    queryKey: ["bitcoin", "expiredUtxos", tradingAddress],
     queryFn: async () => {
-      if (!spokeProvider || !tradingAddress) {
-        throw new Error("spokeProvider and tradingAddress are required");
+      if (!walletProvider || !tradingAddress) {
+        throw new Error("walletProvider and tradingAddress are required");
       }
-      const result = await spokeProvider.radfi.getExpiredUtxos(tradingAddress);
+      const result = await sodax.spoke.bitcoin.radfi.getExpiredUtxos(tradingAddress);
       return result.data;
     },
-    enabled: !!spokeProvider && !!tradingAddress,
-    refetchInterval: 6e4
-    // refetch every minute
+    enabled: !!walletProvider && !!tradingAddress,
+    refetchInterval: 6e4,
+    ...queryOptions
   });
 }
-function useRenewUtxos(spokeProvider) {
+function useRenewUtxos({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async ({ txIdVouts }) => {
-      if (!spokeProvider) {
-        throw new Error("Bitcoin spoke provider not found");
-      }
-      const userAddress = await spokeProvider.walletProvider.getWalletAddress();
+  return useSafeMutation({
+    mutationKey: ["bitcoin", "renewUtxos"],
+    ...mutationOptions,
+    mutationFn: async ({ txIdVouts, walletProvider }) => {
+      const radfi = sodax.spoke.bitcoin.radfi;
+      const userAddress = await walletProvider.getWalletAddress();
       const session = loadRadfiSession(userAddress);
-      const accessToken = session?.accessToken || spokeProvider.radfiAccessToken;
+      const accessToken = session?.accessToken || radfi.accessToken;
       if (!accessToken) {
         throw new Error("Radfi authentication required. Please login first.");
       }
-      const buildResult = await spokeProvider.radfi.buildRenewUtxoTransaction(
-        { userAddress, txIdVouts },
-        accessToken
-      );
-      const signedTx = await spokeProvider.walletProvider.signTransaction(
-        buildResult.base64Psbt,
-        false
-      );
+      const buildResult = await radfi.buildRenewUtxoTransaction({ userAddress, txIdVouts }, accessToken);
+      const signedTx = await walletProvider.signTransaction(buildResult.base64Psbt, false);
       const signedBase64Tx = normalizePsbtToBase64(signedTx);
-      return spokeProvider.radfi.signAndBroadcastRenewUtxo(
-        { userAddress, signedBase64Tx },
-        accessToken
-      );
+      return radfi.signAndBroadcastRenewUtxo({ userAddress, signedBase64Tx }, accessToken);
     },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["expired-utxos"] });
-      queryClient.invalidateQueries({ queryKey: ["trading-wallet-balance"] });
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["bitcoin", "expiredUtxos"] });
+      queryClient.invalidateQueries({ queryKey: ["bitcoin", "tradingWalletBalance"] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useRadfiWithdraw(spokeProvider) {
+function useRadfiWithdraw({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async ({ amount, tokenId, withdrawTo }) => {
-      if (!spokeProvider) {
-        throw new Error("Bitcoin spoke provider not found");
-      }
-      const userAddress = await spokeProvider.walletProvider.getWalletAddress();
+  return useSafeMutation({
+    mutationKey: ["bitcoin", "radfiWithdraw"],
+    ...mutationOptions,
+    mutationFn: async ({ amount, tokenId, withdrawTo, walletProvider }) => {
+      const radfi = sodax.spoke.bitcoin.radfi;
+      const userAddress = await walletProvider.getWalletAddress();
       const session = loadRadfiSession(userAddress);
-      const accessToken = session?.accessToken || spokeProvider.radfiAccessToken;
+      const accessToken = session?.accessToken || radfi.accessToken;
       if (!accessToken) {
         throw new Error("Radfi authentication required. Please login first.");
       }
-      const buildResult = await spokeProvider.radfi.withdrawToUser(
-        { userAddress, amount, tokenId, withdrawTo },
-        accessToken
-      );
-      const signedTx = await spokeProvider.walletProvider.signTransaction(
-        buildResult.base64Psbt,
-        false
-      );
+      const buildResult = await radfi.withdrawToUser({ userAddress, amount, tokenId, withdrawTo }, accessToken);
+      const signedTx = await walletProvider.signTransaction(buildResult.base64Psbt, false);
       const signedBase64Tx = normalizePsbtToBase64(signedTx);
-      const txId = await spokeProvider.radfi.signAndBroadcastWithdraw(
-        { userAddress, signedBase64Tx },
-        accessToken
-      );
+      const txId = await radfi.signAndBroadcastWithdraw({ userAddress, signedBase64Tx }, accessToken);
       return { txId, fee: buildResult.fee.totalFee };
     },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["trading-wallet-balance"] });
-      queryClient.invalidateQueries({ queryKey: ["btc-balance"] });
-      queryClient.invalidateQueries({ queryKey: ["xBalances"] });
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["bitcoin", "tradingWalletBalance"] });
+      queryClient.invalidateQueries({ queryKey: ["bitcoin", "balance"] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", ChainKeys.BITCOIN_MAINNET] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useBorrow() {
+function useBorrow({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("spokeProvider is not found");
-      }
-      const response = await sodax.moneyMarket.borrow(params, spokeProvider);
-      if (!response.ok) {
-        throw response.error;
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["mm", "borrow"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.moneyMarket.borrow({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ["mm", "userReservesData", params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({
+        queryKey: ["mm", "userFormattedSummary", params.srcChainKey, params.srcAddress]
+      });
+      queryClient.invalidateQueries({ queryKey: ["mm", "aTokensBalances"] });
+      const balanceChains = /* @__PURE__ */ new Set([params.srcChainKey, params.dstChainKey ?? params.srcChainKey]);
+      for (const chainKey of balanceChains) {
+        queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", chainKey] });
       }
-      return response;
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useRepay() {
+function useRepay({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("spokeProvider is not found");
-      }
-      const response = await sodax.moneyMarket.repay(params, spokeProvider);
-      if (!response.ok) {
-        throw response.error;
-      }
-      return response;
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["mm", "repay"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.moneyMarket.repay({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ["mm", "userReservesData", params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({
+        queryKey: ["mm", "userFormattedSummary", params.srcChainKey, params.srcAddress]
+      });
+      queryClient.invalidateQueries({ queryKey: ["mm", "aTokensBalances"] });
+      queryClient.invalidateQueries({ queryKey: ["mm", "allowance", params.srcChainKey, params.token, params.action] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", params.srcChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useSupply() {
+function useSupply({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("spokeProvider is not found");
-      }
-      const response = await sodax.moneyMarket.supply(params, spokeProvider);
-      if (!response.ok) {
-        throw response.error;
-      }
-      return response;
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["mm", "supply"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.moneyMarket.supply({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ["mm", "userReservesData", params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({
+        queryKey: ["mm", "userFormattedSummary", params.srcChainKey, params.srcAddress]
+      });
+      queryClient.invalidateQueries({ queryKey: ["mm", "aTokensBalances"] });
+      queryClient.invalidateQueries({ queryKey: ["mm", "allowance", params.srcChainKey, params.token, params.action] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", params.srcChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useWithdraw() {
+function useWithdraw({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("spokeProvider is not found");
-      }
-      const response = await sodax.moneyMarket.withdraw(params, spokeProvider);
-      if (!response.ok) {
-        throw response.error;
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["mm", "withdraw"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.moneyMarket.withdraw({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ["mm", "userReservesData", params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({
+        queryKey: ["mm", "userFormattedSummary", params.srcChainKey, params.srcAddress]
+      });
+      queryClient.invalidateQueries({ queryKey: ["mm", "aTokensBalances"] });
+      const balanceChains = /* @__PURE__ */ new Set([params.srcChainKey, params.dstChainKey ?? params.srcChainKey]);
+      for (const chainKey of balanceChains) {
+        queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", chainKey] });
       }
-      return response;
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function isLegacyParams(params) {
-  return "spokeProvider" in params || "address" in params;
-}
-function resolveParams(params) {
-  if (isLegacyParams(params)) {
-    return {
-      spokeChainId: params.spokeProvider?.chainConfig.chain.id,
-      userAddress: params.address
-    };
-  }
-  return { spokeChainId: params.spokeChainId, userAddress: params.userAddress };
-}
-function useUserReservesData(params) {
+function useUserReservesData({
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  const resolved = params ? resolveParams(params) : { spokeChainId: void 0, userAddress: void 0 };
-  const defaultQueryOptions = {
-    queryKey: ["mm", "userReservesData", resolved.spokeChainId, resolved.userAddress],
-    enabled: !!resolved.spokeChainId && !!resolved.userAddress,
-    refetchInterval: 5e3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-    // override default query options if provided
-  };
+  const spokeChainKey = params?.spokeChainKey;
+  const userAddress = params?.userAddress;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["mm", "userReservesData", spokeChainKey, userAddress],
     queryFn: async () => {
-      if (!resolved.spokeChainId || !resolved.userAddress) {
-        throw new Error("spokeChainId or userAddress is not defined");
+      if (!spokeChainKey || !userAddress) {
+        throw new Error("spokeChainKey and userAddress are required");
       }
-      return await sodax.moneyMarket.data.getUserReservesData(resolved.spokeChainId, resolved.userAddress);
-    }
+      return sodax.moneyMarket.data.getUserReservesData(spokeChainKey, userAddress);
+    },
+    enabled: !!spokeChainKey && !!userAddress,
+    refetchInterval: 5e3,
+    ...queryOptions
   });
 }
-function useReservesData(params) {
-  const defaultQueryOptions = {
+function useReservesData({
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  return useQuery({
     queryKey: ["mm", "reservesData"],
-    refetchInterval: 5e3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-    // override default query options if provided
-  };
+    queryFn: async () => sodax.moneyMarket.data.getReservesData(),
+    refetchInterval: 5e3,
+    ...queryOptions
+  });
+}
+function useReservesHumanized({
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   return useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      return await sodax.moneyMarket.data.getReservesData();
-    }
+    queryKey: ["mm", "reservesHumanized"],
+    queryFn: async () => sodax.moneyMarket.data.getReservesHumanized(),
+    refetchInterval: 5e3,
+    ...queryOptions
+  });
+}
+function useReservesList({
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  return useQuery({
+    queryKey: ["mm", "reservesList"],
+    queryFn: async () => sodax.moneyMarket.data.getReservesList(),
+    ...queryOptions
   });
 }
 function useMMAllowance({
   params,
-  spokeProvider,
   queryOptions
-}) {
+} = {}) {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["mm", "allowance", params?.token, params?.action],
-    /**
-     * IMPORTANT: Skip allowance checks for 'borrow' and 'withdraw' actions.
-     *
-     * Reason: According to the SDK's MoneyMarketService.isAllowanceValid() implementation,
-     * borrow and withdraw actions do NOT require ERC-20 token approval. The SDK's
-     * isAllowanceValid() method always returns `true` for these actions without making
-     * any on-chain allowance checks.
-     *
-     * This optimization prevents unnecessary RPC calls and avoids showing confusing states for actions that don't actually need approval.
-     *
-     * Only 'supply' and 'repay' actions require token approval and should trigger allowance checks.
-     */
-    enabled: !!spokeProvider && !!params && params.action !== "borrow" && params.action !== "withdraw",
-    refetchInterval: 5e3,
-    gcTime: 0
-    // Don't cache failed queries
-  };
-  queryOptions = {
-    ...defaultQueryOptions,
-    ...queryOptions
-    // override default query options if provided
-  };
+  const payload = params?.payload;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["mm", "allowance", payload?.srcChainKey, payload?.token, payload?.action],
     queryFn: async () => {
-      if (!spokeProvider) throw new Error("Spoke provider is required");
-      if (!params) throw new Error("Params are required");
-      if (params.action === "borrow" || params.action === "withdraw") {
-        return true;
+      if (!payload) {
+        throw new Error("Params are required");
       }
-      const allowance = await sodax.moneyMarket.isAllowanceValid(params, spokeProvider);
-      if (!allowance.ok) {
-        throw allowance.error;
+      if (payload.action === "borrow" || payload.action === "withdraw") {
+        return true;
       }
-      return allowance.value;
-    }
+      const result = await sodax.moneyMarket.isAllowanceValid({ params: payload });
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!payload && payload.action !== "borrow" && payload.action !== "withdraw",
+    refetchInterval: 5e3,
+    gcTime: 0,
+    ...queryOptions
   });
 }
-function useMMApprove() {
+function useMMApprove({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const allowance = await sodax.moneyMarket.approve(params, spokeProvider, false);
-      if (!allowance.ok) {
-        throw allowance.error;
-      }
-      return allowance.value;
-    },
-    onSuccess: (_, { params, spokeProvider }) => {
+  return useSafeMutation({
+    mutationKey: ["mm", "approve"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.moneyMarket.approve({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
       queryClient.invalidateQueries({
-        queryKey: ["mm", "allowance", spokeProvider?.chainConfig.chain.id, params.token, params.action]
+        queryKey: ["mm", "allowance", params.srcChainKey, params.token, params.action]
       });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useAToken({ aToken, queryOptions }) {
+function useAToken({ params, queryOptions } = {}) {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["mm", "aToken", aToken],
-    enabled: !!aToken
-  };
-  queryOptions = {
-    ...defaultQueryOptions,
-    ...queryOptions
-    // override default query options if provided
-  };
+  const aToken = params?.aToken;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["mm", "aToken", aToken],
     queryFn: async () => {
       if (!aToken) {
-        throw new Error("aToken address or hub provider is not defined");
+        throw new Error("aToken address is required");
       }
       if (!isAddress(aToken)) {
         throw new Error("aToken address is not a valid address");
@@ -676,121 +678,92 @@ function useAToken({ aToken, queryOptions }) {
       const aTokenData = await sodax.moneyMarket.data.getATokenData(aToken);
       return {
         ...aTokenData,
-        xChainId: sodax.hubProvider.chainConfig.chain.id
+        chainKey: sodax.hubProvider.chainConfig.chain.key
       };
-    }
+    },
+    enabled: !!aToken && isAddress(aToken ?? ""),
+    ...queryOptions
   });
 }
 function useATokensBalances({
-  aTokens,
-  spokeProvider,
-  userAddress,
+  params,
   queryOptions
-}) {
+} = {}) {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["mm", "aTokensBalances", aTokens, spokeProvider?.chainConfig.chain.id, userAddress],
-    enabled: aTokens.length > 0 && aTokens.every((token) => isAddress(token)) && !!spokeProvider && !!userAddress
-  };
-  queryOptions = {
-    ...defaultQueryOptions,
-    ...queryOptions
-    // override default query options if provided
-  };
+  const aTokens = params?.aTokens ?? [];
+  const spokeChainKey = params?.spokeChainKey;
+  const userAddress = params?.userAddress;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["mm", "aTokensBalances", aTokens, spokeChainKey, userAddress],
     queryFn: async () => {
       if (aTokens.length === 0) {
         return /* @__PURE__ */ new Map();
       }
-      if (!spokeProvider || !userAddress) {
-        throw new Error("Spoke provider and user address are required");
+      if (!spokeChainKey || !userAddress) {
+        throw new Error("spokeChainKey and userAddress are required");
       }
       for (const aToken of aTokens) {
         if (!isAddress(aToken)) {
           throw new Error(`Invalid aToken address: ${aToken}`);
         }
       }
-      const hubWalletAddress = await HubService.getUserHubWalletAddress(userAddress, spokeProvider.chainConfig.chain.id, sodax.hubProvider);
-      return await sodax.moneyMarket.data.getATokensBalances(aTokens, hubWalletAddress);
-    }
+      const hubWalletAddress = await sodax.hubProvider.getUserHubWalletAddress(userAddress, spokeChainKey);
+      return sodax.moneyMarket.data.getATokensBalances(aTokens, hubWalletAddress);
+    },
+    enabled: aTokens.length > 0 && !!spokeChainKey && !!userAddress,
+    ...queryOptions
   });
 }
-function useReservesUsdFormat(params) {
+function useReservesUsdFormat({
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = { queryKey: ["mm", "reservesUsdFormat"] };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-    // override default query options if provided
-  };
   return useQuery({
-    ...queryOptions,
+    queryKey: ["mm", "reservesUsdFormat"],
     queryFn: async () => {
       const reserves = await sodax.moneyMarket.data.getReservesHumanized();
       return sodax.moneyMarket.data.formatReservesUSD(sodax.moneyMarket.data.buildReserveDataWithPrice(reserves));
-    }
+    },
+    ...queryOptions
   });
 }
-function isLegacyParams2(params) {
-  return "spokeProvider" in params || "address" in params;
-}
-function resolveParams2(params) {
-  if (isLegacyParams2(params)) {
-    return {
-      spokeChainId: params.spokeProvider?.chainConfig.chain.id,
-      userAddress: params.address
-    };
-  }
-  return { spokeChainId: params.spokeChainId, userAddress: params.userAddress };
-}
-function useUserFormattedSummary(params) {
+function useUserFormattedSummary({
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  const resolved = params ? resolveParams2(params) : { spokeChainId: void 0, userAddress: void 0 };
-  const defaultQueryOptions = {
-    queryKey: ["mm", "userFormattedSummary", resolved.spokeChainId, resolved.userAddress],
-    enabled: !!resolved.spokeChainId && !!resolved.userAddress,
-    refetchInterval: 5e3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-    // override default query options if provided
-  };
+  const spokeChainKey = params?.spokeChainKey;
+  const userAddress = params?.userAddress;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["mm", "userFormattedSummary", spokeChainKey, userAddress],
     queryFn: async () => {
-      if (!resolved.spokeChainId || !resolved.userAddress) {
-        throw new Error("spokeChainId or userAddress is not defined");
+      if (!spokeChainKey || !userAddress) {
+        throw new Error("spokeChainKey and userAddress are required");
       }
-      const reserves = await sodax.moneyMarket.data.getReservesHumanized();
+      const [reserves, userReserves] = await Promise.all([
+        sodax.moneyMarket.data.getReservesHumanized(),
+        sodax.moneyMarket.data.getUserReservesHumanized(spokeChainKey, userAddress)
+      ]);
       const formattedReserves = sodax.moneyMarket.data.formatReservesUSD(
         sodax.moneyMarket.data.buildReserveDataWithPrice(reserves)
       );
-      const userReserves = await sodax.moneyMarket.data.getUserReservesHumanized(
-        resolved.spokeChainId,
-        resolved.userAddress
-      );
       return sodax.moneyMarket.data.formatUserSummary(
         sodax.moneyMarket.data.buildUserSummaryRequest(reserves, formattedReserves, userReserves)
       );
-    }
+    },
+    enabled: !!spokeChainKey && !!userAddress,
+    refetchInterval: 5e3,
+    ...queryOptions
   });
 }
-var useQuote = (payload) => {
+var useQuote = ({
+  params,
+  queryOptions
+} = {}) => {
   const { sodax } = useSodaxContext();
-  const queryKey = useMemo(() => {
-    if (!payload) return ["quote", void 0];
-    return [
-      "quote",
-      {
-        ...payload,
-        amount: payload.amount.toString()
-      }
-    ];
-  }, [payload]);
+  const payload = params?.payload;
   return useQuery({
-    queryKey,
+    queryKey: ["swap", "quote", payload && { ...payload, amount: payload.amount.toString() }],
     queryFn: async () => {
       if (!payload) {
         return void 0;
@@ -798,1239 +771,1324 @@ var useQuote = (payload) => {
       return sodax.swaps.getQuote(payload);
     },
     enabled: !!payload,
-    refetchInterval: 3e3
+    refetchInterval: 3e3,
+    ...queryOptions
   });
 };
-function useSwap(spokeProvider) {
+function useSwap({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      return sodax.swaps.swap({
-        intentParams: params,
-        spokeProvider
-      });
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["xBalances"] });
+  return useSafeMutation({
+    mutationKey: ["swap"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.swaps.swap({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", vars.params.srcChainKey] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", vars.params.dstChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-var useStatus = (intent_tx_hash) => {
+var useStatus = ({
+  params,
+  queryOptions
+} = {}) => {
   const { sodax } = useSodaxContext();
+  const intentTxHash = params?.intentTxHash;
   return useQuery({
-    queryKey: [intent_tx_hash],
+    queryKey: ["swap", "status", intentTxHash],
     queryFn: async () => {
-      return sodax.swaps.getStatus({ intent_tx_hash });
+      if (!intentTxHash) return void 0;
+      return sodax.swaps.getStatus({ intent_tx_hash: intentTxHash });
     },
-    refetchInterval: 3e3
-    // 3s
+    enabled: !!intentTxHash,
+    refetchInterval: 3e3,
+    ...queryOptions
   });
 };
-function useSwapAllowance(params, spokeProvider) {
+function useSwapAllowance({
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const payload = params?.payload;
+  const srcChainKey = params?.srcChainKey;
+  const walletProvider = params?.walletProvider;
   return useQuery({
-    queryKey: ["allowance", params],
+    // Extract the (chain, owner, token, amount) tuple that actually scopes the allowance —
+    // raw-object keys break per Rule 4 (bigints) and churn on every render.
+    queryKey: [
+      "swap",
+      "allowance",
+      payload?.srcChainKey,
+      payload?.srcAddress,
+      payload?.inputToken,
+      payload?.inputAmount?.toString()
+    ],
     queryFn: async () => {
-      if (!spokeProvider || !params) {
+      if (!srcChainKey || !walletProvider || !payload) {
         return false;
       }
       const allowance = await sodax.swaps.isAllowanceValid({
-        intentParams: params,
-        spokeProvider
+        params: payload,
+        raw: false,
+        walletProvider
       });
-      if (allowance.ok) {
-        return allowance.value;
-      }
-      return false;
+      return allowance.ok ? allowance.value : false;
     },
-    enabled: !!spokeProvider && !!params,
-    refetchInterval: 2e3
+    enabled: !!srcChainKey && !!walletProvider && !!payload,
+    refetchInterval: 2e3,
+    ...queryOptions
   });
 }
-function useSwapApprove(params, spokeProvider) {
+function useSwapApprove({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  const {
-    mutateAsync: approve,
-    isPending,
-    error,
-    reset: resetError
-  } = useMutation({
-    mutationFn: async ({ params: params2 }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      if (!params2) {
-        throw new Error("Swap Params not found");
-      }
-      const allowance = await sodax.swaps.approve({
-        intentParams: params2,
-        spokeProvider
-      });
-      if (!allowance.ok) {
-        throw new Error("Failed to approve input token");
-      }
-      return allowance.ok;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["allowance", params] });
+  return useSafeMutation({
+    mutationKey: ["swap", "approve"],
+    ...mutationOptions,
+    mutationFn: async ({ params, walletProvider }) => unwrapResult(
+      await sodax.swaps.approve({
+        params,
+        raw: false,
+        walletProvider
+      })
+    ),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["swap", "allowance"] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
-  return {
-    approve,
-    isLoading: isPending,
-    error,
-    resetError
-  };
 }
-function useCancelSwap(spokeProvider) {
+
+// src/hooks/swap/useCancelSwap.ts
+function useCancelSwap({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async ({ intent, raw = false }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      return sodax.swaps.cancelIntent(intent, spokeProvider, raw);
-    }
+  return useSafeMutation({
+    mutationKey: ["swap", "cancel"],
+    ...mutationOptions,
+    mutationFn: async ({ srcChainKey, walletProvider, intent }) => unwrapResult(await sodax.swaps.cancelIntent({ params: { srcChainKey, intent }, walletProvider }))
   });
 }
-function useCreateLimitOrder(spokeProvider) {
+
+// src/hooks/swap/useCreateLimitOrder.ts
+function useCreateLimitOrder({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      return sodax.swaps.createLimitOrder({
-        intentParams: params,
-        spokeProvider
-      });
-    }
+  return useSafeMutation({
+    mutationKey: ["swap", "limitOrder", "create"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.swaps.createLimitOrder({ ...vars, raw: false }))
   });
 }
-function useCancelLimitOrder() {
+
+// src/hooks/swap/useCancelLimitOrder.ts
+function useCancelLimitOrder({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async ({ intent, spokeProvider, timeout }) => {
-      return sodax.swaps.cancelLimitOrder({
-        intent,
-        spokeProvider,
-        timeout
-      });
-    }
+  return useSafeMutation({
+    mutationKey: ["swap", "limitOrder", "cancel"],
+    ...mutationOptions,
+    mutationFn: async ({ srcChainKey, walletProvider, intent, timeout }) => unwrapResult(await sodax.swaps.cancelLimitOrder({ params: { srcChainKey, intent }, walletProvider, timeout }))
   });
 }
-var useBackendIntentByTxHash = (params) => {
+var useBackendIntentByTxHash = ({
+  params,
+  queryOptions
+} = {}) => {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "intent", "txHash", params?.params?.txHash],
-    enabled: !!params?.params?.txHash && params?.params?.txHash.length > 0,
-    retry: 3,
-    refetchInterval: 1e3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
+  const txHash = params?.txHash;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["backend", "intent", "txHash", txHash],
     queryFn: async () => {
-      if (!params?.params?.txHash) {
-        return void 0;
-      }
-      return sodax.backendApi.getIntentByTxHash(params.params.txHash);
-    }
+      if (!txHash) return void 0;
+      const result = await sodax.backendApi.getIntentByTxHash(txHash);
+      return result.ok ? result.value : void 0;
+    },
+    enabled: !!txHash && txHash.length > 0,
+    retry: 3,
+    refetchInterval: 1e3,
+    ...queryOptions
   });
 };
-var useBackendIntentByHash = (params) => {
+var useBackendIntentByHash = ({
+  params,
+  queryOptions
+} = {}) => {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "intent", "hash", params?.params?.intentHash],
-    enabled: !!params?.params?.intentHash && params?.params?.intentHash.length > 0,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
+  const intentHash = params?.intentHash;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["backend", "intent", "hash", intentHash],
     queryFn: async () => {
-      if (!params?.params?.intentHash) {
-        return void 0;
-      }
-      return sodax.backendApi.getIntentByHash(params.params.intentHash);
-    }
+      if (!intentHash) return void 0;
+      const result = await sodax.backendApi.getIntentByHash(intentHash);
+      return result.ok ? result.value : void 0;
+    },
+    enabled: !!intentHash && intentHash.length > 0,
+    retry: 3,
+    ...queryOptions
   });
 };
 var useBackendUserIntents = ({
   params,
   queryOptions
-}) => {
+} = {}) => {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "intent", "user", params],
-    enabled: !!params && !!params.userAddress && params.userAddress.length > 0,
-    retry: 3
-  };
-  queryOptions = {
-    ...defaultQueryOptions,
-    ...queryOptions
-    // override default query options if provided
-  };
+  const userAddress = params?.userAddress;
+  const startDate = params?.startDate;
+  const endDate = params?.endDate;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["backend", "intent", "user", userAddress, startDate, endDate],
     queryFn: async () => {
-      if (!params?.userAddress) {
-        return void 0;
-      }
-      return sodax.backendApi.getUserIntents(params);
-    }
+      if (!userAddress) return void 0;
+      return unwrapResult(await sodax.backendApi.getUserIntents({ userAddress, startDate, endDate }));
+    },
+    enabled: !!userAddress && userAddress.length > 0,
+    retry: 3,
+    ...queryOptions
   });
 };
-var useBackendSubmitSwapTx = (params) => {
+
+// src/hooks/backend/useBackendSubmitSwapTx.ts
+var useBackendSubmitSwapTx = ({
+  mutationOptions
+} = {}) => {
   const { sodax } = useSodaxContext();
-  const defaultMutationOptions = {
-    retry: 3
-  };
-  const mutationOptions = {
-    ...defaultMutationOptions,
-    ...params?.mutationOptions
-  };
-  return useMutation({
+  return useSafeMutation({
+    mutationKey: ["backend", "submitSwapTx"],
+    retry: 3,
     ...mutationOptions,
-    mutationFn: async (request) => {
-      return sodax.backendApi.submitSwapTx(request, params?.apiConfig);
-    }
+    mutationFn: async ({ request, apiConfig }) => unwrapResult(await sodax.backendApi.submitSwapTx(request, apiConfig))
   });
 };
-var useBackendSubmitSwapTxStatus = (params) => {
+var useBackendSubmitSwapTxStatus = ({
+  params,
+  queryOptions
+} = {}) => {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "swaps", "submit-tx", "status", params?.params?.txHash, params?.params?.srcChainId],
-    enabled: !!params?.params?.txHash && params.params.txHash.length > 0,
+  const txHash = params?.txHash;
+  const srcChainKey = params?.srcChainKey;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["backend", "submitSwapTx", "status", txHash, srcChainKey],
+    queryFn: async () => {
+      if (!txHash) return void 0;
+      return unwrapResult(
+        await sodax.backendApi.getSubmitSwapTxStatus(
+          {
+            txHash,
+            srcChainKey
+          },
+          apiConfig
+        )
+      );
+    },
+    enabled: !!txHash && txHash.length > 0,
     retry: 3,
     refetchInterval: (query) => {
       const status = query.state.data?.data?.status;
       if (status === "executed" || status === "failed") return false;
       return 1e3;
-    }
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
-  return useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!params?.params?.txHash) {
-        return void 0;
-      }
-      return sodax.backendApi.getSubmitSwapTxStatus(
-        {
-          txHash: params.params.txHash,
-          srcChainId: params.params.srcChainId
-        },
-        params.apiConfig
-      );
-    }
+    },
+    ...queryOptions
   });
 };
-var useBackendOrderbook = (params) => {
+var useBackendOrderbook = ({
+  params,
+  queryOptions
+} = {}) => {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "solver", "orderbook", params?.pagination?.offset, params?.pagination?.limit],
-    enabled: !!params?.pagination && !!params?.pagination.offset && !!params?.pagination.limit,
-    staleTime: 30 * 1e3,
-    // 30 seconds for real-time data
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-    // override default query options if provided
-  };
+  const pagination = params?.pagination;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["backend", "orderbook", pagination?.offset, pagination?.limit],
     queryFn: async () => {
-      if (!params?.pagination || !params?.pagination.offset || !params?.pagination.limit) {
-        return void 0;
+      if (!pagination?.offset || !pagination?.limit) {
+        throw new Error("Pagination offset and limit are required");
       }
-      return sodax.backendApi.getOrderbook(params.pagination);
-    }
+      return unwrapResult(await sodax.backendApi.getOrderbook(pagination));
+    },
+    enabled: !!pagination?.offset && !!pagination?.limit,
+    staleTime: 30 * 1e3,
+    retry: 3,
+    ...queryOptions
   });
 };
-var useBackendMoneyMarketPosition = (params) => {
+var useBackendMoneyMarketPosition = ({
+  params,
+  queryOptions
+} = {}) => {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "mm", "position", params?.userAddress],
-    enabled: !!params?.userAddress && params?.userAddress.length > 0,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
+  const userAddress = params?.userAddress;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["backend", "mm", "position", userAddress],
     queryFn: async () => {
-      if (!params?.userAddress) {
-        return void 0;
-      }
-      return sodax.backendApi.getMoneyMarketPosition(params.userAddress);
-    }
+      if (!userAddress) return void 0;
+      return unwrapResult(await sodax.backendApi.getMoneyMarketPosition(userAddress));
+    },
+    enabled: !!userAddress && userAddress.length > 0,
+    retry: 3,
+    ...queryOptions
   });
 };
-var useBackendAllMoneyMarketAssets = (params) => {
+var useBackendAllMoneyMarketAssets = ({
+  queryOptions
+} = {}) => {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "mm", "assets", "all"],
-    enabled: true,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
   return useQuery({
-    ...queryOptions,
+    queryKey: ["backend", "mm", "assets", "all"],
     queryFn: async () => {
-      return sodax.backendApi.getAllMoneyMarketAssets();
-    }
+      return unwrapResult(await sodax.backendApi.getAllMoneyMarketAssets());
+    },
+    retry: 3,
+    ...queryOptions
   });
 };
-var useBackendMoneyMarketAsset = (params) => {
+var useBackendMoneyMarketAsset = ({
+  params,
+  queryOptions
+} = {}) => {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "mm", "asset", params?.params?.reserveAddress],
-    enabled: !!params?.params?.reserveAddress && params?.params?.reserveAddress.length > 0,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
+  const reserveAddress = params?.reserveAddress;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["backend", "mm", "asset", reserveAddress],
     queryFn: async () => {
-      if (!params?.params?.reserveAddress) {
-        return void 0;
-      }
-      return sodax.backendApi.getMoneyMarketAsset(params.params.reserveAddress);
-    }
+      if (!reserveAddress) return void 0;
+      return unwrapResult(await sodax.backendApi.getMoneyMarketAsset(reserveAddress));
+    },
+    enabled: !!reserveAddress && reserveAddress.length > 0,
+    retry: 3,
+    ...queryOptions
   });
 };
-var useBackendMoneyMarketAssetBorrowers = (params) => {
+var useBackendMoneyMarketAssetBorrowers = ({
+  params,
+  queryOptions
+} = {}) => {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "mm", "asset", "borrowers", params],
-    enabled: !!params?.params?.reserveAddress && !!params.pagination.offset && !!params.pagination.limit,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
+  const reserveAddress = params?.reserveAddress;
+  const pagination = params?.pagination;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["backend", "mm", "asset", "borrowers", reserveAddress, pagination],
     queryFn: async () => {
-      if (!params?.params?.reserveAddress || !params.pagination.offset || !params.pagination.limit) {
+      if (!reserveAddress || !pagination?.offset || !pagination?.limit) {
         return void 0;
       }
-      return sodax.backendApi.getMoneyMarketAssetBorrowers(params.params.reserveAddress, {
-        offset: params.pagination.offset,
-        limit: params.pagination.limit
-      });
-    }
+      return unwrapResult(
+        await sodax.backendApi.getMoneyMarketAssetBorrowers(reserveAddress, {
+          offset: pagination.offset,
+          limit: pagination.limit
+        })
+      );
+    },
+    enabled: !!reserveAddress && !!pagination?.offset && !!pagination?.limit,
+    retry: 3,
+    ...queryOptions
   });
 };
-var useBackendMoneyMarketAssetSuppliers = (params) => {
+var useBackendMoneyMarketAssetSuppliers = ({
+  params,
+  queryOptions
+} = {}) => {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "mm", "asset", "suppliers", params],
-    enabled: !!params?.params?.reserveAddress && !!params.pagination.offset && !!params.pagination.limit,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
+  const reserveAddress = params?.reserveAddress;
+  const pagination = params?.pagination;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["backend", "mm", "asset", "suppliers", reserveAddress, pagination],
     queryFn: async () => {
-      if (!params?.params?.reserveAddress || !params.pagination.offset || !params.pagination.limit) {
+      if (!reserveAddress || !pagination?.offset || !pagination?.limit) {
         return void 0;
       }
-      return sodax.backendApi.getMoneyMarketAssetSuppliers(params.params.reserveAddress, {
-        offset: params.pagination.offset,
-        limit: params.pagination.limit
-      });
-    }
+      return unwrapResult(
+        await sodax.backendApi.getMoneyMarketAssetSuppliers(reserveAddress, {
+          offset: pagination.offset,
+          limit: pagination.limit
+        })
+      );
+    },
+    enabled: !!reserveAddress && !!pagination?.offset && !!pagination?.limit,
+    retry: 3,
+    ...queryOptions
   });
 };
-var useBackendAllMoneyMarketBorrowers = (params) => {
+var useBackendAllMoneyMarketBorrowers = ({
+  params,
+  queryOptions
+} = {}) => {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "mm", "borrowers", "all", params],
-    enabled: !!params && !!params.pagination.offset && !!params.pagination.limit,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
+  const pagination = params?.pagination;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["backend", "mm", "borrowers", "all", pagination],
     queryFn: async () => {
-      if (!params || !params.pagination.offset || !params.pagination.limit) {
+      if (!pagination?.offset || !pagination?.limit) {
         return void 0;
       }
-      return sodax.backendApi.getAllMoneyMarketBorrowers({
-        offset: params.pagination.offset,
-        limit: params.pagination.limit
-      });
-    }
+      return unwrapResult(
+        await sodax.backendApi.getAllMoneyMarketBorrowers({
+          offset: pagination.offset,
+          limit: pagination.limit
+        })
+      );
+    },
+    enabled: !!pagination?.offset && !!pagination?.limit,
+    retry: 3,
+    ...queryOptions
   });
 };
-function useBridgeAllowance(params, spokeProvider) {
+function useBridge({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["bridge"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.bridge.bridge({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", vars.params.srcChainKey] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", vars.params.dstChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    }
+  });
+}
+function useBridgeAllowance({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const payload = params?.payload;
+  const walletProvider = params?.walletProvider;
   return useQuery({
-    queryKey: ["bridge-allowance", params],
+    // Extract the (chain, owner, token, amount) tuple that actually scopes the allowance —
+    // raw-object keys break per Rule 4 (bigints) and churn on every render.
+    queryKey: [
+      "bridge",
+      "allowance",
+      payload?.srcChainKey,
+      payload?.srcAddress,
+      payload?.srcToken,
+      payload?.amount?.toString()
+    ],
     queryFn: async () => {
-      if (!spokeProvider || !params) {
+      if (!payload || !walletProvider) {
         return false;
       }
-      const allowance = await sodax.bridge.isAllowanceValid({
-        params,
-        spokeProvider
+      const result = await sodax.bridge.isAllowanceValid({
+        params: payload,
+        raw: false,
+        walletProvider
       });
-      if (allowance.ok) {
-        return allowance.value;
-      }
-      return false;
+      return result.ok ? result.value : false;
     },
-    enabled: !!spokeProvider && !!params
+    enabled: !!payload && !!walletProvider,
+    refetchInterval: 2e3,
+    gcTime: 0,
+    ...queryOptions
   });
 }
-function useBridgeApprove(spokeProvider) {
+function useBridgeApprove({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  const {
-    mutateAsync: approve,
-    isPending,
-    error,
-    reset: resetError
-  } = useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const allowance = await sodax.bridge.approve({
-        params,
-        spokeProvider
-      });
-      if (!allowance.ok) {
-        throw new Error("Failed to approve tokens for bridge");
-      }
-      return true;
-    },
-    onSuccess: (_, params) => {
-      queryClient.invalidateQueries({ queryKey: ["bridge-allowance", params] });
-    }
-  });
-  return {
-    approve,
-    isLoading: isPending,
-    error,
-    resetError
-  };
-}
-function useBridge(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.bridge.bridge({
-        params,
-        spokeProvider
-      });
-      if (!result.ok) {
-        throw new Error(`Bridge failed: ${result.error.code}`);
-      }
-      return result;
+  return useSafeMutation({
+    mutationKey: ["bridge", "approve"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.bridge.approve({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["bridge", "allowance"] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useGetBridgeableAmount(from, to) {
+function useGetBridgeableAmount({
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const from = params?.from;
+  const to = params?.to;
   return useQuery({
-    queryKey: ["spoke-asset-manager-token-balance", from, to],
+    queryKey: ["bridge", "bridgeableAmount", from, to],
     queryFn: async () => {
       if (!from || !to) {
-        return { amount: 0n, decimals: 0, type: "DEPOSIT_LIMIT" };
+        throw new Error("from and to tokens are required");
       }
       const result = await sodax.bridge.getBridgeableAmount(from, to);
-      if (result.ok) {
-        return result.value;
+      if (!result.ok) {
+        throw result.error;
       }
-      console.error("Error getting bridgeable amount:", result.error);
-      return { amount: 0n, decimals: 0, type: "DEPOSIT_LIMIT" };
+      return result.value;
     },
-    enabled: !!from && !!to
+    enabled: !!from && !!to,
+    ...queryOptions
   });
 }
-function useGetBridgeableTokens(from, to, token) {
+function useGetBridgeableTokens({
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const from = params?.from;
+  const to = params?.to;
+  const token = params?.token;
   return useQuery({
-    queryKey: ["bridgeable-tokens", from, to, token],
-    queryFn: async () => {
+    queryKey: ["bridge", "bridgeableTokens", from, to, token],
+    queryFn: () => {
       if (!from || !to || !token) {
-        return [];
+        throw new Error("from, to and token are required");
       }
       const result = sodax.bridge.getBridgeableTokens(from, to, token);
-      if (result.ok) {
-        return result.value;
+      if (!result.ok) {
+        throw result.error;
       }
-      console.error("Error getting bridgeable tokens:", result.error);
-      return [];
+      return result.value;
     },
-    enabled: !!from && !!to && !!token
+    enabled: !!from && !!to && !!token,
+    ...queryOptions
   });
 }
-function useStake(spokeProvider) {
+function useStake({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.stake(params, spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Stake failed: ${result.error.code}`);
-      }
-      return result.value;
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["staking", "stake"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.staking.stake({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ["staking", "info", params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({ queryKey: ["staking", "allowance", params.srcChainKey, "stake"] });
+      queryClient.invalidateQueries({ queryKey: ["staking", "stakeRatio"] });
+      queryClient.invalidateQueries({ queryKey: ["staking", "convertedAssets"] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", params.srcChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useStakeApprove(spokeProvider) {
+function useStakeApprove({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.approve({
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["staking", "approve", "stake"],
+    ...mutationOptions,
+    mutationFn: async ({ params, walletProvider }) => unwrapResult(
+      await sodax.staking.approve({
         params: { ...params, action: "stake" },
-        spokeProvider
-      });
-      if (!result.ok) {
-        throw new Error(`Stake approval failed: ${result.error.code}`);
-      }
-      return result.value;
+        raw: false,
+        walletProvider
+      })
+    ),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["staking", "allowance", vars.params.srcChainKey, "stake"] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useStakeAllowance(params, spokeProvider) {
+function useStakeAllowance({
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const payload = params?.payload;
   return useQuery({
-    queryKey: ["soda", "stakeAllowance", params, spokeProvider?.chainConfig.chain.id],
+    queryKey: ["staking", "allowance", payload?.srcChainKey, "stake", payload?.srcAddress, payload?.amount?.toString()],
     queryFn: async () => {
-      if (!params || !spokeProvider) {
-        return false;
+      if (!payload) {
+        throw new Error("Params are required");
       }
       const result = await sodax.staking.isAllowanceValid({
-        params: { ...params, action: "stake" },
-        spokeProvider
+        params: { ...payload, action: "stake" },
+        raw: true
       });
-      if (!result.ok) {
-        throw new Error(`Allowance check failed: ${result.error.code}`);
-      }
+      if (!result.ok) throw result.error;
       return result.value;
     },
-    enabled: !!params && !!spokeProvider,
-    refetchInterval: 5e3
-    // Refetch every 5 seconds
+    enabled: !!payload,
+    refetchInterval: 5e3,
+    gcTime: 0,
+    ...queryOptions
   });
 }
-function useUnstake(spokeProvider) {
+function useUnstake({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.unstake({ ...params, action: "unstake" }, spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Unstake failed: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["stakingInfo"] });
-      queryClient.invalidateQueries({ queryKey: ["unstakingInfo"] });
-      queryClient.invalidateQueries({ queryKey: ["unstakingInfoWithPenalty"] });
+  return useSafeMutation({
+    mutationKey: ["staking", "unstake"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.staking.unstake({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ["staking", "info", params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({ queryKey: ["staking", "unstakingInfo", params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({
+        queryKey: ["staking", "unstakingInfoWithPenalty", params.srcChainKey, params.srcAddress]
+      });
+      queryClient.invalidateQueries({ queryKey: ["staking", "allowance", params.srcChainKey, "unstake"] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useClaim(spokeProvider) {
+function useClaim({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.claim({ ...params, action: "claim" }, spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Claim failed: ${result.error.code}`);
-      }
-      return result.value;
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["staking", "claim"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.staking.claim({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ["staking", "unstakingInfo", params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({
+        queryKey: ["staking", "unstakingInfoWithPenalty", params.srcChainKey, params.srcAddress]
+      });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", params.srcChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useCancelUnstake(spokeProvider) {
+function useCancelUnstake({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not available");
-      }
-      const result = await sodax.staking.cancelUnstake({ ...params, action: "cancelUnstake" }, spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Cancel unstake failed: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["stakingInfo"] });
-      queryClient.invalidateQueries({ queryKey: ["unstakingInfo"] });
-      queryClient.invalidateQueries({ queryKey: ["unstakingInfoWithPenalty"] });
+  return useSafeMutation({
+    mutationKey: ["staking", "cancelUnstake"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.staking.cancelUnstake({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ["staking", "unstakingInfo", params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({
+        queryKey: ["staking", "unstakingInfoWithPenalty", params.srcChainKey, params.srcAddress]
+      });
+      queryClient.invalidateQueries({ queryKey: ["staking", "info", params.srcChainKey, params.srcAddress] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useStakingInfo(spokeProvider, refetchInterval = 5e3) {
+function useStakingInfo({ params, queryOptions } = {}) {
   const { sodax } = useSodaxContext();
+  const srcAddress = params?.srcAddress;
+  const srcChainKey = params?.srcChainKey;
   return useQuery({
-    queryKey: ["soda", "stakingInfo", spokeProvider?.chainConfig.chain.id],
+    queryKey: ["staking", "info", srcChainKey, srcAddress],
     queryFn: async () => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.getStakingInfoFromSpoke(spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Failed to fetch staking info: ${result.error.code}`);
+      if (!srcAddress || !srcChainKey) {
+        throw new Error("srcAddress and srcChainKey are required");
       }
+      const result = await sodax.staking.getStakingInfoFromSpoke(srcAddress, srcChainKey);
+      if (!result.ok) throw result.error;
       return result.value;
     },
-    enabled: !!spokeProvider,
-    refetchInterval
+    enabled: !!srcAddress && !!srcChainKey,
+    refetchInterval: 5e3,
+    ...queryOptions
   });
 }
-function useUnstakingInfoWithPenalty(userAddress, spokeProvider, refetchInterval = 5e3) {
+function useUnstakingInfoWithPenalty({
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const srcAddress = params?.srcAddress;
+  const srcChainKey = params?.srcChainKey;
   return useQuery({
-    queryKey: ["soda", "unstakingInfoWithPenalty", spokeProvider?.chainConfig.chain.id, userAddress],
+    queryKey: ["staking", "unstakingInfoWithPenalty", srcChainKey, srcAddress],
     queryFn: async () => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const penaltyResult = await sodax.staking.getUnstakingInfoWithPenalty(spokeProvider);
-      if (!penaltyResult.ok) {
-        throw new Error(`Failed to fetch unstaking info with penalty: ${penaltyResult.error.code}`);
+      if (!srcAddress || !srcChainKey) {
+        throw new Error("srcAddress and srcChainKey are required");
       }
-      return penaltyResult.value;
+      const result = await sodax.staking.getUnstakingInfoWithPenalty(srcAddress, srcChainKey);
+      if (!result.ok) throw result.error;
+      return result.value;
     },
-    enabled: !!spokeProvider && !!userAddress,
-    refetchInterval
+    enabled: !!srcAddress && !!srcChainKey,
+    refetchInterval: 5e3,
+    ...queryOptions
   });
 }
-function useStakingConfig(refetchInterval = 3e4) {
+function useStakingConfig({
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   return useQuery({
-    queryKey: ["soda", "stakingConfig"],
+    queryKey: ["staking", "config"],
     queryFn: async () => {
       const result = await sodax.staking.getStakingConfig();
-      if (!result.ok) {
-        throw new Error(`Failed to fetch staking config: ${result.error.code}`);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    staleTime: Number.POSITIVE_INFINITY,
+    ...queryOptions
+  });
+}
+function useStakeRatio({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const amount = params?.amount;
+  return useQuery({
+    queryKey: ["staking", "stakeRatio", amount?.toString()],
+    queryFn: async () => {
+      if (amount === void 0) {
+        throw new Error("amount is required");
       }
+      const result = await sodax.staking.getStakeRatio(amount);
+      if (!result.ok) throw result.error;
       return result.value;
     },
-    refetchInterval
+    enabled: amount !== void 0,
+    refetchInterval: 1e4,
+    ...queryOptions
   });
 }
-function useStakeRatio(amount, refetchInterval = 1e4) {
+function useInstantUnstakeRatio({
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const amount = params?.amount;
   return useQuery({
-    queryKey: ["soda", "stakeRatio", amount?.toString()],
+    queryKey: ["staking", "instantUnstakeRatio", amount?.toString()],
     queryFn: async () => {
-      if (!amount || amount <= 0n) {
-        throw new Error("Amount must be greater than 0");
+      if (amount === void 0) {
+        throw new Error("amount is required");
       }
-      if (!sodax?.staking) {
-        throw new Error("Staking service not available");
+      const result = await sodax.staking.getInstantUnstakeRatio(amount);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: amount !== void 0,
+    refetchInterval: 1e4,
+    ...queryOptions
+  });
+}
+function useConvertedAssets({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const amount = params?.amount;
+  return useQuery({
+    queryKey: ["staking", "convertedAssets", amount?.toString()],
+    queryFn: async () => {
+      if (amount === void 0) {
+        throw new Error("amount is required");
       }
-      const result = await sodax.staking.getStakeRatio(amount);
-      if (!result.ok) {
-        throw new Error(`Failed to fetch stake ratio: ${result.error.code}`);
+      const result = await sodax.staking.getConvertedAssets(amount);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: amount !== void 0,
+    refetchInterval: 1e4,
+    ...queryOptions
+  });
+}
+function useInstantUnstake({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["staking", "instantUnstake"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.staking.instantUnstake({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ["staking", "info", params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({ queryKey: ["staking", "instantUnstakeRatio"] });
+      queryClient.invalidateQueries({ queryKey: ["staking", "allowance", params.srcChainKey, "instantUnstake"] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", params.srcChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    }
+  });
+}
+function useUnstakeAllowance({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const payload = params?.payload;
+  return useQuery({
+    queryKey: [
+      "staking",
+      "allowance",
+      payload?.srcChainKey,
+      "unstake",
+      payload?.srcAddress,
+      payload?.amount?.toString()
+    ],
+    queryFn: async () => {
+      if (!payload) {
+        throw new Error("Params are required");
       }
+      const result = await sodax.staking.isAllowanceValid({
+        params: { ...payload, action: "unstake" },
+        raw: true
+      });
+      if (!result.ok) throw result.error;
       return result.value;
     },
-    enabled: !!amount && amount > 0n && !!sodax?.staking,
-    refetchInterval
+    enabled: !!payload,
+    refetchInterval: 5e3,
+    gcTime: 0,
+    ...queryOptions
   });
 }
-function useInstantUnstakeRatio(amount, refetchInterval = 1e4) {
+function useUnstakeApprove({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  console.log("useInstantUnstakeRatio hook called with:", { amount: amount?.toString(), sodax: !!sodax });
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["staking", "approve", "unstake"],
+    ...mutationOptions,
+    mutationFn: async ({ params, walletProvider }) => unwrapResult(
+      await sodax.staking.approve({
+        params: { ...params, action: "unstake" },
+        raw: false,
+        walletProvider
+      })
+    ),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["staking", "allowance", vars.params.srcChainKey, "unstake"] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    }
+  });
+}
+function useUnstakingInfo({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const srcAddress = params?.srcAddress;
+  const srcChainKey = params?.srcChainKey;
   return useQuery({
-    queryKey: ["soda", "instantUnstakeRatio", amount?.toString()],
+    queryKey: ["staking", "unstakingInfo", srcChainKey, srcAddress],
     queryFn: async () => {
-      console.log("useInstantUnstakeRatio queryFn called with amount:", amount?.toString());
-      if (!amount || amount <= 0n) {
-        throw new Error("Amount must be greater than 0");
+      if (!srcAddress || !srcChainKey) {
+        throw new Error("srcAddress and srcChainKey are required");
       }
-      if (!sodax?.staking) {
-        throw new Error("Staking service not available");
+      const result = await sodax.staking.getUnstakingInfo(srcAddress, srcChainKey);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!srcAddress && !!srcChainKey,
+    refetchInterval: 5e3,
+    ...queryOptions
+  });
+}
+function useInstantUnstakeApprove({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["staking", "approve", "instantUnstake"],
+    ...mutationOptions,
+    mutationFn: async ({ params, walletProvider }) => unwrapResult(
+      await sodax.staking.approve({
+        params: { ...params, action: "instantUnstake" },
+        raw: false,
+        walletProvider
+      })
+    ),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({
+        queryKey: ["staking", "allowance", vars.params.srcChainKey, "instantUnstake"]
+      });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    }
+  });
+}
+function useInstantUnstakeAllowance({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const payload = params?.payload;
+  return useQuery({
+    queryKey: [
+      "staking",
+      "allowance",
+      payload?.srcChainKey,
+      "instantUnstake",
+      payload?.srcAddress,
+      payload?.amount?.toString()
+    ],
+    queryFn: async () => {
+      if (!payload) {
+        throw new Error("Params are required");
       }
-      const result = await sodax.staking.getInstantUnstakeRatio(amount);
-      if (!result.ok) {
-        throw new Error(`Failed to fetch instant unstake ratio: ${result.error.code}`);
+      const result = await sodax.staking.isAllowanceValid({
+        params: { ...payload, action: "instantUnstake" },
+        raw: true
+      });
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!payload,
+    refetchInterval: 5e3,
+    gcTime: 0,
+    ...queryOptions
+  });
+}
+function useFetchAssetsBalances({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const queryAddress = params?.queryAddress;
+  return useQuery({
+    queryKey: ["partner", "feeClaim", "assetsBalances", queryAddress],
+    queryFn: async () => {
+      if (!queryAddress) {
+        throw new Error("queryAddress is required");
       }
+      const result = await sodax.partners.feeClaim.fetchAssetsBalances(queryAddress);
+      if (!result.ok) throw result.error;
       return result.value;
     },
-    enabled: !!amount && amount > 0n && !!sodax?.staking,
-    refetchInterval
+    enabled: !!queryAddress,
+    ...queryOptions
   });
 }
-function useConvertedAssets(amount, refetchInterval = 1e4) {
+function useGetAutoSwapPreferences({
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const queryAddress = params?.queryAddress;
   return useQuery({
-    queryKey: ["soda", "convertedAssets", amount?.toString()],
+    queryKey: ["partner", "feeClaim", "autoSwapPreferences", queryAddress],
     queryFn: async () => {
-      if (!amount || amount <= 0n) {
-        throw new Error("Amount must be greater than 0");
+      if (!queryAddress) {
+        throw new Error("queryAddress is required");
       }
-      const result = await sodax.staking.getConvertedAssets(amount);
-      if (!result.ok) {
-        throw new Error(`Failed to fetch converted assets: ${result.error.code}`);
+      const result = await sodax.partners.feeClaim.getAutoSwapPreferences(queryAddress);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!queryAddress,
+    ...queryOptions
+  });
+}
+function useIsTokenApproved({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const payload = params?.payload;
+  return useQuery({
+    queryKey: ["partner", "feeClaim", "isTokenApproved", payload?.srcChainKey, payload?.srcAddress, payload?.token],
+    queryFn: async () => {
+      if (!payload) {
+        throw new Error("params are required");
       }
+      const result = await sodax.partners.feeClaim.isTokenApproved(payload);
+      if (!result.ok) throw result.error;
       return result.value;
     },
-    enabled: !!amount && amount > 0n && !!sodax?.staking,
-    refetchInterval
+    enabled: !!payload,
+    refetchInterval: 5e3,
+    gcTime: 0,
+    ...queryOptions
   });
 }
-function useInstantUnstake(spokeProvider) {
+function useApproveToken({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("spokeProvider is not found");
-      }
-      const result = await sodax.staking.instantUnstake({ ...params, action: "instantUnstake" }, spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Instant unstake failed: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    onError: (error) => {
-      console.error("Instant unstake error:", error);
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["partner", "approveToken"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.partners.feeClaim.approveToken({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({
+        queryKey: ["partner", "feeClaim", "isTokenApproved", params.srcChainKey, params.srcAddress, params.token]
+      });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useUnstakeAllowance(params, spokeProvider) {
+function useSetSwapPreference({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useQuery({
-    queryKey: ["soda", "unstakeAllowance", params, spokeProvider?.chainConfig.chain.id],
-    queryFn: async () => {
-      if (!params || !spokeProvider) {
-        return false;
-      }
-      const result = await sodax.staking.isAllowanceValid({
-        params: { ...params, action: "unstake" },
-        spokeProvider
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["partner", "setSwapPreference"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.partners.feeClaim.setSwapPreference({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({
+        queryKey: ["partner", "feeClaim", "autoSwapPreferences", vars.params.srcAddress]
       });
-      if (!result.ok) {
-        console.error(`Unstake allowance check failed: ${result.error.code}, error: ${result.error.error}`);
-        throw new Error(`Unstake allowance check failed: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    enabled: !!params && !!spokeProvider,
-    refetchInterval: 5e3
-    // Refetch every 5 seconds
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    }
   });
 }
-function useUnstakeApprove(spokeProvider) {
+function useFeeClaimSwap({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async (params) => {
-      console.log("useUnstakeApprove called with params:", params);
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.approve({
-        params: { ...params, action: "unstake" },
-        spokeProvider
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["partner", "feeClaimSwap"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.partners.feeClaim.swap({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({
+        queryKey: ["partner", "feeClaim", "assetsBalances", vars.params.srcAddress]
       });
-      if (!result.ok) {
-        throw new Error(`Unstake approval failed: ${result.error.code}`);
-      }
-      return result.value;
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useUnstakingInfo(userAddress, spokeProvider, refetchInterval = 5e3) {
+function useHubAssetBalances({
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const chainKey = params?.chainKey;
+  const srcAddress = params?.srcAddress;
   return useQuery({
-    queryKey: ["soda", "unstakingInfoWithPenalty", spokeProvider?.chainConfig.chain.id, userAddress],
+    queryKey: ["recovery", "hubAssetBalances", chainKey, srcAddress],
     queryFn: async () => {
-      if (!spokeProvider || !userAddress) {
-        throw new Error("Spoke provider or user address not found");
-      }
-      const result = await sodax.staking.getUnstakingInfo(spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Failed to fetch unstaking info: ${result.error.code}`);
+      if (!chainKey || !srcAddress) {
+        throw new Error("chainKey and srcAddress are required");
       }
+      const result = await sodax.recovery.fetchHubAssetBalances({ chainKey, srcAddress });
+      if (!result.ok) throw result.error;
       return result.value;
     },
-    enabled: !!spokeProvider && !!userAddress,
-    refetchInterval
+    enabled: !!chainKey && !!srcAddress,
+    staleTime: 1e4,
+    ...queryOptions
   });
 }
-function useInstantUnstakeApprove(spokeProvider) {
+function useWithdrawHubAsset({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async (params) => {
-      console.log("useInstantUnstakeApprove called with params:", params);
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.approve({
-        params: { ...params, action: "instantUnstake" },
-        spokeProvider
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["recovery", "withdrawHubAsset"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.recovery.withdrawHubAsset({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({
+        queryKey: ["recovery", "hubAssetBalances", params.srcChainKey, params.srcAddress]
       });
-      if (!result.ok) {
-        throw new Error(`Instant unstake approval failed: ${result.error.code}`);
-      }
-      return result.value;
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", params.srcChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useInstantUnstakeAllowance(params, spokeProvider) {
+function useMigrateIcxToSoda({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useQuery({
-    queryKey: ["soda", "instantUnstakeAllowance", params, spokeProvider?.chainConfig.chain.id],
-    queryFn: async () => {
-      if (!params || !spokeProvider) {
-        return false;
-      }
-      const result = await sodax.staking.isAllowanceValid({
-        params: { ...params, action: "instantUnstake" },
-        spokeProvider
-      });
-      if (!result.ok) {
-        console.error(`Unstake allowance check failed: ${result.error.code}, error: ${result.error.error}`);
-        throw new Error(`Unstake allowance check failed: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    enabled: !!params && !!spokeProvider,
-    refetchInterval: 5e3
-    // Refetch every 5 seconds
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["migrate", "icxToSoda"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.migration.migrateIcxToSoda({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["migrate", "allowance"] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", vars.params.srcChainKey] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", ChainKeys.SONIC_MAINNET] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    }
   });
 }
-
-// src/hooks/migrate/types.ts
-var MIGRATION_MODE_ICX_SODA = "icxsoda";
-var MIGRATION_MODE_BNUSD = "bnusd";
-
-// src/hooks/migrate/useMigrate.tsx
-function useMigrate(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return useMutation({
-    mutationFn: async (params) => {
-      const { token, amount, migrationMode = MIGRATION_MODE_ICX_SODA, toToken, destinationAddress } = params;
-      const amountToMigrate = parseUnits(amount ?? "0", token?.decimals ?? 0);
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      if (migrationMode === MIGRATION_MODE_ICX_SODA) {
-        if (token?.xChainId === ICON_MAINNET_CHAIN_ID) {
-          const params2 = {
-            address: spokeChainConfig[ICON_MAINNET_CHAIN_ID].nativeToken,
-            amount: amountToMigrate,
-            to: destinationAddress
-          };
-          const result2 = await sodax.migration.migrateIcxToSoda(params2, spokeProvider, 3e4);
-          if (result2.ok) {
-            const [spokeTxHash, hubTxHash] = result2.value;
-            return { spokeTxHash, hubTxHash };
-          }
-          throw new Error("ICX to SODA migration failed. Please try again.");
-        }
-        const revertParams = {
-          amount: amountToMigrate,
-          to: destinationAddress
-        };
-        const result = await sodax.migration.revertMigrateSodaToIcx(
-          revertParams,
-          spokeProvider,
-          3e4
-        );
-        if (result.ok) {
-          const [hubTxHash, spokeTxHash] = result.value;
-          return { spokeTxHash, hubTxHash };
-        }
-        throw new Error("SODA to ICX migration failed. Please try again.");
-      }
-      if (migrationMode === MIGRATION_MODE_BNUSD) {
-        const params2 = {
-          srcChainId: token?.xChainId,
-          dstChainId: toToken?.xChainId,
-          srcbnUSD: token?.address,
-          dstbnUSD: toToken?.address,
-          amount: amountToMigrate,
-          to: destinationAddress
-        };
-        const result = await sodax.migration.migratebnUSD(params2, spokeProvider, 3e4);
-        if (result.ok) {
-          const [spokeTxHash, hubTxHash] = result.value;
-          return { spokeTxHash, hubTxHash };
-        }
-        const errorMessage = isLegacybnUSDToken(token?.address) ? "bnUSD migration failed. Please try again." : "bnUSD reverse migration failed. Please try again.";
-        throw new Error(errorMessage);
-      }
-      throw new Error("Invalid migration mode");
+function useRevertMigrateSodaToIcx({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["migrate", "revertSodaToIcx"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.migration.revertMigrateSodaToIcx({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["migrate", "allowance"] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", vars.params.srcChainKey] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", ChainKeys.ICON_MAINNET] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useMigrationAllowance(params, spokeProvider) {
+function useMigratebnUSD({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  return useQuery({
-    queryKey: ["migration-allowance", params],
-    queryFn: async () => {
-      if (!spokeProvider || !params) {
-        return false;
-      }
-      const { token, amount, migrationMode = MIGRATION_MODE_ICX_SODA, toToken, destinationAddress } = params;
-      if (token?.xChainId === ICON_MAINNET_CHAIN_ID) {
-        return true;
-      }
-      if (!spokeProvider) throw new Error("Spoke provider is required");
-      const amountToMigrate = parseUnits(amount ?? "0", token?.decimals ?? 0);
-      let migrationParams;
-      if (migrationMode === MIGRATION_MODE_ICX_SODA) {
-        migrationParams = {
-          amount: amountToMigrate,
-          to: destinationAddress
-        };
-      } else {
-        if (!toToken) throw new Error("Destination token is required for bnUSD migration");
-        migrationParams = {
-          srcChainId: token?.xChainId,
-          dstChainId: toToken?.xChainId,
-          srcbnUSD: token?.address,
-          dstbnUSD: toToken?.address,
-          amount: amountToMigrate,
-          to: destinationAddress
-        };
-      }
-      const allowance = await sodax.migration.isAllowanceValid(migrationParams, "revert", spokeProvider);
-      if (allowance.ok) {
-        return allowance.value;
-      }
-      return false;
-    },
-    enabled: !!spokeProvider && !!params,
-    refetchInterval: 2e3
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["migrate", "bnUSD"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.migration.migratebnUSD({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ["migrate", "allowance"] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", params.srcChainKey] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", params.dstChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    }
   });
 }
-function useMigrationApprove(params, spokeProvider) {
+function useMigrateBaln({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState(null);
-  const [isApproved, setIsApproved] = useState(false);
   const queryClient = useQueryClient();
-  const prevTokenAddress = useRef(void 0);
-  const prevAmount = useRef(void 0);
-  useEffect(() => {
-    if (prevTokenAddress.current !== params?.token?.address || prevAmount.current !== params?.amount) {
-      setIsApproved(false);
-      prevTokenAddress.current = params?.token?.address;
-      prevAmount.current = params?.amount;
+  return useSafeMutation({
+    mutationKey: ["migrate", "baln"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.migration.migrateBaln({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["migrate", "allowance"] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", ChainKeys.ICON_MAINNET] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", ChainKeys.SONIC_MAINNET] });
+      queryClient.invalidateQueries({ queryKey: ["staking", "info"] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
-  }, [params?.token?.address, params?.amount]);
-  const approve = useCallback(
-    async ({ params: approveParams }) => {
-      try {
-        setIsLoading(true);
-        setError(null);
-        if (!spokeProvider) {
-          throw new Error("Spoke provider not found");
-        }
-        if (!approveParams) {
-          throw new Error("Migration intent not found");
-        }
-        const { token, amount, migrationMode = MIGRATION_MODE_ICX_SODA, toToken, destinationAddress } = approveParams;
-        const amountToMigrate = parseUnits(amount ?? "0", token?.decimals ?? 0);
-        let result;
-        if (migrationMode === MIGRATION_MODE_ICX_SODA) {
-          const revertParams = {
-            amount: amountToMigrate,
-            to: destinationAddress
-          };
-          result = await sodax.migration.approve(revertParams, "revert", spokeProvider, false);
-        } else if (migrationMode === MIGRATION_MODE_BNUSD) {
-          if (!toToken) throw new Error("Destination token is required for bnUSD migration");
-          const migrationParams = {
-            srcChainId: token?.xChainId,
-            dstChainId: toToken?.xChainId,
-            srcbnUSD: token?.address,
-            dstbnUSD: toToken?.address,
-            amount: amountToMigrate,
-            to: destinationAddress
-          };
-          result = await sodax.migration.approve(migrationParams, "revert", spokeProvider, false);
-        } else {
-          throw new Error("Invalid migration mode");
-        }
-        if (!result.ok) {
-          throw new Error("Failed to approve tokens");
-        }
-        setIsApproved(true);
-        queryClient.invalidateQueries({ queryKey: ["migration-allowance", params] });
-        return result.ok;
-      } catch (err) {
-        const error2 = err instanceof Error ? err : new Error("An unknown error occurred");
-        setError(error2);
-        throw error2;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [spokeProvider, sodax, queryClient, params]
-  );
-  const resetError = useCallback(() => {
-    setError(null);
-  }, []);
-  return {
-    approve,
-    isLoading,
-    error,
-    resetError,
-    isApproved
-  };
+  });
 }
-function usePools(params) {
+function useMigrationApprove({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["dex", "pools"],
-    staleTime: Number.POSITIVE_INFINITY
-    // Pools list is static, cache indefinitely
-  };
-  const queryOptions = { ...defaultQueryOptions, ...params?.queryOptions };
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["migrate", "approve"],
+    ...mutationOptions,
+    mutationFn: async ({ action, ...actionParams }) => unwrapResult(
+      await sodax.migration.approve(
+        { ...actionParams, raw: false },
+        action
+      )
+    ),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["migrate", "allowance"] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    }
+  });
+}
+var REFETCH_INTERVAL_MS2 = 2e3;
+function useMigrationAllowance({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const migrationParams = params?.params;
+  const action = params?.action;
   return useQuery({
-    ...queryOptions,
+    // Extract the (chain, owner, token, amount) tuple that actually scopes the allowance —
+    // raw-object keys break per Rule 4 (bigints) and churn on every render.
+    queryKey: [
+      "migrate",
+      "allowance",
+      action,
+      migrationParams?.srcChainKey,
+      migrationParams?.srcAddress,
+      migrationParams && "srcbnUSD" in migrationParams ? migrationParams.srcbnUSD : void 0,
+      migrationParams?.amount?.toString()
+    ],
     queryFn: async () => {
-      return sodax.dex.clService.getPools();
-    }
+      if (!migrationParams || !action) return false;
+      const result = await sodax.migration.isAllowanceValid(migrationParams, action);
+      return result.ok ? result.value : false;
+    },
+    enabled: !!migrationParams && !!action,
+    refetchInterval: REFETCH_INTERVAL_MS2,
+    ...queryOptions
   });
 }
-function usePoolData({
-  poolKey,
-  queryOptions = {
-    queryKey: ["dex", "poolData", poolKey],
-    enabled: poolKey !== null,
-    staleTime: 1e4,
-    refetchInterval: 3e4
-  }
-}) {
+function usePools({ queryOptions } = {}) {
   const { sodax } = useSodaxContext();
   return useQuery({
-    ...queryOptions,
+    queryKey: ["dex", "pools"],
+    queryFn: () => sodax.dex.clService.getPools(),
+    staleTime: Number.POSITIVE_INFINITY,
+    ...queryOptions
+  });
+}
+function usePoolData({ params, queryOptions } = {}) {
+  const { sodax } = useSodaxContext();
+  const poolKey = params?.poolKey ?? null;
+  return useQuery({
+    queryKey: ["dex", "poolData", poolKey],
     queryFn: async () => {
       if (!poolKey) {
         throw new Error("Pool key is required");
       }
-      return await sodax.dex.clService.getPoolData(poolKey, sodax.hubProvider.publicClient);
+      const result = await sodax.dex.clService.getPoolData(poolKey, sodax.hubProvider.publicClient);
+      if (!result.ok) throw result.error;
+      return result.value;
     },
-    enabled: poolKey !== null
+    enabled: poolKey !== null,
+    staleTime: 1e4,
+    refetchInterval: 3e4,
+    ...queryOptions
   });
 }
 function usePoolBalances({
-  poolData,
-  poolKey,
-  spokeProvider,
-  enabled = true,
-  queryOptions = {
-    queryKey: [
-      "dex",
-      "poolBalances",
-      poolData?.poolKey,
-      spokeProvider?.chainConfig.chain.id
-    ],
-    enabled: enabled && poolData !== null && poolKey !== null && spokeProvider !== null,
-    staleTime: 5e3,
-    // Consider data stale after 5 seconds
-    refetchInterval: 1e4
-    // Refetch every 10 seconds
-  }
-}) {
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const poolData = params?.poolData ?? null;
+  const poolKey = params?.poolKey ?? null;
+  const spokeChainKey = params?.spokeChainKey;
+  const userAddress = params?.userAddress;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["dex", "poolBalances", poolData?.poolId, spokeChainKey, userAddress],
     queryFn: async () => {
-      if (!poolData || !spokeProvider || !poolKey) {
-        throw new Error("Pool data, pool key, and spoke provider are required");
-      }
-      const [balance0, balance1] = await Promise.all([
-        sodax.dex.assetService.getDeposit(poolData.token0.address, spokeProvider),
-        sodax.dex.assetService.getDeposit(poolData.token1.address, spokeProvider)
+      if (!poolData || !poolKey || !spokeChainKey || !userAddress) {
+        throw new Error("poolData, poolKey, spokeChainKey, and userAddress are required");
+      }
+      const hubWallet = await sodax.hubProvider.getUserHubWalletAddress(userAddress, spokeChainKey);
+      const [token0Balance, token1Balance] = await Promise.all([
+        sodax.hubProvider.publicClient.readContract({
+          address: poolData.token0.address,
+          abi: erc20Abi,
+          functionName: "balanceOf",
+          args: [hubWallet]
+        }),
+        sodax.hubProvider.publicClient.readContract({
+          address: poolData.token1.address,
+          abi: erc20Abi,
+          functionName: "balanceOf",
+          args: [hubWallet]
+        })
       ]);
-      return {
-        token0Balance: balance0,
-        token1Balance: balance1
-      };
-    }
+      return { token0Balance, token1Balance };
+    },
+    enabled: !!poolData && !!poolKey && !!spokeChainKey && !!userAddress,
+    staleTime: 5e3,
+    refetchInterval: 1e4,
+    ...queryOptions
   });
 }
 function usePositionInfo({
-  tokenId,
-  poolKey,
-  queryOptions = {
-    queryKey: ["dex", "positionInfo", tokenId, poolKey],
-    enabled: tokenId !== null && poolKey !== null && tokenId !== "",
-    staleTime: 1e4
-    // Consider data stale after 10 seconds
-  }
-}) {
+  params,
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const tokenId = params?.tokenId ?? null;
+  const poolKey = params?.poolKey ?? null;
   return useQuery({
+    queryKey: ["dex", "positionInfo", tokenId, poolKey],
     queryFn: async () => {
       if (!tokenId || !poolKey) {
         throw new Error("Token ID and pool key are required");
       }
-      const tokenIdBigInt = BigInt(tokenId);
-      const publicClient = sodax.hubProvider.publicClient;
-      const info = await sodax.dex.clService.getPositionInfo(tokenIdBigInt, publicClient);
+      const infoResult = await sodax.dex.clService.getPositionInfo(BigInt(tokenId), sodax.hubProvider.publicClient);
+      if (!infoResult.ok) throw infoResult.error;
+      const info = infoResult.value;
       const isValid = info.poolKey.currency0.toLowerCase() === poolKey.currency0.toLowerCase() && info.poolKey.currency1.toLowerCase() === poolKey.currency1.toLowerCase() && info.poolKey.fee === poolKey.fee;
-      return {
-        positionInfo: info,
-        isValid
-      };
+      return { positionInfo: info, isValid };
     },
+    enabled: tokenId !== null && tokenId !== "" && poolKey !== null,
+    staleTime: 1e4,
     ...queryOptions
   });
 }
-function useDexDeposit() {
+function useDexDeposit({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider is required");
-      }
-      if (!params) {
-        throw new Error("Deposit params are required");
-      }
-      const depositResult = await sodax.dex.assetService.deposit({
-        params,
-        spokeProvider
+  return useSafeMutation({
+    mutationKey: ["dex", "deposit"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.dex.assetService.deposit({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances", params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({
+        queryKey: ["dex", "allowance", params.srcChainKey, params.asset, params.amount.toString()]
       });
-      if (!depositResult.ok) {
-        throw new Error(`Deposit failed: ${depositResult.error?.code || "Unknown error"}`);
-      }
-      return depositResult.value;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances"] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", params.srcChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useDexWithdraw() {
+function useDexWithdraw({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider is required");
-      }
-      const withdrawResult = await sodax.dex.assetService.withdraw({
-        params,
-        spokeProvider
-      });
-      if (!withdrawResult.ok) {
-        throw new Error(`Withdraw failed: ${withdrawResult.error.code}`);
-      }
-      return withdrawResult.value;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances"] });
+  return useSafeMutation({
+    mutationKey: ["dex", "withdraw"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.dex.assetService.withdraw({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances", params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", params.srcChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
 function useDexAllowance({
   params,
-  spokeProvider,
-  queryOptions = {
-    queryKey: [
-      "dex",
-      "allowance",
-      params?.asset,
-      params?.poolToken,
-      params?.amount.toString(),
-      spokeProvider?.chainConfig.chain.id
-    ],
-    enabled: !!params && !!spokeProvider
-  }
-}) {
+  queryOptions
+} = {}) {
   const { sodax } = useSodaxContext();
+  const payload = params?.payload;
   return useQuery({
-    ...queryOptions,
+    queryKey: ["dex", "allowance", payload?.srcChainKey, payload?.asset, payload?.amount?.toString()],
     queryFn: async () => {
-      if (!params || !spokeProvider) {
-        throw new Error("Params and spoke provider are required");
-      }
-      const allowanceResult = await sodax.dex.assetService.isAllowanceValid({
-        params: {
-          asset: params.asset,
-          amount: params.amount,
-          poolToken: params.poolToken
-        },
-        spokeProvider
-      });
-      if (!allowanceResult.ok) {
-        return false;
+      if (!payload) {
+        throw new Error("Params are required");
       }
-      return allowanceResult.value;
-    }
+      const result = await sodax.dex.assetService.isAllowanceValid({ params: payload, raw: true });
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!payload,
+    refetchInterval: 5e3,
+    gcTime: 0,
+    ...queryOptions
   });
 }
-function useDexApprove() {
+function useDexApprove({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      const approveResult = await sodax.dex.assetService.approve({
-        params,
-        spokeProvider,
-        raw: false
+  return useSafeMutation({
+    mutationKey: ["dex", "approve"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.dex.assetService.approve({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({
+        queryKey: ["dex", "allowance", params.srcChainKey, params.asset, params.amount.toString()]
       });
-      if (!approveResult.ok) {
-        throw new Error("Approval failed");
-      }
-      return approveResult.value;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["dex", "allowance"] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
@@ -2042,48 +2100,28 @@ function useLiquidityAmounts(minPrice, maxPrice, poolData) {
     const parsedMin = Number.parseFloat(minPrice);
     const parsedMax = Number.parseFloat(maxPrice);
     const isValid = parsedMin > 0 && parsedMax > 0 && parsedMin < parsedMax;
-    return {
-      minPriceNum: parsedMin,
-      maxPriceNum: parsedMax,
-      isValidPriceRange: isValid
-    };
+    return { minPriceNum: parsedMin, maxPriceNum: parsedMax, isValidPriceRange: isValid };
   }, [minPrice, maxPrice]);
   const { tickLower, tickUpper, currentTick } = useMemo(() => {
     if (!poolData || !isValidPriceRange) {
-      return {
-        tickLower: null,
-        tickUpper: null,
-        currentTick: null
-      };
+      return { tickLower: null, tickUpper: null, currentTick: null };
     }
     try {
       const lower = ClService.priceToTick(minPriceNum, poolData.token0, poolData.token1, poolData.tickSpacing);
       const upper = ClService.priceToTick(maxPriceNum, poolData.token0, poolData.token1, poolData.tickSpacing);
-      return {
-        tickLower: lower,
-        tickUpper: upper,
-        currentTick: BigInt(poolData.currentTick)
-      };
+      return { tickLower: lower, tickUpper: upper, currentTick: BigInt(poolData.currentTick) };
     } catch (err) {
       console.error("Failed to calculate ticks:", err);
-      return {
-        tickLower: null,
-        tickUpper: null,
-        currentTick: null
-      };
+      return { tickLower: null, tickUpper: null, currentTick: null };
     }
   }, [minPriceNum, maxPriceNum, poolData, isValidPriceRange]);
   const handleToken0AmountChange = useCallback(
     (value) => {
       setLiquidityToken0Amount(value);
       setLastEditedToken("token0");
-      if (!value || !poolData || !tickLower || !tickUpper || !currentTick) {
-        return;
-      }
+      if (!value || !poolData || !tickLower || !tickUpper || !currentTick) return;
       const amount0 = Number.parseFloat(value);
-      if (amount0 <= 0 || !isValidPriceRange) {
-        return;
-      }
+      if (amount0 <= 0 || !isValidPriceRange) return;
       try {
         const amount0BigInt = BigInt(Math.floor(amount0 * 10 ** poolData.token0.decimals));
         const amount1BigInt = ClService.calculateAmount1FromAmount0(
@@ -2105,13 +2143,9 @@ function useLiquidityAmounts(minPrice, maxPrice, poolData) {
     (value) => {
       setLiquidityToken1Amount(value);
       setLastEditedToken("token1");
-      if (!value || !poolData || !tickLower || !tickUpper || !currentTick) {
-        return;
-      }
+      if (!value || !poolData || !tickLower || !tickUpper || !currentTick) return;
       const amount1 = Number.parseFloat(value);
-      if (amount1 <= 0 || !isValidPriceRange) {
-        return;
-      }
+      if (amount1 <= 0 || !isValidPriceRange) return;
       try {
         const amount1BigInt = BigInt(Math.floor(amount1 * 10 ** poolData.token1.decimals));
         const amount0BigInt = ClService.calculateAmount0FromAmount1(
@@ -2130,9 +2164,7 @@ function useLiquidityAmounts(minPrice, maxPrice, poolData) {
     [poolData, tickLower, tickUpper, currentTick, isValidPriceRange]
   );
   useEffect(() => {
-    if (!poolData || !tickLower || !tickUpper || !lastEditedToken || !isValidPriceRange) {
-      return;
-    }
+    if (!poolData || !tickLower || !tickUpper || !lastEditedToken || !isValidPriceRange) return;
     if (lastEditedToken === "token0" && liquidityToken0Amount) {
       handleToken0AmountChange(liquidityToken0Amount);
     } else if (lastEditedToken === "token1" && liquidityToken1Amount) {
@@ -2159,73 +2191,71 @@ function useLiquidityAmounts(minPrice, maxPrice, poolData) {
     handleToken1AmountChange
   };
 }
-function useSupplyLiquidity() {
+function useSupplyLiquidity({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (params.tokenId && params.isValidPosition) {
-        const increaseResult = await sodax.dex.clService.increaseLiquidity({
-          params: {
-            poolKey: params.poolKey,
-            tokenId: BigInt(params.tokenId),
-            tickLower: params.tickLower,
-            tickUpper: params.tickUpper,
-            liquidity: params.liquidity,
-            amount0Max: params.amount0Max,
-            amount1Max: params.amount1Max,
-            sqrtPriceX96: params.sqrtPriceX96
-          },
-          spokeProvider
-        });
-        if (!increaseResult.ok) {
-          throw new Error(`Increase liquidity failed: ${increaseResult.error?.code || "Unknown error"}`);
-        }
-        return increaseResult.value;
-      }
-      const supplyResult = await sodax.dex.clService.supplyLiquidity({
-        params: {
-          poolKey: params.poolKey,
-          tickLower: params.tickLower,
-          tickUpper: params.tickUpper,
-          liquidity: params.liquidity,
-          amount0Max: params.amount0Max,
-          amount1Max: params.amount1Max,
-          sqrtPriceX96: params.sqrtPriceX96
-        },
-        spokeProvider
-      });
-      if (!supplyResult.ok) {
-        throw new Error(`Supply liquidity failed: ${supplyResult.error?.code || "Unknown error"}`);
+  return useSafeMutation({
+    mutationKey: ["dex", "supplyLiquidity"],
+    ...mutationOptions,
+    mutationFn: async ({ params, walletProvider, timeout }) => {
+      const sharedParams = {
+        srcChainKey: params.srcChainKey,
+        srcAddress: params.srcAddress,
+        poolKey: params.poolKey,
+        tickLower: params.tickLower,
+        tickUpper: params.tickUpper,
+        liquidity: params.liquidity,
+        amount0Max: params.amount0Max,
+        amount1Max: params.amount1Max,
+        sqrtPriceX96: params.sqrtPriceX96
+      };
+      if (params.tokenId !== void 0 && params.isValidPosition) {
+        const increaseParams = {
+          ...sharedParams,
+          tokenId: typeof params.tokenId === "bigint" ? params.tokenId : BigInt(params.tokenId)
+        };
+        return unwrapResult(
+          await sodax.dex.clService.increaseLiquidity({ params: increaseParams, raw: false, walletProvider, timeout })
+        );
       }
-      return supplyResult.value;
+      return unwrapResult(
+        await sodax.dex.clService.supplyLiquidity({ params: sharedParams, raw: false, walletProvider, timeout })
+      );
     },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances"] });
-      queryClient.invalidateQueries({ queryKey: ["dex", "positionInfo"] });
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      if (params.tokenId !== void 0 && params.isValidPosition) {
+        const tokenIdStr = String(params.tokenId);
+        queryClient.invalidateQueries({ queryKey: ["dex", "positionInfo", tokenIdStr, params.poolKey] });
+      } else {
+        queryClient.invalidateQueries({ queryKey: ["dex", "positionInfo"] });
+      }
+      queryClient.invalidateQueries({ queryKey: ["dex", "poolData", params.poolKey] });
+      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances", params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", params.srcChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-function useDecreaseLiquidity() {
+function useDecreaseLiquidity({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider is required");
-      }
-      const decreaseResult = await sodax.dex.clService.decreaseLiquidity({
-        params,
-        spokeProvider
+  return useSafeMutation({
+    mutationKey: ["dex", "decreaseLiquidity"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.dex.clService.decreaseLiquidity({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({
+        queryKey: ["dex", "positionInfo", params.tokenId.toString(), params.poolKey]
       });
-      if (!decreaseResult.ok) {
-        throw new Error(`Decrease liquidity failed: ${decreaseResult.error?.code || "Unknown error"}`);
-      }
-      return decreaseResult.value;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances"] });
-      queryClient.invalidateQueries({ queryKey: ["dex", "positionInfo"] });
+      queryClient.invalidateQueries({ queryKey: ["dex", "poolData", params.poolKey] });
+      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances", params.srcChainKey, params.srcAddress] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
@@ -2433,37 +2463,57 @@ function useCreateWithdrawParams({
     return createWithdrawParamsProps({ tokenIndex, amount, poolData, poolSpokeAssets, dst });
   }, [tokenIndex, amount, poolData, poolSpokeAssets, dst]);
 }
-function useClaimRewards() {
+function useClaimRewards({
+  mutationOptions
+} = {}) {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider is required");
-      }
-      const result = await sodax.dex.clService.claimRewards({
-        params,
-        spokeProvider
-      });
-      if (!result.ok) {
-        throw new Error(`Claim rewards failed: ${result.error?.code || "Unknown error"}`);
-      }
-      return result.value;
-    },
-    onSuccess: (_, { params, spokeProvider }) => {
+  return useSafeMutation({
+    mutationKey: ["dex", "claimRewards"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.dex.clService.claimRewards({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
       queryClient.invalidateQueries({
-        queryKey: ["dex", "poolBalances", params.poolKey, spokeProvider.chainConfig.chain.id]
+        queryKey: ["dex", "positionInfo", params.tokenId.toString(), params.poolKey]
       });
-      queryClient.invalidateQueries({ queryKey: ["dex", "positionInfo", params.tokenId, params.poolKey] });
-      queryClient.invalidateQueries({ queryKey: ["dex", "poolData", params.poolKey] });
+      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances", params.srcChainKey, params.srcAddress] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     }
   });
 }
-var SodaxProvider = ({ children, testnet = false, config, rpcConfig }) => {
-  const sodax = new Sodax(config);
-  return /* @__PURE__ */ React.createElement(SodaxContext.Provider, { value: { sodax, testnet, rpcConfig } }, children);
+var SodaxProvider = ({ children, config }) => {
+  const configRef = useRef(config);
+  const frozen = configRef.current;
+  const sodax = useMemo(() => new Sodax(frozen), [frozen]);
+  return /* @__PURE__ */ jsx(SodaxContext.Provider, { value: { sodax }, children });
+};
+var defaultOnMutationError = (error) => {
+  console.error("[sodax] Mutation error:", error);
 };
+function createSodaxQueryClient({
+  onMutationError = defaultOnMutationError,
+  config
+} = {}) {
+  if (config?.mutationCache) {
+    config.mutationCache.subscribe((event) => {
+      if (event.type === "updated" && event.action.type === "error" && event.mutation.options.meta?.silent !== true) {
+        onMutationError(event.action.error);
+      }
+    });
+    return new QueryClient(config);
+  }
+  return new QueryClient({
+    ...config,
+    mutationCache: new MutationCache({
+      onError: (error, _vars, _ctx, mutation) => {
+        if (mutation.options.meta?.silent === true) return;
+        onMutationError(error);
+      }
+    })
+  });
+}
 
-export { MIGRATION_MODE_BNUSD, MIGRATION_MODE_ICX_SODA, SodaxProvider, clearRadfiSession, createDecreaseLiquidityParamsProps, createDepositParamsProps, createSupplyLiquidityParamsProps, createWithdrawParamsProps, loadRadfiSession, saveRadfiSession, useAToken, useATokensBalances, useBackendAllMoneyMarketAssets, useBackendAllMoneyMarketBorrowers, useBackendIntentByHash, useBackendIntentByTxHash, useBackendMoneyMarketAsset, useBackendMoneyMarketAssetBorrowers, useBackendMoneyMarketAssetSuppliers, useBackendMoneyMarketPosition, useBackendOrderbook, useBackendSubmitSwapTx, useBackendSubmitSwapTxStatus, useBackendUserIntents, useBitcoinBalance, useBorrow, useBridge, useBridgeAllowance, useBridgeApprove, useCancelLimitOrder, useCancelSwap, useCancelUnstake, useClaim, useClaimRewards, useConvertedAssets, useCreateDecreaseLiquidityParams, useCreateDepositParams, useCreateLimitOrder, useCreateSupplyLiquidityParams, useCreateWithdrawParams, useDecreaseLiquidity, useDeriveUserWalletAddress, useDexAllowance, useDexApprove, useDexDeposit, useDexWithdraw, useEstimateGas, useExpiredUtxos, useFundTradingWallet, useGetBridgeableAmount, useGetBridgeableTokens, useGetUserHubWalletAddress, useHubProvider, useInstantUnstake, useInstantUnstakeAllowance, useInstantUnstakeApprove, useInstantUnstakeRatio, useLiquidityAmounts, useMMAllowance, useMMApprove, useMigrate, useMigrationAllowance, useMigrationApprove, usePoolBalances, usePoolData, usePools, usePositionInfo, useQuote, useRadfiAuth, useRadfiSession, useRadfiWithdraw, useRenewUtxos, useRepay, useRequestTrustline, useReservesData, useReservesUsdFormat, useSodaxContext, useSpokeProvider, useStake, useStakeAllowance, useStakeApprove, useStakeRatio, useStakingConfig, useStakingInfo, useStatus, useStellarTrustlineCheck, useSupply, useSupplyLiquidity, useSwap, useSwapAllowance, useSwapApprove, useTradingWalletBalance, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserFormattedSummary, useUserReservesData, useWithdraw };
+export { SodaxProvider, clearRadfiSession, createDecreaseLiquidityParamsProps, createDepositParamsProps, createSodaxQueryClient, createSupplyLiquidityParamsProps, createWithdrawParamsProps, getXBalancesQueryOptions, loadRadfiSession, saveRadfiSession, toResult, unwrapResult, useAToken, useATokensBalances, useApproveToken, useBackendAllMoneyMarketAssets, useBackendAllMoneyMarketBorrowers, useBackendIntentByHash, useBackendIntentByTxHash, useBackendMoneyMarketAsset, useBackendMoneyMarketAssetBorrowers, useBackendMoneyMarketAssetSuppliers, useBackendMoneyMarketPosition, useBackendOrderbook, useBackendSubmitSwapTx, useBackendSubmitSwapTxStatus, useBackendUserIntents, useBitcoinBalance, useBorrow, useBridge, useBridgeAllowance, useBridgeApprove, useCancelLimitOrder, useCancelSwap, useCancelUnstake, useClaim, useClaimRewards, useConvertedAssets, useCreateDecreaseLiquidityParams, useCreateDepositParams, useCreateLimitOrder, useCreateSupplyLiquidityParams, useCreateWithdrawParams, useDecreaseLiquidity, useDeriveUserWalletAddress, useDexAllowance, useDexApprove, useDexDeposit, useDexWithdraw, useEstimateGas, useExpiredUtxos, useFeeClaimSwap, useFetchAssetsBalances, useFundTradingWallet, useGetAutoSwapPreferences, useGetBridgeableAmount, useGetBridgeableTokens, useGetUserHubWalletAddress, useHubAssetBalances, useHubProvider, useInstantUnstake, useInstantUnstakeAllowance, useInstantUnstakeApprove, useInstantUnstakeRatio, useIsTokenApproved, useLiquidityAmounts, useMMAllowance, useMMApprove, useMigrateBaln, useMigrateIcxToSoda, useMigratebnUSD, useMigrationAllowance, useMigrationApprove, usePoolBalances, usePoolData, usePools, usePositionInfo, useQuote, useRadfiAuth, useRadfiSession, useRadfiWithdraw, useRenewUtxos, useRepay, useRequestTrustline, useReservesData, useReservesHumanized, useReservesList, useReservesUsdFormat, useRevertMigrateSodaToIcx, useSafeMutation, useSetSwapPreference, useSodaxContext, useStake, useStakeAllowance, useStakeApprove, useStakeRatio, useStakingConfig, useStakingInfo, useStatus, useStellarTrustlineCheck, useSupply, useSupplyLiquidity, useSwap, useSwapAllowance, useSwapApprove, useTradingWallet, useTradingWalletBalance, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserFormattedSummary, useUserReservesData, useWithdraw, useWithdrawHubAsset, useXBalances };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map