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

package/dist/index.js

@@ -1,2562 +0,0 @@
-'use strict';
-
-var React = require('react');
-var sdk = require('@sodax/sdk');
-var reactQuery = require('@tanstack/react-query');
-var viem = require('viem');
-var types = require('@sodax/types');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var React__default = /*#__PURE__*/_interopDefault(React);
-
-// src/contexts/index.ts
-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;
-};
-function useEstimateGas(spokeProvider) {
-  return reactQuery.useMutation({
-    mutationFn: async (rawTx) => {
-      if (!spokeProvider) {
-        throw new Error("spokeProvider is not found");
-      }
-      const response = await sdk.SpokeService.estimateGas(rawTx, spokeProvider);
-      return response;
-    }
-  });
-}
-function useDeriveUserWalletAddress(spokeChainId, spokeAddress) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["deriveUserWalletAddress", spokeChainId, spokeAddress],
-    queryFn: async () => {
-      if (!spokeChainId || !spokeAddress) {
-        throw new Error("Spoke chain id and address are required");
-      }
-      spokeChainId = typeof spokeChainId === "object" ? spokeChainId.chainConfig.chain.id : spokeChainId;
-      return await sdk.deriveUserWalletAddress(sodax.hubProvider, spokeChainId, spokeAddress);
-    },
-    enabled: !!spokeChainId && !!spokeAddress,
-    refetchInterval: false
-    // This is a deterministic operation, no need to refetch
-  });
-}
-function useStellarTrustlineCheck(token, amount, spokeProvider, chainId) {
-  return reactQuery.useQuery({
-    queryKey: ["stellar-trustline-check", token],
-    queryFn: async () => {
-      if (chainId !== sdk.STELLAR_MAINNET_CHAIN_ID) {
-        return true;
-      }
-      if (!spokeProvider || !token || !amount || !(spokeProvider instanceof sdk.StellarSpokeProvider)) {
-        console.error(
-          "Spoke provider, token or amount not found. Details: spokeProvider:",
-          spokeProvider,
-          "token:",
-          token,
-          "amount:",
-          amount
-        );
-        return false;
-      }
-      const response = await sdk.StellarSpokeService.hasSufficientTrustline(token, amount, spokeProvider);
-      return response;
-    },
-    enabled: !!spokeProvider && !!token && !!amount
-  });
-}
-function useRequestTrustline(token) {
-  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,
-      spokeProvider
-    }) => {
-      if (!spokeProvider || !token2 || !amount || !(spokeProvider instanceof sdk.StellarSpokeProvider)) {
-        const error2 = new Error("Spoke provider, token or amount not found");
-        setError(error2);
-        throw error2;
-      }
-      setIsLoading(true);
-      setError(null);
-      try {
-        const result = await sdk.StellarSpokeService.requestTrustline(token2, amount, spokeProvider);
-        setData(result);
-        setIsRequested(true);
-        queryClient.invalidateQueries({ queryKey: ["stellar-trustline-check", token2] });
-        return result;
-      } catch (err) {
-        const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
-        setError(error2);
-        throw error2;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [queryClient]
-  );
-  return {
-    requestTrustline,
-    isLoading,
-    isRequested,
-    error,
-    data
-  };
-}
-function useGetUserHubWalletAddress(spokeChainId, spokeAddress) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["getUserHubWalletAddress", spokeChainId, spokeAddress],
-    queryFn: async () => {
-      if (!spokeChainId || !spokeAddress) {
-        throw new Error("Spoke chain id and address are required");
-      }
-      spokeChainId = typeof spokeChainId === "object" ? spokeChainId.chainConfig.chain.id : spokeChainId;
-      return await sdk.HubService.getUserHubWalletAddress(spokeAddress, spokeChainId, sodax.hubProvider);
-    },
-    enabled: !!spokeChainId && !!spokeAddress,
-    refetchInterval: false
-    // This is a deterministic operation, no need to refetch
-  });
-}
-
-// src/hooks/provider/useHubProvider.ts
-function useHubProvider() {
-  const { sodax } = useSodaxContext();
-  return sodax.hubProvider;
-}
-function useSpokeProvider(spokeChainId, walletProvider) {
-  const { rpcConfig } = useSodaxContext();
-  const xChainType = spokeChainId ? sdk.spokeChainConfig[spokeChainId]?.chain.type : void 0;
-  const spokeProvider = React.useMemo(() => {
-    if (!walletProvider) return void 0;
-    if (!spokeChainId) return void 0;
-    if (!xChainType) return void 0;
-    if (!rpcConfig) return void 0;
-    if (xChainType === "BITCOIN") {
-      const bitcoinConfig = sdk.spokeChainConfig[spokeChainId];
-      const btcRpcOverride = rpcConfig[spokeChainId];
-      return new sdk.BitcoinSpokeProvider(
-        walletProvider,
-        bitcoinConfig,
-        {
-          url: btcRpcOverride?.radfiApiUrl || bitcoinConfig.radfiApiUrl,
-          apiKey: bitcoinConfig.radfiApiKey,
-          umsUrl: btcRpcOverride?.radfiUmsUrl || bitcoinConfig.radfiUmsUrl
-        },
-        "TRADING",
-        btcRpcOverride?.rpcUrl || bitcoinConfig.rpcUrl
-      );
-    }
-    if (xChainType === "EVM") {
-      if (spokeChainId === sdk.SONIC_MAINNET_CHAIN_ID) {
-        return new sdk.SonicSpokeProvider(
-          walletProvider,
-          sdk.spokeChainConfig[spokeChainId]
-        );
-      }
-      const evmRpcUrl = rpcConfig[spokeChainId];
-      return new sdk.EvmSpokeProvider(
-        walletProvider,
-        sdk.spokeChainConfig[spokeChainId],
-        typeof evmRpcUrl === "string" ? evmRpcUrl : void 0
-      );
-    }
-    if (xChainType === "SUI") {
-      return new sdk.SuiSpokeProvider(
-        sdk.spokeChainConfig[spokeChainId],
-        walletProvider
-      );
-    }
-    if (xChainType === "ICON") {
-      return new sdk.IconSpokeProvider(
-        walletProvider,
-        sdk.spokeChainConfig[spokeChainId]
-      );
-    }
-    if (xChainType === "INJECTIVE") {
-      return new sdk.InjectiveSpokeProvider(
-        sdk.spokeChainConfig[spokeChainId],
-        walletProvider
-      );
-    }
-    if (xChainType === "STELLAR") {
-      const stellarConfig = sdk.spokeChainConfig[spokeChainId];
-      return new sdk.StellarSpokeProvider(
-        walletProvider,
-        stellarConfig,
-        rpcConfig.stellar ? rpcConfig.stellar : {
-          horizonRpcUrl: stellarConfig.horizonRpcUrl,
-          sorobanRpcUrl: stellarConfig.sorobanRpcUrl
-        }
-      );
-    }
-    if (xChainType === "SOLANA") {
-      return new sdk.SolanaSpokeProvider(
-        walletProvider,
-        rpcConfig.solana ? {
-          ...sdk.spokeChainConfig[spokeChainId],
-          rpcUrl: rpcConfig.solana
-        } : sdk.spokeChainConfig[spokeChainId]
-      );
-    }
-    if (xChainType === "NEAR") {
-      return new sdk.NearSpokeProvider(
-        walletProvider,
-        sdk.spokeChainConfig[spokeChainId]
-      );
-    }
-    if (xChainType === "STACKS") {
-      return new sdk.StacksSpokeProvider(
-        rpcConfig[spokeChainId] ? {
-          ...sdk.spokeChainConfig[spokeChainId],
-          rpcUrl: rpcConfig[spokeChainId]
-        } : sdk.spokeChainConfig[spokeChainId],
-        walletProvider
-      );
-    }
-    return void 0;
-  }, [spokeChainId, xChainType, walletProvider, rpcConfig]);
-  return spokeProvider;
-}
-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(spokeProvider) {
-  return reactQuery.useMutation({
-    mutationFn: async () => {
-      if (!spokeProvider) {
-        throw new Error("Bitcoin spoke provider not found");
-      }
-      const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
-      const existingSession = loadRadfiSession(walletAddress);
-      const cachedPublicKey = existingSession?.publicKey;
-      try {
-        const { accessToken, refreshToken, tradingAddress, publicKey } = await spokeProvider.authenticateWithWallet(cachedPublicKey);
-        const session = {
-          accessToken,
-          refreshToken,
-          tradingAddress,
-          publicKey
-        };
-        saveRadfiSession(walletAddress, session);
-        return { accessToken, refreshToken, tradingAddress };
-      } catch (err) {
-        const isAlreadyRegistered = err instanceof Error && (err.message.includes("duplicatedPubKey") || err.message.includes("4008"));
-        if (isAlreadyRegistered && existingSession?.refreshToken) {
-          try {
-            const refreshed = await spokeProvider.radfi.refreshAccessToken(existingSession.refreshToken);
-            const session = {
-              ...existingSession,
-              accessToken: refreshed.accessToken,
-              refreshToken: refreshed.refreshToken
-            };
-            spokeProvider.setRadfiAccessToken(refreshed.accessToken, refreshed.refreshToken);
-            saveRadfiSession(walletAddress, session);
-            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(spokeProvider) {
-  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 (!spokeProvider || isRefreshingRef.current) return;
-    isRefreshingRef.current = true;
-    try {
-      const session = loadRadfiSession(address);
-      if (!session?.refreshToken) {
-        setIsAuthed(false);
-        return;
-      }
-      const { accessToken, refreshToken } = await spokeProvider.radfi.refreshAccessToken(session.refreshToken);
-      const updated = {
-        ...session,
-        accessToken,
-        refreshToken
-      };
-      saveRadfiSession(address, updated);
-      spokeProvider.setRadfiAccessToken(accessToken, refreshToken);
-      setIsAuthed(true);
-      setTradingAddress(updated.tradingAddress || void 0);
-    } catch {
-      clearRadfiSession(address);
-      spokeProvider.setRadfiAccessToken("", "");
-      setIsAuthed(false);
-      setTradingAddress(void 0);
-    } finally {
-      isRefreshingRef.current = false;
-    }
-  }, [spokeProvider]);
-  React.useEffect(() => {
-    if (!spokeProvider) return;
-    setIsAuthed(false);
-    setTradingAddress(void 0);
-    setWalletAddress(void 0);
-    spokeProvider.walletProvider.getWalletAddress().then((addr) => {
-      setWalletAddress(addr);
-      const session = loadRadfiSession(addr);
-      if (!session?.refreshToken) return;
-      silentRefresh(addr);
-    }).catch(() => {
-    });
-  }, [spokeProvider, silentRefresh]);
-  React.useEffect(() => {
-    if (!walletAddress || !spokeProvider) return;
-    const id = setInterval(() => {
-      silentRefresh(walletAddress);
-    }, REFRESH_INTERVAL);
-    return () => clearInterval(id);
-  }, [walletAddress, spokeProvider, silentRefresh]);
-  const { mutateAsync: loginMutate, isPending: isLoginPending } = useRadfiAuth(spokeProvider);
-  const login = React.useCallback(async () => {
-    const result = await loginMutate();
-    setIsAuthed(true);
-    setTradingAddress(result.tradingAddress || void 0);
-  }, [loginMutate]);
-  return { walletAddress, isAuthed, tradingAddress, login, isLoginPending };
-}
-function useFundTradingWallet(spokeProvider) {
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async (amount) => {
-      if (!spokeProvider) {
-        throw new Error("Bitcoin spoke provider not found");
-      }
-      return sdk.BitcoinSpokeService.fundTradingWallet(amount, spokeProvider);
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["btc-balance"] });
-      queryClient.invalidateQueries({ queryKey: ["xBalances"] });
-    }
-  });
-}
-function useBitcoinBalance(address, rpcUrl = "https://mempool.space/api") {
-  return reactQuery.useQuery({
-    queryKey: ["btc-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
-  });
-}
-function useTradingWalletBalance(spokeProvider, tradingAddress) {
-  return reactQuery.useQuery({
-    queryKey: ["trading-wallet-balance", tradingAddress],
-    queryFn: () => {
-      if (!spokeProvider || !tradingAddress) {
-        throw new Error("spokeProvider and tradingAddress are required");
-      }
-      return spokeProvider.radfi.getBalance(tradingAddress);
-    },
-    enabled: !!spokeProvider && !!tradingAddress
-  });
-}
-function useExpiredUtxos(spokeProvider, tradingAddress) {
-  return reactQuery.useQuery({
-    queryKey: ["expired-utxos", tradingAddress],
-    queryFn: async () => {
-      if (!spokeProvider || !tradingAddress) {
-        throw new Error("spokeProvider and tradingAddress are required");
-      }
-      const result = await spokeProvider.radfi.getExpiredUtxos(tradingAddress);
-      return result.data;
-    },
-    enabled: !!spokeProvider && !!tradingAddress,
-    refetchInterval: 6e4
-    // refetch every minute
-  });
-}
-function useRenewUtxos(spokeProvider) {
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async ({ txIdVouts }) => {
-      if (!spokeProvider) {
-        throw new Error("Bitcoin spoke provider not found");
-      }
-      const userAddress = await spokeProvider.walletProvider.getWalletAddress();
-      const session = loadRadfiSession(userAddress);
-      const accessToken = session?.accessToken || spokeProvider.radfiAccessToken;
-      if (!accessToken) {
-        throw new Error("Radfi authentication required. Please login first.");
-      }
-      const buildResult = await spokeProvider.radfi.buildRenewUtxoTransaction(
-        { userAddress, txIdVouts },
-        accessToken
-      );
-      const signedTx = await spokeProvider.walletProvider.signTransaction(
-        buildResult.base64Psbt,
-        false
-      );
-      const signedBase64Tx = sdk.normalizePsbtToBase64(signedTx);
-      return spokeProvider.radfi.signAndBroadcastRenewUtxo(
-        { userAddress, signedBase64Tx },
-        accessToken
-      );
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["expired-utxos"] });
-      queryClient.invalidateQueries({ queryKey: ["trading-wallet-balance"] });
-    }
-  });
-}
-function useRadfiWithdraw(spokeProvider) {
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async ({ amount, tokenId, withdrawTo }) => {
-      if (!spokeProvider) {
-        throw new Error("Bitcoin spoke provider not found");
-      }
-      const userAddress = await spokeProvider.walletProvider.getWalletAddress();
-      const session = loadRadfiSession(userAddress);
-      const accessToken = session?.accessToken || spokeProvider.radfiAccessToken;
-      if (!accessToken) {
-        throw new Error("Radfi authentication required. Please login first.");
-      }
-      const buildResult = await spokeProvider.radfi.withdrawToUser(
-        { userAddress, amount, tokenId, withdrawTo },
-        accessToken
-      );
-      const signedTx = await spokeProvider.walletProvider.signTransaction(
-        buildResult.base64Psbt,
-        false
-      );
-      const signedBase64Tx = sdk.normalizePsbtToBase64(signedTx);
-      const txId = await spokeProvider.radfi.signAndBroadcastWithdraw(
-        { userAddress, signedBase64Tx },
-        accessToken
-      );
-      return { txId, fee: buildResult.fee.totalFee };
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["trading-wallet-balance"] });
-      queryClient.invalidateQueries({ queryKey: ["btc-balance"] });
-      queryClient.invalidateQueries({ queryKey: ["xBalances"] });
-    }
-  });
-}
-function useBorrow() {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("spokeProvider is not found");
-      }
-      const response = await sodax.moneyMarket.borrow(params, spokeProvider);
-      if (!response.ok) {
-        throw response.error;
-      }
-      return response;
-    }
-  });
-}
-function useRepay() {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("spokeProvider is not found");
-      }
-      const response = await sodax.moneyMarket.repay(params, spokeProvider);
-      if (!response.ok) {
-        throw response.error;
-      }
-      return response;
-    }
-  });
-}
-function useSupply() {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("spokeProvider is not found");
-      }
-      const response = await sodax.moneyMarket.supply(params, spokeProvider);
-      if (!response.ok) {
-        throw response.error;
-      }
-      return response;
-    }
-  });
-}
-function useWithdraw() {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("spokeProvider is not found");
-      }
-      const response = await sodax.moneyMarket.withdraw(params, spokeProvider);
-      if (!response.ok) {
-        throw response.error;
-      }
-      return response;
-    }
-  });
-}
-function isLegacyParams(params) {
-  return "spokeProvider" in params || "address" in params;
-}
-function resolveParams(params) {
-  if (isLegacyParams(params)) {
-    return {
-      spokeChainId: params.spokeProvider?.chainConfig.chain.id,
-      userAddress: params.address
-    };
-  }
-  return { spokeChainId: params.spokeChainId, userAddress: params.userAddress };
-}
-function useUserReservesData(params) {
-  const { sodax } = useSodaxContext();
-  const resolved = params ? resolveParams(params) : { spokeChainId: void 0, userAddress: void 0 };
-  const defaultQueryOptions = {
-    queryKey: ["mm", "userReservesData", resolved.spokeChainId, resolved.userAddress],
-    enabled: !!resolved.spokeChainId && !!resolved.userAddress,
-    refetchInterval: 5e3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-    // override default query options if provided
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!resolved.spokeChainId || !resolved.userAddress) {
-        throw new Error("spokeChainId or userAddress is not defined");
-      }
-      return await sodax.moneyMarket.data.getUserReservesData(resolved.spokeChainId, resolved.userAddress);
-    }
-  });
-}
-function useReservesData(params) {
-  const defaultQueryOptions = {
-    queryKey: ["mm", "reservesData"],
-    refetchInterval: 5e3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-    // override default query options if provided
-  };
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      return await sodax.moneyMarket.data.getReservesData();
-    }
-  });
-}
-function useMMAllowance({
-  params,
-  spokeProvider,
-  queryOptions
-}) {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["mm", "allowance", params?.token, params?.action],
-    /**
-     * IMPORTANT: Skip allowance checks for 'borrow' and 'withdraw' actions.
-     *
-     * Reason: According to the SDK's MoneyMarketService.isAllowanceValid() implementation,
-     * borrow and withdraw actions do NOT require ERC-20 token approval. The SDK's
-     * isAllowanceValid() method always returns `true` for these actions without making
-     * any on-chain allowance checks.
-     *
-     * This optimization prevents unnecessary RPC calls and avoids showing confusing states for actions that don't actually need approval.
-     *
-     * Only 'supply' and 'repay' actions require token approval and should trigger allowance checks.
-     */
-    enabled: !!spokeProvider && !!params && params.action !== "borrow" && params.action !== "withdraw",
-    refetchInterval: 5e3,
-    gcTime: 0
-    // Don't cache failed queries
-  };
-  queryOptions = {
-    ...defaultQueryOptions,
-    ...queryOptions
-    // override default query options if provided
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!spokeProvider) throw new Error("Spoke provider is required");
-      if (!params) throw new Error("Params are required");
-      if (params.action === "borrow" || params.action === "withdraw") {
-        return true;
-      }
-      const allowance = await sodax.moneyMarket.isAllowanceValid(params, spokeProvider);
-      if (!allowance.ok) {
-        throw allowance.error;
-      }
-      return allowance.value;
-    }
-  });
-}
-function useMMApprove() {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const allowance = await sodax.moneyMarket.approve(params, spokeProvider, false);
-      if (!allowance.ok) {
-        throw allowance.error;
-      }
-      return allowance.value;
-    },
-    onSuccess: (_, { params, spokeProvider }) => {
-      queryClient.invalidateQueries({
-        queryKey: ["mm", "allowance", spokeProvider?.chainConfig.chain.id, params.token, params.action]
-      });
-    }
-  });
-}
-function useAToken({ aToken, queryOptions }) {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["mm", "aToken", aToken],
-    enabled: !!aToken
-  };
-  queryOptions = {
-    ...defaultQueryOptions,
-    ...queryOptions
-    // override default query options if provided
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!aToken) {
-        throw new Error("aToken address or hub provider is not defined");
-      }
-      if (!viem.isAddress(aToken)) {
-        throw new Error("aToken address is not a valid address");
-      }
-      const aTokenData = await sodax.moneyMarket.data.getATokenData(aToken);
-      return {
-        ...aTokenData,
-        xChainId: sodax.hubProvider.chainConfig.chain.id
-      };
-    }
-  });
-}
-function useATokensBalances({
-  aTokens,
-  spokeProvider,
-  userAddress,
-  queryOptions
-}) {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["mm", "aTokensBalances", aTokens, spokeProvider?.chainConfig.chain.id, userAddress],
-    enabled: aTokens.length > 0 && aTokens.every((token) => viem.isAddress(token)) && !!spokeProvider && !!userAddress
-  };
-  queryOptions = {
-    ...defaultQueryOptions,
-    ...queryOptions
-    // override default query options if provided
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (aTokens.length === 0) {
-        return /* @__PURE__ */ new Map();
-      }
-      if (!spokeProvider || !userAddress) {
-        throw new Error("Spoke provider and user address are required");
-      }
-      for (const aToken of aTokens) {
-        if (!viem.isAddress(aToken)) {
-          throw new Error(`Invalid aToken address: ${aToken}`);
-        }
-      }
-      const hubWalletAddress = await sdk.HubService.getUserHubWalletAddress(userAddress, spokeProvider.chainConfig.chain.id, sodax.hubProvider);
-      return await sodax.moneyMarket.data.getATokensBalances(aTokens, hubWalletAddress);
-    }
-  });
-}
-function useReservesUsdFormat(params) {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = { queryKey: ["mm", "reservesUsdFormat"] };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-    // override default query options if provided
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      const reserves = await sodax.moneyMarket.data.getReservesHumanized();
-      return sodax.moneyMarket.data.formatReservesUSD(sodax.moneyMarket.data.buildReserveDataWithPrice(reserves));
-    }
-  });
-}
-function isLegacyParams2(params) {
-  return "spokeProvider" in params || "address" in params;
-}
-function resolveParams2(params) {
-  if (isLegacyParams2(params)) {
-    return {
-      spokeChainId: params.spokeProvider?.chainConfig.chain.id,
-      userAddress: params.address
-    };
-  }
-  return { spokeChainId: params.spokeChainId, userAddress: params.userAddress };
-}
-function useUserFormattedSummary(params) {
-  const { sodax } = useSodaxContext();
-  const resolved = params ? resolveParams2(params) : { spokeChainId: void 0, userAddress: void 0 };
-  const defaultQueryOptions = {
-    queryKey: ["mm", "userFormattedSummary", resolved.spokeChainId, resolved.userAddress],
-    enabled: !!resolved.spokeChainId && !!resolved.userAddress,
-    refetchInterval: 5e3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-    // override default query options if provided
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!resolved.spokeChainId || !resolved.userAddress) {
-        throw new Error("spokeChainId or userAddress is not defined");
-      }
-      const reserves = await sodax.moneyMarket.data.getReservesHumanized();
-      const formattedReserves = sodax.moneyMarket.data.formatReservesUSD(
-        sodax.moneyMarket.data.buildReserveDataWithPrice(reserves)
-      );
-      const userReserves = await sodax.moneyMarket.data.getUserReservesHumanized(
-        resolved.spokeChainId,
-        resolved.userAddress
-      );
-      return sodax.moneyMarket.data.formatUserSummary(
-        sodax.moneyMarket.data.buildUserSummaryRequest(reserves, formattedReserves, userReserves)
-      );
-    }
-  });
-}
-var useQuote = (payload) => {
-  const { sodax } = useSodaxContext();
-  const queryKey = React.useMemo(() => {
-    if (!payload) return ["quote", void 0];
-    return [
-      "quote",
-      {
-        ...payload,
-        amount: payload.amount.toString()
-      }
-    ];
-  }, [payload]);
-  return reactQuery.useQuery({
-    queryKey,
-    queryFn: async () => {
-      if (!payload) {
-        return void 0;
-      }
-      return sodax.swaps.getQuote(payload);
-    },
-    enabled: !!payload,
-    refetchInterval: 3e3
-  });
-};
-function useSwap(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      return sodax.swaps.swap({
-        intentParams: params,
-        spokeProvider
-      });
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["xBalances"] });
-    }
-  });
-}
-var useStatus = (intent_tx_hash) => {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: [intent_tx_hash],
-    queryFn: async () => {
-      return sodax.swaps.getStatus({ intent_tx_hash });
-    },
-    refetchInterval: 3e3
-    // 3s
-  });
-};
-function useSwapAllowance(params, spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["allowance", params],
-    queryFn: async () => {
-      if (!spokeProvider || !params) {
-        return false;
-      }
-      const allowance = await sodax.swaps.isAllowanceValid({
-        intentParams: params,
-        spokeProvider
-      });
-      if (allowance.ok) {
-        return allowance.value;
-      }
-      return false;
-    },
-    enabled: !!spokeProvider && !!params,
-    refetchInterval: 2e3
-  });
-}
-function useSwapApprove(params, spokeProvider) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  const {
-    mutateAsync: approve,
-    isPending,
-    error,
-    reset: resetError
-  } = reactQuery.useMutation({
-    mutationFn: async ({ params: params2 }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      if (!params2) {
-        throw new Error("Swap Params not found");
-      }
-      const allowance = await sodax.swaps.approve({
-        intentParams: params2,
-        spokeProvider
-      });
-      if (!allowance.ok) {
-        throw new Error("Failed to approve input token");
-      }
-      return allowance.ok;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["allowance", params] });
-    }
-  });
-  return {
-    approve,
-    isLoading: isPending,
-    error,
-    resetError
-  };
-}
-function useCancelSwap(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async ({ intent, raw = false }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      return sodax.swaps.cancelIntent(intent, spokeProvider, raw);
-    }
-  });
-}
-function useCreateLimitOrder(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      return sodax.swaps.createLimitOrder({
-        intentParams: params,
-        spokeProvider
-      });
-    }
-  });
-}
-function useCancelLimitOrder() {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async ({ intent, spokeProvider, timeout }) => {
-      return sodax.swaps.cancelLimitOrder({
-        intent,
-        spokeProvider,
-        timeout
-      });
-    }
-  });
-}
-var useBackendIntentByTxHash = (params) => {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "intent", "txHash", params?.params?.txHash],
-    enabled: !!params?.params?.txHash && params?.params?.txHash.length > 0,
-    retry: 3,
-    refetchInterval: 1e3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!params?.params?.txHash) {
-        return void 0;
-      }
-      return sodax.backendApi.getIntentByTxHash(params.params.txHash);
-    }
-  });
-};
-var useBackendIntentByHash = (params) => {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "intent", "hash", params?.params?.intentHash],
-    enabled: !!params?.params?.intentHash && params?.params?.intentHash.length > 0,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!params?.params?.intentHash) {
-        return void 0;
-      }
-      return sodax.backendApi.getIntentByHash(params.params.intentHash);
-    }
-  });
-};
-var useBackendUserIntents = ({
-  params,
-  queryOptions
-}) => {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "intent", "user", params],
-    enabled: !!params && !!params.userAddress && params.userAddress.length > 0,
-    retry: 3
-  };
-  queryOptions = {
-    ...defaultQueryOptions,
-    ...queryOptions
-    // override default query options if provided
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!params?.userAddress) {
-        return void 0;
-      }
-      return sodax.backendApi.getUserIntents(params);
-    }
-  });
-};
-var useBackendSubmitSwapTx = (params) => {
-  const { sodax } = useSodaxContext();
-  const defaultMutationOptions = {
-    retry: 3
-  };
-  const mutationOptions = {
-    ...defaultMutationOptions,
-    ...params?.mutationOptions
-  };
-  return reactQuery.useMutation({
-    ...mutationOptions,
-    mutationFn: async (request) => {
-      return sodax.backendApi.submitSwapTx(request, params?.apiConfig);
-    }
-  });
-};
-var useBackendSubmitSwapTxStatus = (params) => {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "swaps", "submit-tx", "status", params?.params?.txHash, params?.params?.srcChainId],
-    enabled: !!params?.params?.txHash && params.params.txHash.length > 0,
-    retry: 3,
-    refetchInterval: (query) => {
-      const status = query.state.data?.data?.status;
-      if (status === "executed" || status === "failed") return false;
-      return 1e3;
-    }
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!params?.params?.txHash) {
-        return void 0;
-      }
-      return sodax.backendApi.getSubmitSwapTxStatus(
-        {
-          txHash: params.params.txHash,
-          srcChainId: params.params.srcChainId
-        },
-        params.apiConfig
-      );
-    }
-  });
-};
-var useBackendOrderbook = (params) => {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "solver", "orderbook", params?.pagination?.offset, params?.pagination?.limit],
-    enabled: !!params?.pagination && !!params?.pagination.offset && !!params?.pagination.limit,
-    staleTime: 30 * 1e3,
-    // 30 seconds for real-time data
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-    // override default query options if provided
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!params?.pagination || !params?.pagination.offset || !params?.pagination.limit) {
-        return void 0;
-      }
-      return sodax.backendApi.getOrderbook(params.pagination);
-    }
-  });
-};
-var useBackendMoneyMarketPosition = (params) => {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "mm", "position", params?.userAddress],
-    enabled: !!params?.userAddress && params?.userAddress.length > 0,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!params?.userAddress) {
-        return void 0;
-      }
-      return sodax.backendApi.getMoneyMarketPosition(params.userAddress);
-    }
-  });
-};
-var useBackendAllMoneyMarketAssets = (params) => {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "mm", "assets", "all"],
-    enabled: true,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      return sodax.backendApi.getAllMoneyMarketAssets();
-    }
-  });
-};
-var useBackendMoneyMarketAsset = (params) => {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "mm", "asset", params?.params?.reserveAddress],
-    enabled: !!params?.params?.reserveAddress && params?.params?.reserveAddress.length > 0,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!params?.params?.reserveAddress) {
-        return void 0;
-      }
-      return sodax.backendApi.getMoneyMarketAsset(params.params.reserveAddress);
-    }
-  });
-};
-var useBackendMoneyMarketAssetBorrowers = (params) => {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "mm", "asset", "borrowers", params],
-    enabled: !!params?.params?.reserveAddress && !!params.pagination.offset && !!params.pagination.limit,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!params?.params?.reserveAddress || !params.pagination.offset || !params.pagination.limit) {
-        return void 0;
-      }
-      return sodax.backendApi.getMoneyMarketAssetBorrowers(params.params.reserveAddress, {
-        offset: params.pagination.offset,
-        limit: params.pagination.limit
-      });
-    }
-  });
-};
-var useBackendMoneyMarketAssetSuppliers = (params) => {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "mm", "asset", "suppliers", params],
-    enabled: !!params?.params?.reserveAddress && !!params.pagination.offset && !!params.pagination.limit,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!params?.params?.reserveAddress || !params.pagination.offset || !params.pagination.limit) {
-        return void 0;
-      }
-      return sodax.backendApi.getMoneyMarketAssetSuppliers(params.params.reserveAddress, {
-        offset: params.pagination.offset,
-        limit: params.pagination.limit
-      });
-    }
-  });
-};
-var useBackendAllMoneyMarketBorrowers = (params) => {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["api", "mm", "borrowers", "all", params],
-    enabled: !!params && !!params.pagination.offset && !!params.pagination.limit,
-    retry: 3
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions
-  };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!params || !params.pagination.offset || !params.pagination.limit) {
-        return void 0;
-      }
-      return sodax.backendApi.getAllMoneyMarketBorrowers({
-        offset: params.pagination.offset,
-        limit: params.pagination.limit
-      });
-    }
-  });
-};
-function useBridgeAllowance(params, spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["bridge-allowance", params],
-    queryFn: async () => {
-      if (!spokeProvider || !params) {
-        return false;
-      }
-      const allowance = await sodax.bridge.isAllowanceValid({
-        params,
-        spokeProvider
-      });
-      if (allowance.ok) {
-        return allowance.value;
-      }
-      return false;
-    },
-    enabled: !!spokeProvider && !!params
-  });
-}
-function useBridgeApprove(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  const {
-    mutateAsync: approve,
-    isPending,
-    error,
-    reset: resetError
-  } = reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const allowance = await sodax.bridge.approve({
-        params,
-        spokeProvider
-      });
-      if (!allowance.ok) {
-        throw new Error("Failed to approve tokens for bridge");
-      }
-      return true;
-    },
-    onSuccess: (_, params) => {
-      queryClient.invalidateQueries({ queryKey: ["bridge-allowance", params] });
-    }
-  });
-  return {
-    approve,
-    isLoading: isPending,
-    error,
-    resetError
-  };
-}
-function useBridge(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.bridge.bridge({
-        params,
-        spokeProvider
-      });
-      if (!result.ok) {
-        throw new Error(`Bridge failed: ${result.error.code}`);
-      }
-      return result;
-    }
-  });
-}
-function useGetBridgeableAmount(from, to) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["spoke-asset-manager-token-balance", from, to],
-    queryFn: async () => {
-      if (!from || !to) {
-        return { amount: 0n, decimals: 0, type: "DEPOSIT_LIMIT" };
-      }
-      const result = await sodax.bridge.getBridgeableAmount(from, to);
-      if (result.ok) {
-        return result.value;
-      }
-      console.error("Error getting bridgeable amount:", result.error);
-      return { amount: 0n, decimals: 0, type: "DEPOSIT_LIMIT" };
-    },
-    enabled: !!from && !!to
-  });
-}
-function useGetBridgeableTokens(from, to, token) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["bridgeable-tokens", from, to, token],
-    queryFn: async () => {
-      if (!from || !to || !token) {
-        return [];
-      }
-      const result = sodax.bridge.getBridgeableTokens(from, to, token);
-      if (result.ok) {
-        return result.value;
-      }
-      console.error("Error getting bridgeable tokens:", result.error);
-      return [];
-    },
-    enabled: !!from && !!to && !!token
-  });
-}
-function useStake(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.stake(params, spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Stake failed: ${result.error.code}`);
-      }
-      return result.value;
-    }
-  });
-}
-function useStakeApprove(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.approve({
-        params: { ...params, action: "stake" },
-        spokeProvider
-      });
-      if (!result.ok) {
-        throw new Error(`Stake approval failed: ${result.error.code}`);
-      }
-      return result.value;
-    }
-  });
-}
-function useStakeAllowance(params, spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["soda", "stakeAllowance", params, spokeProvider?.chainConfig.chain.id],
-    queryFn: async () => {
-      if (!params || !spokeProvider) {
-        return false;
-      }
-      const result = await sodax.staking.isAllowanceValid({
-        params: { ...params, action: "stake" },
-        spokeProvider
-      });
-      if (!result.ok) {
-        throw new Error(`Allowance check failed: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    enabled: !!params && !!spokeProvider,
-    refetchInterval: 5e3
-    // Refetch every 5 seconds
-  });
-}
-function useUnstake(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.unstake({ ...params, action: "unstake" }, spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Unstake failed: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["stakingInfo"] });
-      queryClient.invalidateQueries({ queryKey: ["unstakingInfo"] });
-      queryClient.invalidateQueries({ queryKey: ["unstakingInfoWithPenalty"] });
-    }
-  });
-}
-function useClaim(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.claim({ ...params, action: "claim" }, spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Claim failed: ${result.error.code}`);
-      }
-      return result.value;
-    }
-  });
-}
-function useCancelUnstake(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not available");
-      }
-      const result = await sodax.staking.cancelUnstake({ ...params, action: "cancelUnstake" }, spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Cancel unstake failed: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["stakingInfo"] });
-      queryClient.invalidateQueries({ queryKey: ["unstakingInfo"] });
-      queryClient.invalidateQueries({ queryKey: ["unstakingInfoWithPenalty"] });
-    }
-  });
-}
-function useStakingInfo(spokeProvider, refetchInterval = 5e3) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["soda", "stakingInfo", spokeProvider?.chainConfig.chain.id],
-    queryFn: async () => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.getStakingInfoFromSpoke(spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Failed to fetch staking info: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    enabled: !!spokeProvider,
-    refetchInterval
-  });
-}
-function useUnstakingInfoWithPenalty(userAddress, spokeProvider, refetchInterval = 5e3) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["soda", "unstakingInfoWithPenalty", spokeProvider?.chainConfig.chain.id, userAddress],
-    queryFn: async () => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const penaltyResult = await sodax.staking.getUnstakingInfoWithPenalty(spokeProvider);
-      if (!penaltyResult.ok) {
-        throw new Error(`Failed to fetch unstaking info with penalty: ${penaltyResult.error.code}`);
-      }
-      return penaltyResult.value;
-    },
-    enabled: !!spokeProvider && !!userAddress,
-    refetchInterval
-  });
-}
-function useStakingConfig(refetchInterval = 3e4) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["soda", "stakingConfig"],
-    queryFn: async () => {
-      const result = await sodax.staking.getStakingConfig();
-      if (!result.ok) {
-        throw new Error(`Failed to fetch staking config: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    refetchInterval
-  });
-}
-function useStakeRatio(amount, refetchInterval = 1e4) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["soda", "stakeRatio", amount?.toString()],
-    queryFn: async () => {
-      if (!amount || amount <= 0n) {
-        throw new Error("Amount must be greater than 0");
-      }
-      if (!sodax?.staking) {
-        throw new Error("Staking service not available");
-      }
-      const result = await sodax.staking.getStakeRatio(amount);
-      if (!result.ok) {
-        throw new Error(`Failed to fetch stake ratio: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    enabled: !!amount && amount > 0n && !!sodax?.staking,
-    refetchInterval
-  });
-}
-function useInstantUnstakeRatio(amount, refetchInterval = 1e4) {
-  const { sodax } = useSodaxContext();
-  console.log("useInstantUnstakeRatio hook called with:", { amount: amount?.toString(), sodax: !!sodax });
-  return reactQuery.useQuery({
-    queryKey: ["soda", "instantUnstakeRatio", amount?.toString()],
-    queryFn: async () => {
-      console.log("useInstantUnstakeRatio queryFn called with amount:", amount?.toString());
-      if (!amount || amount <= 0n) {
-        throw new Error("Amount must be greater than 0");
-      }
-      if (!sodax?.staking) {
-        throw new Error("Staking service not available");
-      }
-      const result = await sodax.staking.getInstantUnstakeRatio(amount);
-      if (!result.ok) {
-        throw new Error(`Failed to fetch instant unstake ratio: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    enabled: !!amount && amount > 0n && !!sodax?.staking,
-    refetchInterval
-  });
-}
-function useConvertedAssets(amount, refetchInterval = 1e4) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["soda", "convertedAssets", amount?.toString()],
-    queryFn: async () => {
-      if (!amount || amount <= 0n) {
-        throw new Error("Amount must be greater than 0");
-      }
-      const result = await sodax.staking.getConvertedAssets(amount);
-      if (!result.ok) {
-        throw new Error(`Failed to fetch converted assets: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    enabled: !!amount && amount > 0n && !!sodax?.staking,
-    refetchInterval
-  });
-}
-function useInstantUnstake(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      if (!spokeProvider) {
-        throw new Error("spokeProvider is not found");
-      }
-      const result = await sodax.staking.instantUnstake({ ...params, action: "instantUnstake" }, spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Instant unstake failed: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    onError: (error) => {
-      console.error("Instant unstake error:", error);
-    }
-  });
-}
-function useUnstakeAllowance(params, spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["soda", "unstakeAllowance", params, spokeProvider?.chainConfig.chain.id],
-    queryFn: async () => {
-      if (!params || !spokeProvider) {
-        return false;
-      }
-      const result = await sodax.staking.isAllowanceValid({
-        params: { ...params, action: "unstake" },
-        spokeProvider
-      });
-      if (!result.ok) {
-        console.error(`Unstake allowance check failed: ${result.error.code}, error: ${result.error.error}`);
-        throw new Error(`Unstake allowance check failed: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    enabled: !!params && !!spokeProvider,
-    refetchInterval: 5e3
-    // Refetch every 5 seconds
-  });
-}
-function useUnstakeApprove(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      console.log("useUnstakeApprove called with params:", params);
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.approve({
-        params: { ...params, action: "unstake" },
-        spokeProvider
-      });
-      if (!result.ok) {
-        throw new Error(`Unstake approval failed: ${result.error.code}`);
-      }
-      return result.value;
-    }
-  });
-}
-function useUnstakingInfo(userAddress, spokeProvider, refetchInterval = 5e3) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["soda", "unstakingInfoWithPenalty", spokeProvider?.chainConfig.chain.id, userAddress],
-    queryFn: async () => {
-      if (!spokeProvider || !userAddress) {
-        throw new Error("Spoke provider or user address not found");
-      }
-      const result = await sodax.staking.getUnstakingInfo(spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Failed to fetch unstaking info: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    enabled: !!spokeProvider && !!userAddress,
-    refetchInterval
-  });
-}
-function useInstantUnstakeApprove(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      console.log("useInstantUnstakeApprove called with params:", params);
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const result = await sodax.staking.approve({
-        params: { ...params, action: "instantUnstake" },
-        spokeProvider
-      });
-      if (!result.ok) {
-        throw new Error(`Instant unstake approval failed: ${result.error.code}`);
-      }
-      return result.value;
-    }
-  });
-}
-function useInstantUnstakeAllowance(params, spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["soda", "instantUnstakeAllowance", params, spokeProvider?.chainConfig.chain.id],
-    queryFn: async () => {
-      if (!params || !spokeProvider) {
-        return false;
-      }
-      const result = await sodax.staking.isAllowanceValid({
-        params: { ...params, action: "instantUnstake" },
-        spokeProvider
-      });
-      if (!result.ok) {
-        console.error(`Unstake allowance check failed: ${result.error.code}, error: ${result.error.error}`);
-        throw new Error(`Unstake allowance check failed: ${result.error.code}`);
-      }
-      return result.value;
-    },
-    enabled: !!params && !!spokeProvider,
-    refetchInterval: 5e3
-    // Refetch every 5 seconds
-  });
-}
-
-// src/hooks/migrate/types.ts
-var MIGRATION_MODE_ICX_SODA = "icxsoda";
-var MIGRATION_MODE_BNUSD = "bnusd";
-
-// src/hooks/migrate/useMigrate.tsx
-function useMigrate(spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useMutation({
-    mutationFn: async (params) => {
-      const { token, amount, migrationMode = MIGRATION_MODE_ICX_SODA, toToken, destinationAddress } = params;
-      const amountToMigrate = viem.parseUnits(amount ?? "0", token?.decimals ?? 0);
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      if (migrationMode === MIGRATION_MODE_ICX_SODA) {
-        if (token?.xChainId === types.ICON_MAINNET_CHAIN_ID) {
-          const params2 = {
-            address: sdk.spokeChainConfig[types.ICON_MAINNET_CHAIN_ID].nativeToken,
-            amount: amountToMigrate,
-            to: destinationAddress
-          };
-          const result2 = await sodax.migration.migrateIcxToSoda(params2, spokeProvider, 3e4);
-          if (result2.ok) {
-            const [spokeTxHash, hubTxHash] = result2.value;
-            return { spokeTxHash, hubTxHash };
-          }
-          throw new Error("ICX to SODA migration failed. Please try again.");
-        }
-        const revertParams = {
-          amount: amountToMigrate,
-          to: destinationAddress
-        };
-        const result = await sodax.migration.revertMigrateSodaToIcx(
-          revertParams,
-          spokeProvider,
-          3e4
-        );
-        if (result.ok) {
-          const [hubTxHash, spokeTxHash] = result.value;
-          return { spokeTxHash, hubTxHash };
-        }
-        throw new Error("SODA to ICX migration failed. Please try again.");
-      }
-      if (migrationMode === MIGRATION_MODE_BNUSD) {
-        const params2 = {
-          srcChainId: token?.xChainId,
-          dstChainId: toToken?.xChainId,
-          srcbnUSD: token?.address,
-          dstbnUSD: toToken?.address,
-          amount: amountToMigrate,
-          to: destinationAddress
-        };
-        const result = await sodax.migration.migratebnUSD(params2, spokeProvider, 3e4);
-        if (result.ok) {
-          const [spokeTxHash, hubTxHash] = result.value;
-          return { spokeTxHash, hubTxHash };
-        }
-        const errorMessage = sdk.isLegacybnUSDToken(token?.address) ? "bnUSD migration failed. Please try again." : "bnUSD reverse migration failed. Please try again.";
-        throw new Error(errorMessage);
-      }
-      throw new Error("Invalid migration mode");
-    }
-  });
-}
-function useMigrationAllowance(params, spokeProvider) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryKey: ["migration-allowance", params],
-    queryFn: async () => {
-      if (!spokeProvider || !params) {
-        return false;
-      }
-      const { token, amount, migrationMode = MIGRATION_MODE_ICX_SODA, toToken, destinationAddress } = params;
-      if (token?.xChainId === types.ICON_MAINNET_CHAIN_ID) {
-        return true;
-      }
-      if (!spokeProvider) throw new Error("Spoke provider is required");
-      const amountToMigrate = viem.parseUnits(amount ?? "0", token?.decimals ?? 0);
-      let migrationParams;
-      if (migrationMode === MIGRATION_MODE_ICX_SODA) {
-        migrationParams = {
-          amount: amountToMigrate,
-          to: destinationAddress
-        };
-      } else {
-        if (!toToken) throw new Error("Destination token is required for bnUSD migration");
-        migrationParams = {
-          srcChainId: token?.xChainId,
-          dstChainId: toToken?.xChainId,
-          srcbnUSD: token?.address,
-          dstbnUSD: toToken?.address,
-          amount: amountToMigrate,
-          to: destinationAddress
-        };
-      }
-      const allowance = await sodax.migration.isAllowanceValid(migrationParams, "revert", spokeProvider);
-      if (allowance.ok) {
-        return allowance.value;
-      }
-      return false;
-    },
-    enabled: !!spokeProvider && !!params,
-    refetchInterval: 2e3
-  });
-}
-function useMigrationApprove(params, spokeProvider) {
-  const { sodax } = useSodaxContext();
-  const [isLoading, setIsLoading] = React.useState(false);
-  const [error, setError] = React.useState(null);
-  const [isApproved, setIsApproved] = React.useState(false);
-  const queryClient = reactQuery.useQueryClient();
-  const prevTokenAddress = React.useRef(void 0);
-  const prevAmount = React.useRef(void 0);
-  React.useEffect(() => {
-    if (prevTokenAddress.current !== params?.token?.address || prevAmount.current !== params?.amount) {
-      setIsApproved(false);
-      prevTokenAddress.current = params?.token?.address;
-      prevAmount.current = params?.amount;
-    }
-  }, [params?.token?.address, params?.amount]);
-  const approve = React.useCallback(
-    async ({ params: approveParams }) => {
-      try {
-        setIsLoading(true);
-        setError(null);
-        if (!spokeProvider) {
-          throw new Error("Spoke provider not found");
-        }
-        if (!approveParams) {
-          throw new Error("Migration intent not found");
-        }
-        const { token, amount, migrationMode = MIGRATION_MODE_ICX_SODA, toToken, destinationAddress } = approveParams;
-        const amountToMigrate = viem.parseUnits(amount ?? "0", token?.decimals ?? 0);
-        let result;
-        if (migrationMode === MIGRATION_MODE_ICX_SODA) {
-          const revertParams = {
-            amount: amountToMigrate,
-            to: destinationAddress
-          };
-          result = await sodax.migration.approve(revertParams, "revert", spokeProvider, false);
-        } else if (migrationMode === MIGRATION_MODE_BNUSD) {
-          if (!toToken) throw new Error("Destination token is required for bnUSD migration");
-          const migrationParams = {
-            srcChainId: token?.xChainId,
-            dstChainId: toToken?.xChainId,
-            srcbnUSD: token?.address,
-            dstbnUSD: toToken?.address,
-            amount: amountToMigrate,
-            to: destinationAddress
-          };
-          result = await sodax.migration.approve(migrationParams, "revert", spokeProvider, false);
-        } else {
-          throw new Error("Invalid migration mode");
-        }
-        if (!result.ok) {
-          throw new Error("Failed to approve tokens");
-        }
-        setIsApproved(true);
-        queryClient.invalidateQueries({ queryKey: ["migration-allowance", params] });
-        return result.ok;
-      } catch (err) {
-        const error2 = err instanceof Error ? err : new Error("An unknown error occurred");
-        setError(error2);
-        throw error2;
-      } finally {
-        setIsLoading(false);
-      }
-    },
-    [spokeProvider, sodax, queryClient, params]
-  );
-  const resetError = React.useCallback(() => {
-    setError(null);
-  }, []);
-  return {
-    approve,
-    isLoading,
-    error,
-    resetError,
-    isApproved
-  };
-}
-function usePools(params) {
-  const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ["dex", "pools"],
-    staleTime: Number.POSITIVE_INFINITY
-    // Pools list is static, cache indefinitely
-  };
-  const queryOptions = { ...defaultQueryOptions, ...params?.queryOptions };
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      return sodax.dex.clService.getPools();
-    }
-  });
-}
-function usePoolData({
-  poolKey,
-  queryOptions = {
-    queryKey: ["dex", "poolData", poolKey],
-    enabled: poolKey !== null,
-    staleTime: 1e4,
-    refetchInterval: 3e4
-  }
-}) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!poolKey) {
-        throw new Error("Pool key is required");
-      }
-      return await sodax.dex.clService.getPoolData(poolKey, sodax.hubProvider.publicClient);
-    },
-    enabled: poolKey !== null
-  });
-}
-function usePoolBalances({
-  poolData,
-  poolKey,
-  spokeProvider,
-  enabled = true,
-  queryOptions = {
-    queryKey: [
-      "dex",
-      "poolBalances",
-      poolData?.poolKey,
-      spokeProvider?.chainConfig.chain.id
-    ],
-    enabled: enabled && poolData !== null && poolKey !== null && spokeProvider !== null,
-    staleTime: 5e3,
-    // Consider data stale after 5 seconds
-    refetchInterval: 1e4
-    // Refetch every 10 seconds
-  }
-}) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!poolData || !spokeProvider || !poolKey) {
-        throw new Error("Pool data, pool key, and spoke provider are required");
-      }
-      const [balance0, balance1] = await Promise.all([
-        sodax.dex.assetService.getDeposit(poolData.token0.address, spokeProvider),
-        sodax.dex.assetService.getDeposit(poolData.token1.address, spokeProvider)
-      ]);
-      return {
-        token0Balance: balance0,
-        token1Balance: balance1
-      };
-    }
-  });
-}
-function usePositionInfo({
-  tokenId,
-  poolKey,
-  queryOptions = {
-    queryKey: ["dex", "positionInfo", tokenId, poolKey],
-    enabled: tokenId !== null && poolKey !== null && tokenId !== "",
-    staleTime: 1e4
-    // Consider data stale after 10 seconds
-  }
-}) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    queryFn: async () => {
-      if (!tokenId || !poolKey) {
-        throw new Error("Token ID and pool key are required");
-      }
-      const tokenIdBigInt = BigInt(tokenId);
-      const publicClient = sodax.hubProvider.publicClient;
-      const info = await sodax.dex.clService.getPositionInfo(tokenIdBigInt, publicClient);
-      const isValid = info.poolKey.currency0.toLowerCase() === poolKey.currency0.toLowerCase() && info.poolKey.currency1.toLowerCase() === poolKey.currency1.toLowerCase() && info.poolKey.fee === poolKey.fee;
-      return {
-        positionInfo: info,
-        isValid
-      };
-    },
-    ...queryOptions
-  });
-}
-function useDexDeposit() {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider is required");
-      }
-      if (!params) {
-        throw new Error("Deposit params are required");
-      }
-      const depositResult = await sodax.dex.assetService.deposit({
-        params,
-        spokeProvider
-      });
-      if (!depositResult.ok) {
-        throw new Error(`Deposit failed: ${depositResult.error?.code || "Unknown error"}`);
-      }
-      return depositResult.value;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances"] });
-    }
-  });
-}
-function useDexWithdraw() {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider is required");
-      }
-      const withdrawResult = await sodax.dex.assetService.withdraw({
-        params,
-        spokeProvider
-      });
-      if (!withdrawResult.ok) {
-        throw new Error(`Withdraw failed: ${withdrawResult.error.code}`);
-      }
-      return withdrawResult.value;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances"] });
-    }
-  });
-}
-function useDexAllowance({
-  params,
-  spokeProvider,
-  queryOptions = {
-    queryKey: [
-      "dex",
-      "allowance",
-      params?.asset,
-      params?.poolToken,
-      params?.amount.toString(),
-      spokeProvider?.chainConfig.chain.id
-    ],
-    enabled: !!params && !!spokeProvider
-  }
-}) {
-  const { sodax } = useSodaxContext();
-  return reactQuery.useQuery({
-    ...queryOptions,
-    queryFn: async () => {
-      if (!params || !spokeProvider) {
-        throw new Error("Params and spoke provider are required");
-      }
-      const allowanceResult = await sodax.dex.assetService.isAllowanceValid({
-        params: {
-          asset: params.asset,
-          amount: params.amount,
-          poolToken: params.poolToken
-        },
-        spokeProvider
-      });
-      if (!allowanceResult.ok) {
-        return false;
-      }
-      return allowanceResult.value;
-    }
-  });
-}
-function useDexApprove() {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      const approveResult = await sodax.dex.assetService.approve({
-        params,
-        spokeProvider,
-        raw: false
-      });
-      if (!approveResult.ok) {
-        throw new Error("Approval failed");
-      }
-      return approveResult.value;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["dex", "allowance"] });
-    }
-  });
-}
-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);
-        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);
-        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() {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (params.tokenId && params.isValidPosition) {
-        const increaseResult = await sodax.dex.clService.increaseLiquidity({
-          params: {
-            poolKey: params.poolKey,
-            tokenId: BigInt(params.tokenId),
-            tickLower: params.tickLower,
-            tickUpper: params.tickUpper,
-            liquidity: params.liquidity,
-            amount0Max: params.amount0Max,
-            amount1Max: params.amount1Max,
-            sqrtPriceX96: params.sqrtPriceX96
-          },
-          spokeProvider
-        });
-        if (!increaseResult.ok) {
-          throw new Error(`Increase liquidity failed: ${increaseResult.error?.code || "Unknown error"}`);
-        }
-        return increaseResult.value;
-      }
-      const supplyResult = await sodax.dex.clService.supplyLiquidity({
-        params: {
-          poolKey: params.poolKey,
-          tickLower: params.tickLower,
-          tickUpper: params.tickUpper,
-          liquidity: params.liquidity,
-          amount0Max: params.amount0Max,
-          amount1Max: params.amount1Max,
-          sqrtPriceX96: params.sqrtPriceX96
-        },
-        spokeProvider
-      });
-      if (!supplyResult.ok) {
-        throw new Error(`Supply liquidity failed: ${supplyResult.error?.code || "Unknown error"}`);
-      }
-      return supplyResult.value;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances"] });
-      queryClient.invalidateQueries({ queryKey: ["dex", "positionInfo"] });
-    }
-  });
-}
-function useDecreaseLiquidity() {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider is required");
-      }
-      const decreaseResult = await sodax.dex.clService.decreaseLiquidity({
-        params,
-        spokeProvider
-      });
-      if (!decreaseResult.ok) {
-        throw new Error(`Decrease liquidity failed: ${decreaseResult.error?.code || "Unknown error"}`);
-      }
-      return decreaseResult.value;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances"] });
-      queryClient.invalidateQueries({ queryKey: ["dex", "positionInfo"] });
-    }
-  });
-}
-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() {
-  const { sodax } = useSodaxContext();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider is required");
-      }
-      const result = await sodax.dex.clService.claimRewards({
-        params,
-        spokeProvider
-      });
-      if (!result.ok) {
-        throw new Error(`Claim rewards failed: ${result.error?.code || "Unknown error"}`);
-      }
-      return result.value;
-    },
-    onSuccess: (_, { params, spokeProvider }) => {
-      queryClient.invalidateQueries({
-        queryKey: ["dex", "poolBalances", params.poolKey, spokeProvider.chainConfig.chain.id]
-      });
-      queryClient.invalidateQueries({ queryKey: ["dex", "positionInfo", params.tokenId, params.poolKey] });
-      queryClient.invalidateQueries({ queryKey: ["dex", "poolData", params.poolKey] });
-    }
-  });
-}
-var SodaxProvider = ({ children, testnet = false, config, rpcConfig }) => {
-  const sodax = new sdk.Sodax(config);
-  return /* @__PURE__ */ React__default.default.createElement(SodaxContext.Provider, { value: { sodax, testnet, rpcConfig } }, children);
-};
-
-exports.MIGRATION_MODE_BNUSD = MIGRATION_MODE_BNUSD;
-exports.MIGRATION_MODE_ICX_SODA = MIGRATION_MODE_ICX_SODA;
-exports.SodaxProvider = SodaxProvider;
-exports.clearRadfiSession = clearRadfiSession;
-exports.createDecreaseLiquidityParamsProps = createDecreaseLiquidityParamsProps;
-exports.createDepositParamsProps = createDepositParamsProps;
-exports.createSupplyLiquidityParamsProps = createSupplyLiquidityParamsProps;
-exports.createWithdrawParamsProps = createWithdrawParamsProps;
-exports.loadRadfiSession = loadRadfiSession;
-exports.saveRadfiSession = saveRadfiSession;
-exports.useAToken = useAToken;
-exports.useATokensBalances = useATokensBalances;
-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.useFundTradingWallet = useFundTradingWallet;
-exports.useGetBridgeableAmount = useGetBridgeableAmount;
-exports.useGetBridgeableTokens = useGetBridgeableTokens;
-exports.useGetUserHubWalletAddress = useGetUserHubWalletAddress;
-exports.useHubProvider = useHubProvider;
-exports.useInstantUnstake = useInstantUnstake;
-exports.useInstantUnstakeAllowance = useInstantUnstakeAllowance;
-exports.useInstantUnstakeApprove = useInstantUnstakeApprove;
-exports.useInstantUnstakeRatio = useInstantUnstakeRatio;
-exports.useLiquidityAmounts = useLiquidityAmounts;
-exports.useMMAllowance = useMMAllowance;
-exports.useMMApprove = useMMApprove;
-exports.useMigrate = useMigrate;
-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.useReservesUsdFormat = useReservesUsdFormat;
-exports.useSodaxContext = useSodaxContext;
-exports.useSpokeProvider = useSpokeProvider;
-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.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;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map