@sodax/dapp-kit 2.0.0-rc.2 → 2.0.0-rc.4

package/dist/index.cjs

@@ -1,2642 +0,0 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
-var react = require('react');
-var sdk = require('@sodax/sdk');
-var viem = require('viem');
-var jsxRuntime = require('react/jsx-runtime');
-
-// 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 = reactQuery.useMutation(options);
-  const { mutateAsync } = mutation;
-  const mutateAsyncSafe = react.useCallback(
-    (vars, opts) => toResult(mutateAsync(vars, opts)),
-    [mutateAsync]
-  );
-  return { ...mutation, mutateAsyncSafe };
-}
-var SodaxContext = react.createContext(null);
-var useSodaxContext = () => {
-  const context = react.useContext(SodaxContext);
-  if (!context) {
-    throw new Error("useSodaxContext must be used within a SodaxProvider");
-  }
-  return context;
-};
-
-// 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({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const spokeChainId = params?.spokeChainId;
-  const spokeAddress = params?.spokeAddress;
-  return reactQuery.useQuery({
-    queryKey: ["shared", "deriveUserWalletAddress", spokeChainId, spokeAddress],
-    queryFn: async () => {
-      if (!spokeChainId || !spokeAddress) {
-        throw new Error("Spoke chain id and address are required");
-      }
-      return await sodax.hubProvider.getUserHubWalletAddress(spokeAddress, spokeChainId);
-    },
-    enabled: !!spokeChainId && !!spokeAddress,
-    refetchInterval: false,
-    ...queryOptions
-  });
-}
-function useStellarTrustlineCheck({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const token = params?.token;
-  const amount = params?.amount;
-  const chainId = params?.chainId;
-  const walletProvider = params?.walletProvider;
-  return reactQuery.useQuery({
-    queryKey: ["shared", "stellarTrustlineCheck", token],
-    queryFn: async () => {
-      if (chainId !== sdk.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: !!walletProvider && !!token && !!amount,
-    ...queryOptions
-  });
-}
-function useRequestTrustline(token) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  const [isLoading, setIsLoading] = react.useState(false);
-  const [isRequested, setIsRequested] = react.useState(false);
-  const [error, setError] = react.useState(null);
-  const [data, setData] = react.useState(null);
-  const requestTrustline = react.useCallback(
-    async ({
-      token: token2,
-      amount,
-      srcChainKey,
-      walletProvider
-    }) => {
-      if (!token2 || !amount) {
-        const error2 = new Error("Token and amount are required");
-        setError(error2);
-        throw error2;
-      }
-      setIsLoading(true);
-      setError(null);
-      try {
-        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: ["shared", "stellarTrustlineCheck", token2] });
-        return result;
-      } catch (err) {
-        const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
-        setError(error2);
-        throw error2;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [queryClient, sodax]
-  );
-  return { requestTrustline, isLoading, isRequested, error, data };
-}
-function useGetUserHubWalletAddress({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const spokeChainId = params?.spokeChainId;
-  const spokeAddress = params?.spokeAddress;
-  return reactQuery.useQuery({
-    queryKey: ["shared", "userHubWalletAddress", spokeChainId, spokeAddress],
-    queryFn: async () => {
-      if (!spokeChainId || !spokeAddress) {
-        throw new Error("Spoke chain id and address are required");
-      }
-      return await sodax.hubProvider.getUserHubWalletAddress(spokeAddress, spokeChainId);
-    },
-    enabled: !!spokeChainId && !!spokeAddress,
-    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 reactQuery.useQuery({
-    ...getXBalancesQueryOptions({
-      xService: params?.xService,
-      xChainId: params?.xChainId,
-      xTokens: params?.xTokens ?? [],
-      address: params?.address
-    }),
-    ...queryOptions
-  });
-}
-
-// src/hooks/provider/useHubProvider.ts
-function useHubProvider() {
-  const { sodax } = useSodaxContext();
-  return sodax.hubProvider;
-}
-var SESSION_KEY = (address) => `radfi_session_${address}`;
-function saveRadfiSession(address, session) {
-  try {
-    localStorage.setItem(SESSION_KEY(address), JSON.stringify(session));
-  } catch {
-  }
-}
-function loadRadfiSession(address) {
-  try {
-    const raw = localStorage.getItem(SESSION_KEY(address));
-    return raw ? JSON.parse(raw) : null;
-  } catch {
-    return null;
-  }
-}
-function clearRadfiSession(address) {
-  try {
-    localStorage.removeItem(SESSION_KEY(address));
-  } catch {
-  }
-}
-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 radfi.authenticateWithWallet(
-          walletProvider,
-          cachedPublicKey
-        );
-        saveRadfiSession(walletAddress, { accessToken, refreshToken, tradingAddress, publicKey });
-        return { accessToken, refreshToken, tradingAddress };
-      } catch (err) {
-        const isAlreadyRegistered = err instanceof sdk.RadfiApiError && err.code === "4008";
-        if (isAlreadyRegistered && existingSession?.refreshToken) {
-          try {
-            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
-            };
-          } catch {
-            clearRadfiSession(walletAddress);
-          }
-          throw new Error(
-            "This wallet is already registered with Radfi from another session. Please clear your browser storage for this site and try again, or wait for the previous session to expire."
-          );
-        }
-        throw err;
-      }
-    }
-  });
-}
-var REFRESH_INTERVAL = 5 * 60 * 1e3;
-function useRadfiSession(walletProvider) {
-  const { sodax } = useSodaxContext();
-  const [walletAddress, setWalletAddress] = react.useState();
-  const [isAuthed, setIsAuthed] = react.useState(false);
-  const [tradingAddress, setTradingAddress] = react.useState();
-  const isRefreshingRef = react.useRef(false);
-  const silentRefresh = react.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);
-        setTradingAddress(void 0);
-      } finally {
-        isRefreshingRef.current = false;
-      }
-    },
-    [walletProvider, sodax]
-  );
-  react.useEffect(() => {
-    if (!walletProvider) return;
-    setIsAuthed(false);
-    setTradingAddress(void 0);
-    setWalletAddress(void 0);
-    walletProvider.getWalletAddress().then((addr) => {
-      setWalletAddress(addr);
-      const session = loadRadfiSession(addr);
-      if (!session?.refreshToken) return;
-      silentRefresh(addr);
-    }).catch(() => {
-    });
-  }, [walletProvider, silentRefresh]);
-  react.useEffect(() => {
-    if (!walletAddress || !walletProvider) return;
-    const id = setInterval(() => {
-      silentRefresh(walletAddress);
-    }, REFRESH_INTERVAL);
-    return () => clearInterval(id);
-  }, [walletAddress, walletProvider, silentRefresh]);
-  const { mutateAsyncSafe: loginMutateSafe, isPending: isLoginPending } = useRadfiAuth();
-  const login = react.useCallback(async () => {
-    if (!walletProvider) {
-      return;
-    }
-    const result = await loginMutateSafe({ walletProvider });
-    if (!result.ok) {
-      return;
-    }
-    setIsAuthed(true);
-    setTradingAddress(result.value.tradingAddress || void 0);
-  }, [loginMutateSafe, walletProvider]);
-  return { walletAddress, isAuthed, tradingAddress, login, isLoginPending };
-}
-function useFundTradingWallet({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  return useSafeMutation({
-    mutationKey: ["bitcoin", "fundTradingWallet"],
-    ...mutationOptions,
-    mutationFn: async ({ amount, walletProvider }) => {
-      const walletAddress = await walletProvider.getWalletAddress();
-      return sodax.spoke.bitcoin.fundTradingWallet(amount, walletAddress, walletProvider);
-    },
-    onSuccess: async (data, vars, ctx) => {
-      queryClient.invalidateQueries({ queryKey: ["bitcoin", "balance"] });
-      queryClient.invalidateQueries({ queryKey: ["bitcoin", "tradingWalletBalance"] });
-      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", sdk.ChainKeys.BITCOIN_MAINNET] });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-var DEFAULT_RPC_URL = "https://mempool.space/api";
-function useBitcoinBalance({
-  params,
-  queryOptions
-} = {}) {
-  const address = params?.address;
-  const rpcUrl = params?.rpcUrl ?? DEFAULT_RPC_URL;
-  return reactQuery.useQuery({
-    queryKey: ["bitcoin", "balance", address],
-    queryFn: async () => {
-      if (!address) return 0n;
-      const response = await fetch(`${rpcUrl}/address/${address}/utxo`);
-      if (!response.ok) return 0n;
-      const utxos = await response.json();
-      return BigInt(utxos.reduce((sum, utxo) => sum + utxo.value, 0));
-    },
-    enabled: !!address,
-    ...queryOptions
-  });
-}
-
-// 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 reactQuery.useQuery({
-    queryKey: ["bitcoin", "tradingWalletBalance", tradingAddress],
-    queryFn: () => {
-      if (!walletProvider || !tradingAddress) {
-        throw new Error("walletProvider and tradingAddress are required");
-      }
-      return sodax.spoke.bitcoin.radfi.getBalance(tradingAddress);
-    },
-    enabled: !!walletProvider && !!tradingAddress,
-    ...queryOptions
-  });
-}
-function useExpiredUtxos({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const walletProvider = params?.walletProvider;
-  const tradingAddress = params?.tradingAddress;
-  return reactQuery.useQuery({
-    queryKey: ["bitcoin", "expiredUtxos", tradingAddress],
-    queryFn: async () => {
-      if (!walletProvider || !tradingAddress) {
-        throw new Error("walletProvider and tradingAddress are required");
-      }
-      const result = await sodax.spoke.bitcoin.radfi.getExpiredUtxos(tradingAddress);
-      return result.data;
-    },
-    enabled: !!walletProvider && !!tradingAddress,
-    refetchInterval: 6e4,
-    ...queryOptions
-  });
-}
-function useRenewUtxos({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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 || radfi.accessToken;
-      if (!accessToken) {
-        throw new Error("Radfi authentication required. Please login first.");
-      }
-      const buildResult = await radfi.buildRenewUtxoTransaction({ userAddress, txIdVouts }, accessToken);
-      const signedTx = await walletProvider.signTransaction(buildResult.base64Psbt, false);
-      const signedBase64Tx = sdk.normalizePsbtToBase64(signedTx);
-      return radfi.signAndBroadcastRenewUtxo({ userAddress, signedBase64Tx }, accessToken);
-    },
-    onSuccess: async (data, vars, ctx) => {
-      queryClient.invalidateQueries({ queryKey: ["bitcoin", "expiredUtxos"] });
-      queryClient.invalidateQueries({ queryKey: ["bitcoin", "tradingWalletBalance"] });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function useRadfiWithdraw({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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 || radfi.accessToken;
-      if (!accessToken) {
-        throw new Error("Radfi authentication required. Please login first.");
-      }
-      const buildResult = await radfi.withdrawToUser({ userAddress, amount, tokenId, withdrawTo }, accessToken);
-      const signedTx = await walletProvider.signTransaction(buildResult.base64Psbt, false);
-      const signedBase64Tx = sdk.normalizePsbtToBase64(signedTx);
-      const txId = await radfi.signAndBroadcastWithdraw({ userAddress, signedBase64Tx }, accessToken);
-      return { txId, fee: buildResult.fee.totalFee };
-    },
-    onSuccess: async (data, vars, ctx) => {
-      queryClient.invalidateQueries({ queryKey: ["bitcoin", "tradingWalletBalance"] });
-      queryClient.invalidateQueries({ queryKey: ["bitcoin", "balance"] });
-      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", sdk.ChainKeys.BITCOIN_MAINNET] });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function useBorrow({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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] });
-      }
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function useRepay({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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] });
-      }
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function useUserReservesData({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const spokeChainKey = params?.spokeChainKey;
-  const userAddress = params?.userAddress;
-  return reactQuery.useQuery({
-    queryKey: ["mm", "userReservesData", spokeChainKey, userAddress],
-    queryFn: async () => {
-      if (!spokeChainKey || !userAddress) {
-        throw new Error("spokeChainKey and userAddress are required");
-      }
-      return sodax.moneyMarket.data.getUserReservesData(spokeChainKey, userAddress);
-    },
-    enabled: !!spokeChainKey && !!userAddress,
-    refetchInterval: 5e3,
-    ...queryOptions
-  });
-}
-function useReservesData({
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["mm", "reservesData"],
-    queryFn: async () => sodax.moneyMarket.data.getReservesData(),
-    refetchInterval: 5e3,
-    ...queryOptions
-  });
-}
-function useReservesHumanized({
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["mm", "reservesHumanized"],
-    queryFn: async () => sodax.moneyMarket.data.getReservesHumanized(),
-    refetchInterval: 5e3,
-    ...queryOptions
-  });
-}
-function useReservesList({
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["mm", "reservesList"],
-    queryFn: async () => sodax.moneyMarket.data.getReservesList(),
-    ...queryOptions
-  });
-}
-function useMMAllowance({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const payload = params?.payload;
-  return reactQuery.useQuery({
-    queryKey: ["mm", "allowance", payload?.srcChainKey, payload?.token, payload?.action],
-    queryFn: async () => {
-      if (!payload) {
-        throw new Error("Params are required");
-      }
-      if (payload.action === "borrow" || payload.action === "withdraw") {
-        return true;
-      }
-      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({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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", params.srcChainKey, params.token, params.action]
-      });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function useAToken({ params, queryOptions } = {}) {
-  const { sodax } = useSodaxContext();
-  const aToken = params?.aToken;
-  return reactQuery.useQuery({
-    queryKey: ["mm", "aToken", aToken],
-    queryFn: async () => {
-      if (!aToken) {
-        throw new Error("aToken address is required");
-      }
-      if (!viem.isAddress(aToken)) {
-        throw new Error("aToken address is not a valid address");
-      }
-      const aTokenData = await sodax.moneyMarket.data.getATokenData(aToken);
-      return {
-        ...aTokenData,
-        chainKey: sodax.hubProvider.chainConfig.chain.key
-      };
-    },
-    enabled: !!aToken && viem.isAddress(aToken ?? ""),
-    ...queryOptions
-  });
-}
-function useATokensBalances({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const aTokens = params?.aTokens ?? [];
-  const spokeChainKey = params?.spokeChainKey;
-  const userAddress = params?.userAddress;
-  return reactQuery.useQuery({
-    queryKey: ["mm", "aTokensBalances", aTokens, spokeChainKey, userAddress],
-    queryFn: async () => {
-      if (aTokens.length === 0) {
-        return /* @__PURE__ */ new Map();
-      }
-      if (!spokeChainKey || !userAddress) {
-        throw new Error("spokeChainKey and userAddress are required");
-      }
-      for (const aToken of aTokens) {
-        if (!viem.isAddress(aToken)) {
-          throw new Error(`Invalid aToken address: ${aToken}`);
-        }
-      }
-      const hubWalletAddress = await sodax.hubProvider.getUserHubWalletAddress(userAddress, spokeChainKey);
-      return sodax.moneyMarket.data.getATokensBalances(aTokens, hubWalletAddress);
-    },
-    enabled: aTokens.length > 0 && !!spokeChainKey && !!userAddress,
-    ...queryOptions
-  });
-}
-function useReservesUsdFormat({
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["mm", "reservesUsdFormat"],
-    queryFn: async () => {
-      const reserves = await sodax.moneyMarket.data.getReservesHumanized();
-      return sodax.moneyMarket.data.formatReservesUSD(sodax.moneyMarket.data.buildReserveDataWithPrice(reserves));
-    },
-    ...queryOptions
-  });
-}
-function useUserFormattedSummary({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const spokeChainKey = params?.spokeChainKey;
-  const userAddress = params?.userAddress;
-  return reactQuery.useQuery({
-    queryKey: ["mm", "userFormattedSummary", spokeChainKey, userAddress],
-    queryFn: async () => {
-      if (!spokeChainKey || !userAddress) {
-        throw new Error("spokeChainKey and userAddress are required");
-      }
-      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)
-      );
-      return sodax.moneyMarket.data.formatUserSummary(
-        sodax.moneyMarket.data.buildUserSummaryRequest(reserves, formattedReserves, userReserves)
-      );
-    },
-    enabled: !!spokeChainKey && !!userAddress,
-    refetchInterval: 5e3,
-    ...queryOptions
-  });
-}
-var useQuote = ({
-  params,
-  queryOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  const payload = params?.payload;
-  return reactQuery.useQuery({
-    queryKey: ["swap", "quote", payload && { ...payload, amount: payload.amount.toString() }],
-    queryFn: async () => {
-      if (!payload) {
-        return void 0;
-      }
-      return sodax.swaps.getQuote(payload);
-    },
-    enabled: !!payload,
-    refetchInterval: 3e3,
-    ...queryOptions
-  });
-};
-function useSwap({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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 = ({
-  params,
-  queryOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  const intentTxHash = params?.intentTxHash;
-  return reactQuery.useQuery({
-    queryKey: ["swap", "status", intentTxHash],
-    queryFn: async () => {
-      if (!intentTxHash) return void 0;
-      return sodax.swaps.getStatus({ intent_tx_hash: intentTxHash });
-    },
-    enabled: !!intentTxHash,
-    refetchInterval: 3e3,
-    ...queryOptions
-  });
-};
-function useSwapAllowance({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const payload = params?.payload;
-  const srcChainKey = params?.srcChainKey;
-  const walletProvider = params?.walletProvider;
-  return reactQuery.useQuery({
-    // 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 (!srcChainKey || !walletProvider || !payload) {
-        return false;
-      }
-      const allowance = await sodax.swaps.isAllowanceValid({
-        params: payload,
-        raw: false,
-        walletProvider
-      });
-      return allowance.ok ? allowance.value : false;
-    },
-    enabled: !!srcChainKey && !!walletProvider && !!payload,
-    refetchInterval: 2e3,
-    ...queryOptions
-  });
-}
-function useSwapApprove({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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);
-    }
-  });
-}
-
-// src/hooks/swap/useCancelSwap.ts
-function useCancelSwap({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  return useSafeMutation({
-    mutationKey: ["swap", "cancel"],
-    ...mutationOptions,
-    mutationFn: async ({ srcChainKey, walletProvider, intent }) => unwrapResult(await sodax.swaps.cancelIntent({ params: { srcChainKey, intent }, walletProvider }))
-  });
-}
-
-// src/hooks/swap/useCreateLimitOrder.ts
-function useCreateLimitOrder({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  return useSafeMutation({
-    mutationKey: ["swap", "limitOrder", "create"],
-    ...mutationOptions,
-    mutationFn: async (vars) => unwrapResult(await sodax.swaps.createLimitOrder({ ...vars, raw: false }))
-  });
-}
-
-// src/hooks/swap/useCancelLimitOrder.ts
-function useCancelLimitOrder({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  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,
-  queryOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  const txHash = params?.txHash;
-  return reactQuery.useQuery({
-    queryKey: ["backend", "intent", "txHash", txHash],
-    queryFn: async () => {
-      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,
-  queryOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  const intentHash = params?.intentHash;
-  return reactQuery.useQuery({
-    queryKey: ["backend", "intent", "hash", intentHash],
-    queryFn: async () => {
-      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 userAddress = params?.userAddress;
-  const startDate = params?.startDate;
-  const endDate = params?.endDate;
-  return reactQuery.useQuery({
-    queryKey: ["backend", "intent", "user", userAddress, startDate, endDate],
-    queryFn: async () => {
-      if (!userAddress) return void 0;
-      return unwrapResult(await sodax.backendApi.getUserIntents({ userAddress, startDate, endDate }));
-    },
-    enabled: !!userAddress && userAddress.length > 0,
-    retry: 3,
-    ...queryOptions
-  });
-};
-
-// src/hooks/backend/useBackendSubmitSwapTx.ts
-var useBackendSubmitSwapTx = ({
-  mutationOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  return useSafeMutation({
-    mutationKey: ["backend", "submitSwapTx"],
-    retry: 3,
-    ...mutationOptions,
-    mutationFn: async ({ request, apiConfig }) => unwrapResult(await sodax.backendApi.submitSwapTx(request, apiConfig))
-  });
-};
-var useBackendSubmitSwapTxStatus = ({
-  params,
-  queryOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  const txHash = params?.txHash;
-  const srcChainKey = params?.srcChainKey;
-  const apiConfig = params?.apiConfig;
-  return reactQuery.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;
-    },
-    ...queryOptions
-  });
-};
-var useBackendOrderbook = ({
-  params,
-  queryOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  const pagination = params?.pagination;
-  return reactQuery.useQuery({
-    queryKey: ["backend", "orderbook", pagination?.offset, pagination?.limit],
-    queryFn: async () => {
-      if (!pagination?.offset || !pagination?.limit) {
-        throw new Error("Pagination offset and limit are required");
-      }
-      return unwrapResult(await sodax.backendApi.getOrderbook(pagination));
-    },
-    enabled: !!pagination?.offset && !!pagination?.limit,
-    staleTime: 30 * 1e3,
-    retry: 3,
-    ...queryOptions
-  });
-};
-var useBackendMoneyMarketPosition = ({
-  params,
-  queryOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  const userAddress = params?.userAddress;
-  return reactQuery.useQuery({
-    queryKey: ["backend", "mm", "position", userAddress],
-    queryFn: async () => {
-      if (!userAddress) return void 0;
-      return unwrapResult(await sodax.backendApi.getMoneyMarketPosition(userAddress));
-    },
-    enabled: !!userAddress && userAddress.length > 0,
-    retry: 3,
-    ...queryOptions
-  });
-};
-var useBackendAllMoneyMarketAssets = ({
-  queryOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["backend", "mm", "assets", "all"],
-    queryFn: async () => {
-      return unwrapResult(await sodax.backendApi.getAllMoneyMarketAssets());
-    },
-    retry: 3,
-    ...queryOptions
-  });
-};
-var useBackendMoneyMarketAsset = ({
-  params,
-  queryOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  const reserveAddress = params?.reserveAddress;
-  return reactQuery.useQuery({
-    queryKey: ["backend", "mm", "asset", reserveAddress],
-    queryFn: async () => {
-      if (!reserveAddress) return void 0;
-      return unwrapResult(await sodax.backendApi.getMoneyMarketAsset(reserveAddress));
-    },
-    enabled: !!reserveAddress && reserveAddress.length > 0,
-    retry: 3,
-    ...queryOptions
-  });
-};
-var useBackendMoneyMarketAssetBorrowers = ({
-  params,
-  queryOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  const reserveAddress = params?.reserveAddress;
-  const pagination = params?.pagination;
-  return reactQuery.useQuery({
-    queryKey: ["backend", "mm", "asset", "borrowers", reserveAddress, pagination],
-    queryFn: async () => {
-      if (!reserveAddress || !pagination?.offset || !pagination?.limit) {
-        return void 0;
-      }
-      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,
-  queryOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  const reserveAddress = params?.reserveAddress;
-  const pagination = params?.pagination;
-  return reactQuery.useQuery({
-    queryKey: ["backend", "mm", "asset", "suppliers", reserveAddress, pagination],
-    queryFn: async () => {
-      if (!reserveAddress || !pagination?.offset || !pagination?.limit) {
-        return void 0;
-      }
-      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,
-  queryOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  const pagination = params?.pagination;
-  return reactQuery.useQuery({
-    queryKey: ["backend", "mm", "borrowers", "all", pagination],
-    queryFn: async () => {
-      if (!pagination?.offset || !pagination?.limit) {
-        return void 0;
-      }
-      return unwrapResult(
-        await sodax.backendApi.getAllMoneyMarketBorrowers({
-          offset: pagination.offset,
-          limit: pagination.limit
-        })
-      );
-    },
-    enabled: !!pagination?.offset && !!pagination?.limit,
-    retry: 3,
-    ...queryOptions
-  });
-};
-function useBridge({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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 reactQuery.useQuery({
-    // 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 (!payload || !walletProvider) {
-        return false;
-      }
-      const result = await sodax.bridge.isAllowanceValid({
-        params: payload,
-        raw: false,
-        walletProvider
-      });
-      return result.ok ? result.value : false;
-    },
-    enabled: !!payload && !!walletProvider,
-    refetchInterval: 2e3,
-    gcTime: 0,
-    ...queryOptions
-  });
-}
-function useBridgeApprove({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const from = params?.from;
-  const to = params?.to;
-  return reactQuery.useQuery({
-    queryKey: ["bridge", "bridgeableAmount", from, to],
-    queryFn: async () => {
-      if (!from || !to) {
-        throw new Error("from and to tokens are required");
-      }
-      const result = await sodax.bridge.getBridgeableAmount(from, to);
-      if (!result.ok) {
-        throw result.error;
-      }
-      return result.value;
-    },
-    enabled: !!from && !!to,
-    ...queryOptions
-  });
-}
-function useGetBridgeableTokens({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const from = params?.from;
-  const to = params?.to;
-  const token = params?.token;
-  return reactQuery.useQuery({
-    queryKey: ["bridge", "bridgeableTokens", from, to, token],
-    queryFn: () => {
-      if (!from || !to || !token) {
-        throw new Error("from, to and token are required");
-      }
-      const result = sodax.bridge.getBridgeableTokens(from, to, token);
-      if (!result.ok) {
-        throw result.error;
-      }
-      return result.value;
-    },
-    enabled: !!from && !!to && !!token,
-    ...queryOptions
-  });
-}
-function useStake({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  return useSafeMutation({
-    mutationKey: ["staking", "approve", "stake"],
-    ...mutationOptions,
-    mutationFn: async ({ params, walletProvider }) => unwrapResult(
-      await sodax.staking.approve({
-        params: { ...params, action: "stake" },
-        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,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const payload = params?.payload;
-  return reactQuery.useQuery({
-    queryKey: ["staking", "allowance", payload?.srcChainKey, "stake", payload?.srcAddress, payload?.amount?.toString()],
-    queryFn: async () => {
-      if (!payload) {
-        throw new Error("Params are required");
-      }
-      const result = await sodax.staking.isAllowanceValid({
-        params: { ...payload, action: "stake" },
-        raw: true
-      });
-      if (!result.ok) throw result.error;
-      return result.value;
-    },
-    enabled: !!payload,
-    refetchInterval: 5e3,
-    gcTime: 0,
-    ...queryOptions
-  });
-}
-function useUnstake({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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({ params, queryOptions } = {}) {
-  const { sodax } = useSodaxContext();
-  const srcAddress = params?.srcAddress;
-  const srcChainKey = params?.srcChainKey;
-  return reactQuery.useQuery({
-    queryKey: ["staking", "info", srcChainKey, srcAddress],
-    queryFn: async () => {
-      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: !!srcAddress && !!srcChainKey,
-    refetchInterval: 5e3,
-    ...queryOptions
-  });
-}
-function useUnstakingInfoWithPenalty({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const srcAddress = params?.srcAddress;
-  const srcChainKey = params?.srcChainKey;
-  return reactQuery.useQuery({
-    queryKey: ["staking", "unstakingInfoWithPenalty", srcChainKey, srcAddress],
-    queryFn: async () => {
-      if (!srcAddress || !srcChainKey) {
-        throw new Error("srcAddress and srcChainKey are required");
-      }
-      const result = await sodax.staking.getUnstakingInfoWithPenalty(srcAddress, srcChainKey);
-      if (!result.ok) throw result.error;
-      return result.value;
-    },
-    enabled: !!srcAddress && !!srcChainKey,
-    refetchInterval: 5e3,
-    ...queryOptions
-  });
-}
-function useStakingConfig({
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["staking", "config"],
-    queryFn: async () => {
-      const result = await sodax.staking.getStakingConfig();
-      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 reactQuery.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;
-    },
-    enabled: amount !== void 0,
-    refetchInterval: 1e4,
-    ...queryOptions
-  });
-}
-function useInstantUnstakeRatio({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const amount = params?.amount;
-  return reactQuery.useQuery({
-    queryKey: ["staking", "instantUnstakeRatio", amount?.toString()],
-    queryFn: async () => {
-      if (amount === void 0) {
-        throw new Error("amount is required");
-      }
-      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 reactQuery.useQuery({
-    queryKey: ["staking", "convertedAssets", amount?.toString()],
-    queryFn: async () => {
-      if (amount === void 0) {
-        throw new Error("amount is required");
-      }
-      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 = reactQuery.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 reactQuery.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: !!payload,
-    refetchInterval: 5e3,
-    gcTime: 0,
-    ...queryOptions
-  });
-}
-function useUnstakeApprove({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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 reactQuery.useQuery({
-    queryKey: ["staking", "unstakingInfo", srcChainKey, srcAddress],
-    queryFn: async () => {
-      if (!srcAddress || !srcChainKey) {
-        throw new Error("srcAddress and srcChainKey are required");
-      }
-      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 = reactQuery.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 reactQuery.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.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 reactQuery.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: !!queryAddress,
-    ...queryOptions
-  });
-}
-function useGetAutoSwapPreferences({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryAddress = params?.queryAddress;
-  return reactQuery.useQuery({
-    queryKey: ["partner", "feeClaim", "autoSwapPreferences", queryAddress],
-    queryFn: async () => {
-      if (!queryAddress) {
-        throw new Error("queryAddress is required");
-      }
-      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 reactQuery.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: !!payload,
-    refetchInterval: 5e3,
-    gcTime: 0,
-    ...queryOptions
-  });
-}
-function useApproveToken({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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 useSetSwapPreference({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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]
-      });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function useFeeClaimSwap({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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]
-      });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function useHubAssetBalances({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const chainKey = params?.chainKey;
-  const srcAddress = params?.srcAddress;
-  return reactQuery.useQuery({
-    queryKey: ["recovery", "hubAssetBalances", chainKey, srcAddress],
-    queryFn: async () => {
-      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: !!chainKey && !!srcAddress,
-    staleTime: 1e4,
-    ...queryOptions
-  });
-}
-function useWithdrawHubAsset({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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]
-      });
-      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", params.srcChainKey] });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function useMigrateIcxToSoda({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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", sdk.ChainKeys.SONIC_MAINNET] });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function useRevertMigrateSodaToIcx({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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", sdk.ChainKeys.ICON_MAINNET] });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function useMigratebnUSD({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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 useMigrateBaln({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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", sdk.ChainKeys.ICON_MAINNET] });
-      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", sdk.ChainKeys.SONIC_MAINNET] });
-      queryClient.invalidateQueries({ queryKey: ["staking", "info"] });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function useMigrationApprove({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.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 reactQuery.useQuery({
-    // 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 () => {
-      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 usePools({ queryOptions } = {}) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    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 reactQuery.useQuery({
-    queryKey: ["dex", "poolData", poolKey],
-    queryFn: async () => {
-      if (!poolKey) {
-        throw new Error("Pool key is required");
-      }
-      const result = await sodax.dex.clService.getPoolData(poolKey, sodax.hubProvider.publicClient);
-      if (!result.ok) throw result.error;
-      return result.value;
-    },
-    enabled: poolKey !== null,
-    staleTime: 1e4,
-    refetchInterval: 3e4,
-    ...queryOptions
-  });
-}
-function usePoolBalances({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const poolData = params?.poolData ?? null;
-  const poolKey = params?.poolKey ?? null;
-  const spokeChainKey = params?.spokeChainKey;
-  const userAddress = params?.userAddress;
-  return reactQuery.useQuery({
-    queryKey: ["dex", "poolBalances", poolData?.poolId, spokeChainKey, userAddress],
-    queryFn: async () => {
-      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: viem.erc20Abi,
-          functionName: "balanceOf",
-          args: [hubWallet]
-        }),
-        sodax.hubProvider.publicClient.readContract({
-          address: poolData.token1.address,
-          abi: viem.erc20Abi,
-          functionName: "balanceOf",
-          args: [hubWallet]
-        })
-      ]);
-      return { token0Balance, token1Balance };
-    },
-    enabled: !!poolData && !!poolKey && !!spokeChainKey && !!userAddress,
-    staleTime: 5e3,
-    refetchInterval: 1e4,
-    ...queryOptions
-  });
-}
-function usePositionInfo({
-  params,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const tokenId = params?.tokenId ?? null;
-  const poolKey = params?.poolKey ?? null;
-  return reactQuery.useQuery({
-    queryKey: ["dex", "positionInfo", tokenId, poolKey],
-    queryFn: async () => {
-      if (!tokenId || !poolKey) {
-        throw new Error("Token ID and pool key are required");
-      }
-      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 };
-    },
-    enabled: tokenId !== null && tokenId !== "" && poolKey !== null,
-    staleTime: 1e4,
-    ...queryOptions
-  });
-}
-function useDexDeposit({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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()]
-      });
-      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", params.srcChainKey] });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function useDexWithdraw({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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,
-  queryOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const payload = params?.payload;
-  return reactQuery.useQuery({
-    queryKey: ["dex", "allowance", payload?.srcChainKey, payload?.asset, payload?.amount?.toString()],
-    queryFn: async () => {
-      if (!payload) {
-        throw new Error("Params are required");
-      }
-      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({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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()]
-      });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function useLiquidityAmounts(minPrice, maxPrice, poolData) {
-  const [liquidityToken0Amount, setLiquidityToken0Amount] = react.useState("");
-  const [liquidityToken1Amount, setLiquidityToken1Amount] = react.useState("");
-  const [lastEditedToken, setLastEditedToken] = react.useState(null);
-  const { minPriceNum, maxPriceNum, isValidPriceRange } = react.useMemo(() => {
-    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 };
-  }, [minPrice, maxPrice]);
-  const { tickLower, tickUpper, currentTick } = react.useMemo(() => {
-    if (!poolData || !isValidPriceRange) {
-      return { tickLower: null, tickUpper: null, currentTick: null };
-    }
-    try {
-      const lower = sdk.ClService.priceToTick(minPriceNum, poolData.token0, poolData.token1, poolData.tickSpacing);
-      const upper = sdk.ClService.priceToTick(maxPriceNum, poolData.token0, poolData.token1, poolData.tickSpacing);
-      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 };
-    }
-  }, [minPriceNum, maxPriceNum, poolData, isValidPriceRange]);
-  const handleToken0AmountChange = react.useCallback(
-    (value) => {
-      setLiquidityToken0Amount(value);
-      setLastEditedToken("token0");
-      if (!value || !poolData || !tickLower || !tickUpper || !currentTick) return;
-      const amount0 = Number.parseFloat(value);
-      if (amount0 <= 0 || !isValidPriceRange) return;
-      try {
-        const amount0BigInt = BigInt(Math.floor(amount0 * 10 ** poolData.token0.decimals));
-        const amount1BigInt = sdk.ClService.calculateAmount1FromAmount0(
-          amount0BigInt,
-          tickLower,
-          tickUpper,
-          currentTick,
-          poolData.sqrtPriceX96
-        );
-        const amount1 = Number(amount1BigInt) / 10 ** poolData.token1.decimals;
-        setLiquidityToken1Amount(amount1.toFixed(6));
-      } catch (err) {
-        console.error("Failed to calculate token1 amount:", err);
-      }
-    },
-    [poolData, tickLower, tickUpper, currentTick, isValidPriceRange]
-  );
-  const handleToken1AmountChange = react.useCallback(
-    (value) => {
-      setLiquidityToken1Amount(value);
-      setLastEditedToken("token1");
-      if (!value || !poolData || !tickLower || !tickUpper || !currentTick) return;
-      const amount1 = Number.parseFloat(value);
-      if (amount1 <= 0 || !isValidPriceRange) return;
-      try {
-        const amount1BigInt = BigInt(Math.floor(amount1 * 10 ** poolData.token1.decimals));
-        const amount0BigInt = sdk.ClService.calculateAmount0FromAmount1(
-          amount1BigInt,
-          tickLower,
-          tickUpper,
-          currentTick,
-          poolData.sqrtPriceX96
-        );
-        const amount0 = Number(amount0BigInt) / 10 ** poolData.token0.decimals;
-        setLiquidityToken0Amount(amount0.toFixed(6));
-      } catch (err) {
-        console.error("Failed to calculate token0 amount:", err);
-      }
-    },
-    [poolData, tickLower, tickUpper, currentTick, isValidPriceRange]
-  );
-  react.useEffect(() => {
-    if (!poolData || !tickLower || !tickUpper || !lastEditedToken || !isValidPriceRange) return;
-    if (lastEditedToken === "token0" && liquidityToken0Amount) {
-      handleToken0AmountChange(liquidityToken0Amount);
-    } else if (lastEditedToken === "token1" && liquidityToken1Amount) {
-      handleToken1AmountChange(liquidityToken1Amount);
-    }
-  }, [
-    poolData,
-    lastEditedToken,
-    liquidityToken0Amount,
-    liquidityToken1Amount,
-    handleToken0AmountChange,
-    handleToken1AmountChange,
-    tickLower,
-    tickUpper,
-    isValidPriceRange
-  ]);
-  return {
-    liquidityToken0Amount,
-    liquidityToken1Amount,
-    lastEditedToken,
-    setLiquidityToken0Amount,
-    setLiquidityToken1Amount,
-    handleToken0AmountChange,
-    handleToken1AmountChange
-  };
-}
-function useSupplyLiquidity({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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 unwrapResult(
-        await sodax.dex.clService.supplyLiquidity({ params: sharedParams, raw: false, walletProvider, timeout })
-      );
-    },
-    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({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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]
-      });
-      queryClient.invalidateQueries({ queryKey: ["dex", "poolData", params.poolKey] });
-      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances", params.srcChainKey, params.srcAddress] });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-function createDecreaseLiquidityParamsProps({
-  poolKey,
-  tokenId,
-  percentage,
-  positionInfo,
-  slippageTolerance
-}) {
-  const percentageNum = Number.parseFloat(String(percentage));
-  const slippage = Number.parseFloat(String(slippageTolerance));
-  if (percentageNum <= 0 || percentageNum > 100) {
-    throw new Error("Percentage must be between 0 and 100");
-  }
-  if (slippage <= 0 || slippage > 100) {
-    throw new Error("Slippage must be between 0 and 100");
-  }
-  const liquidityToRemove = percentageNum === 100 ? positionInfo.liquidity : positionInfo.liquidity * BigInt(Math.floor(percentageNum * 100)) / 10000n;
-  const expectedAmount0 = percentageNum === 100 ? positionInfo.amount0 : positionInfo.amount0 * BigInt(Math.floor(percentageNum * 100)) / 10000n;
-  const expectedAmount1 = percentageNum === 100 ? positionInfo.amount1 : positionInfo.amount1 * BigInt(Math.floor(percentageNum * 100)) / 10000n;
-  const slippageMultiplier = BigInt(Math.floor((100 - slippage) * 100));
-  const amount0Min = expectedAmount0 * slippageMultiplier / 10000n;
-  const amount1Min = expectedAmount1 * slippageMultiplier / 10000n;
-  return {
-    poolKey,
-    tokenId: BigInt(tokenId),
-    liquidity: liquidityToRemove,
-    amount0Min,
-    amount1Min
-  };
-}
-function createDepositParamsProps({
-  tokenIndex,
-  amount,
-  poolData,
-  poolSpokeAssets
-}) {
-  const amountNum = Number.parseFloat(String(amount));
-  if (!amount || amountNum <= 0) {
-    throw new Error("Amount must be greater than 0");
-  }
-  const token = tokenIndex === 0 ? poolData.token0 : poolData.token1;
-  const originalAsset = tokenIndex === 0 ? poolSpokeAssets.token0 : poolSpokeAssets.token1;
-  return {
-    asset: originalAsset.address,
-    // Use deposit token decimals (original asset) for correct unit parsing
-    amount: viem.parseUnits(String(amount), originalAsset.decimals),
-    poolToken: token.address
-  };
-}
-function createSupplyLiquidityParamsProps({
-  poolData,
-  poolKey,
-  minPrice,
-  maxPrice,
-  liquidityToken0Amount,
-  liquidityToken1Amount,
-  slippageTolerance,
-  positionId,
-  isValidPosition
-}) {
-  const slippage = Number.parseFloat(String(slippageTolerance));
-  if (slippage <= 0 || slippage > 100) {
-    throw new Error("Slippage must be between 0 and 100");
-  }
-  const minPriceNum = Number.parseFloat(minPrice);
-  const maxPriceNum = Number.parseFloat(maxPrice);
-  const amount0 = Number.parseFloat(liquidityToken0Amount);
-  const amount1 = Number.parseFloat(liquidityToken1Amount);
-  if (minPriceNum <= 0 || maxPriceNum <= 0 || amount0 <= 0 || amount1 <= 0) {
-    throw new Error("All values must be greater than 0");
-  }
-  if (minPriceNum >= maxPriceNum) {
-    throw new Error("Min price must be less than max price");
-  }
-  const amount0BigInt = viem.parseUnits(liquidityToken0Amount, poolData.token0.decimals);
-  const amount1BigInt = viem.parseUnits(liquidityToken1Amount, poolData.token1.decimals);
-  const token0 = poolData.token0;
-  const token1 = poolData.token1;
-  const tickSpacing = poolData.tickSpacing;
-  const tickLower = sdk.ClService.priceToTick(minPriceNum, token0, token1, tickSpacing);
-  const tickUpper = sdk.ClService.priceToTick(maxPriceNum, token0, token1, tickSpacing);
-  const liquidity = sdk.ClService.calculateLiquidityFromAmounts(
-    amount0BigInt,
-    amount1BigInt,
-    tickLower,
-    tickUpper,
-    BigInt(poolData.currentTick)
-  );
-  const { amount0Max, amount1Max } = sdk.ClService.calculateMaxAmountsForSlippage(
-    liquidity,
-    tickLower,
-    tickUpper,
-    BigInt(poolData.currentTick),
-    poolData.sqrtPriceX96,
-    slippage
-  );
-  const tokenId = positionId ? BigInt(positionId) : void 0;
-  return {
-    poolKey,
-    tickLower,
-    tickUpper,
-    liquidity,
-    amount0Max,
-    amount1Max,
-    sqrtPriceX96: poolData.sqrtPriceX96,
-    positionId,
-    isValidPosition,
-    tokenId
-  };
-}
-function createWithdrawParamsProps({
-  tokenIndex,
-  amount,
-  poolData,
-  poolSpokeAssets,
-  dst
-}) {
-  const amountNum = Number.parseFloat(String(amount));
-  if (!amount || amountNum <= 0) {
-    throw new Error("Please enter a valid amount");
-  }
-  const token = tokenIndex === 0 ? poolData.token0 : poolData.token1;
-  const originalAsset = tokenIndex === 0 ? poolSpokeAssets.token0 : poolSpokeAssets.token1;
-  return {
-    asset: originalAsset.address,
-    amount: viem.parseUnits(String(amount), token.decimals),
-    poolToken: token.address,
-    dst
-  };
-}
-
-// src/hooks/dex/useCreateDepositParams.ts
-function useCreateDepositParams({
-  tokenIndex,
-  amount,
-  poolData,
-  poolSpokeAssets
-}) {
-  return react.useMemo(() => {
-    if (!amount || Number.parseFloat(String(amount)) <= 0) {
-      return void 0;
-    }
-    return createDepositParamsProps({ tokenIndex, amount, poolData, poolSpokeAssets });
-  }, [tokenIndex, amount, poolData, poolSpokeAssets]);
-}
-function useCreateSupplyLiquidityParams({
-  poolData,
-  poolKey,
-  minPrice,
-  maxPrice,
-  liquidityToken0Amount,
-  liquidityToken1Amount,
-  slippageTolerance,
-  positionId,
-  isValidPosition
-}) {
-  return react.useMemo(() => {
-    return createSupplyLiquidityParamsProps({
-      poolData,
-      poolKey,
-      minPrice,
-      maxPrice,
-      liquidityToken0Amount,
-      liquidityToken1Amount,
-      slippageTolerance,
-      positionId,
-      isValidPosition
-    });
-  }, [
-    minPrice,
-    maxPrice,
-    liquidityToken0Amount,
-    liquidityToken1Amount,
-    slippageTolerance,
-    poolData,
-    poolKey,
-    positionId,
-    isValidPosition
-  ]);
-}
-function useCreateDecreaseLiquidityParams({
-  poolKey,
-  tokenId,
-  percentage,
-  positionInfo,
-  slippageTolerance
-}) {
-  return react.useMemo(() => {
-    return createDecreaseLiquidityParamsProps({ poolKey, tokenId, percentage, positionInfo, slippageTolerance });
-  }, [poolKey, tokenId, percentage, positionInfo, slippageTolerance]);
-}
-function useCreateWithdrawParams({
-  tokenIndex,
-  amount,
-  poolData,
-  poolSpokeAssets,
-  dst
-}) {
-  return react.useMemo(() => {
-    if (!amount || Number.parseFloat(String(amount)) <= 0) {
-      return void 0;
-    }
-    return createWithdrawParamsProps({ tokenIndex, amount, poolData, poolSpokeAssets, dst });
-  }, [tokenIndex, amount, poolData, poolSpokeAssets, dst]);
-}
-function useClaimRewards({
-  mutationOptions
-} = {}) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  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", "positionInfo", params.tokenId.toString(), params.poolKey]
-      });
-      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances", params.srcChainKey, params.srcAddress] });
-      await mutationOptions?.onSuccess?.(data, vars, ctx);
-    }
-  });
-}
-var SodaxProvider = ({ children, config }) => {
-  const configRef = react.useRef(config);
-  const frozen = configRef.current;
-  const sodax = react.useMemo(() => new sdk.Sodax(frozen), [frozen]);
-  return /* @__PURE__ */ jsxRuntime.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 reactQuery.QueryClient(config);
-  }
-  return new reactQuery.QueryClient({
-    ...config,
-    mutationCache: new reactQuery.MutationCache({
-      onError: (error, _vars, _ctx, mutation) => {
-        if (mutation.options.meta?.silent === true) return;
-        onMutationError(error);
-      }
-    })
-  });
-}
-
-exports.SodaxProvider = SodaxProvider;
-exports.clearRadfiSession = clearRadfiSession;
-exports.createDecreaseLiquidityParamsProps = createDecreaseLiquidityParamsProps;
-exports.createDepositParamsProps = createDepositParamsProps;
-exports.createSodaxQueryClient = createSodaxQueryClient;
-exports.createSupplyLiquidityParamsProps = createSupplyLiquidityParamsProps;
-exports.createWithdrawParamsProps = createWithdrawParamsProps;
-exports.getXBalancesQueryOptions = getXBalancesQueryOptions;
-exports.loadRadfiSession = loadRadfiSession;
-exports.saveRadfiSession = saveRadfiSession;
-exports.toResult = toResult;
-exports.unwrapResult = unwrapResult;
-exports.useAToken = useAToken;
-exports.useATokensBalances = useATokensBalances;
-exports.useApproveToken = useApproveToken;
-exports.useBackendAllMoneyMarketAssets = useBackendAllMoneyMarketAssets;
-exports.useBackendAllMoneyMarketBorrowers = useBackendAllMoneyMarketBorrowers;
-exports.useBackendIntentByHash = useBackendIntentByHash;
-exports.useBackendIntentByTxHash = useBackendIntentByTxHash;
-exports.useBackendMoneyMarketAsset = useBackendMoneyMarketAsset;
-exports.useBackendMoneyMarketAssetBorrowers = useBackendMoneyMarketAssetBorrowers;
-exports.useBackendMoneyMarketAssetSuppliers = useBackendMoneyMarketAssetSuppliers;
-exports.useBackendMoneyMarketPosition = useBackendMoneyMarketPosition;
-exports.useBackendOrderbook = useBackendOrderbook;
-exports.useBackendSubmitSwapTx = useBackendSubmitSwapTx;
-exports.useBackendSubmitSwapTxStatus = useBackendSubmitSwapTxStatus;
-exports.useBackendUserIntents = useBackendUserIntents;
-exports.useBitcoinBalance = useBitcoinBalance;
-exports.useBorrow = useBorrow;
-exports.useBridge = useBridge;
-exports.useBridgeAllowance = useBridgeAllowance;
-exports.useBridgeApprove = useBridgeApprove;
-exports.useCancelLimitOrder = useCancelLimitOrder;
-exports.useCancelSwap = useCancelSwap;
-exports.useCancelUnstake = useCancelUnstake;
-exports.useClaim = useClaim;
-exports.useClaimRewards = useClaimRewards;
-exports.useConvertedAssets = useConvertedAssets;
-exports.useCreateDecreaseLiquidityParams = useCreateDecreaseLiquidityParams;
-exports.useCreateDepositParams = useCreateDepositParams;
-exports.useCreateLimitOrder = useCreateLimitOrder;
-exports.useCreateSupplyLiquidityParams = useCreateSupplyLiquidityParams;
-exports.useCreateWithdrawParams = useCreateWithdrawParams;
-exports.useDecreaseLiquidity = useDecreaseLiquidity;
-exports.useDeriveUserWalletAddress = useDeriveUserWalletAddress;
-exports.useDexAllowance = useDexAllowance;
-exports.useDexApprove = useDexApprove;
-exports.useDexDeposit = useDexDeposit;
-exports.useDexWithdraw = useDexWithdraw;
-exports.useEstimateGas = useEstimateGas;
-exports.useExpiredUtxos = useExpiredUtxos;
-exports.useFeeClaimSwap = useFeeClaimSwap;
-exports.useFetchAssetsBalances = useFetchAssetsBalances;
-exports.useFundTradingWallet = useFundTradingWallet;
-exports.useGetAutoSwapPreferences = useGetAutoSwapPreferences;
-exports.useGetBridgeableAmount = useGetBridgeableAmount;
-exports.useGetBridgeableTokens = useGetBridgeableTokens;
-exports.useGetUserHubWalletAddress = useGetUserHubWalletAddress;
-exports.useHubAssetBalances = useHubAssetBalances;
-exports.useHubProvider = useHubProvider;
-exports.useInstantUnstake = useInstantUnstake;
-exports.useInstantUnstakeAllowance = useInstantUnstakeAllowance;
-exports.useInstantUnstakeApprove = useInstantUnstakeApprove;
-exports.useInstantUnstakeRatio = useInstantUnstakeRatio;
-exports.useIsTokenApproved = useIsTokenApproved;
-exports.useLiquidityAmounts = useLiquidityAmounts;
-exports.useMMAllowance = useMMAllowance;
-exports.useMMApprove = useMMApprove;
-exports.useMigrateBaln = useMigrateBaln;
-exports.useMigrateIcxToSoda = useMigrateIcxToSoda;
-exports.useMigratebnUSD = useMigratebnUSD;
-exports.useMigrationAllowance = useMigrationAllowance;
-exports.useMigrationApprove = useMigrationApprove;
-exports.usePoolBalances = usePoolBalances;
-exports.usePoolData = usePoolData;
-exports.usePools = usePools;
-exports.usePositionInfo = usePositionInfo;
-exports.useQuote = useQuote;
-exports.useRadfiAuth = useRadfiAuth;
-exports.useRadfiSession = useRadfiSession;
-exports.useRadfiWithdraw = useRadfiWithdraw;
-exports.useRenewUtxos = useRenewUtxos;
-exports.useRepay = useRepay;
-exports.useRequestTrustline = useRequestTrustline;
-exports.useReservesData = useReservesData;
-exports.useReservesHumanized = useReservesHumanized;
-exports.useReservesList = useReservesList;
-exports.useReservesUsdFormat = useReservesUsdFormat;
-exports.useRevertMigrateSodaToIcx = useRevertMigrateSodaToIcx;
-exports.useSafeMutation = useSafeMutation;
-exports.useSetSwapPreference = useSetSwapPreference;
-exports.useSodaxContext = useSodaxContext;
-exports.useStake = useStake;
-exports.useStakeAllowance = useStakeAllowance;
-exports.useStakeApprove = useStakeApprove;
-exports.useStakeRatio = useStakeRatio;
-exports.useStakingConfig = useStakingConfig;
-exports.useStakingInfo = useStakingInfo;
-exports.useStatus = useStatus;
-exports.useStellarTrustlineCheck = useStellarTrustlineCheck;
-exports.useSupply = useSupply;
-exports.useSupplyLiquidity = useSupplyLiquidity;
-exports.useSwap = useSwap;
-exports.useSwapAllowance = useSwapAllowance;
-exports.useSwapApprove = useSwapApprove;
-exports.useTradingWallet = useTradingWallet;
-exports.useTradingWalletBalance = useTradingWalletBalance;
-exports.useUnstake = useUnstake;
-exports.useUnstakeAllowance = useUnstakeAllowance;
-exports.useUnstakeApprove = useUnstakeApprove;
-exports.useUnstakingInfo = useUnstakingInfo;
-exports.useUnstakingInfoWithPenalty = useUnstakingInfoWithPenalty;
-exports.useUserFormattedSummary = useUserFormattedSummary;
-exports.useUserReservesData = useUserReservesData;
-exports.useWithdraw = useWithdraw;
-exports.useWithdrawHubAsset = useWithdrawHubAsset;
-exports.useXBalances = useXBalances;
-Object.keys(sdk).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return sdk[k]; }
-  });
-});
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map