@sodax/dapp-kit 1.3.1-beta-rc2 → 1.3.1-beta

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import React, { createContext, useContext, useState, useCallback, useMemo, useRef, useEffect } from 'react';
-import { SpokeService, deriveUserWalletAddress, STELLAR_MAINNET_CHAIN_ID, StellarSpokeProvider, StellarSpokeService, HubService, spokeChainConfig, BitcoinSpokeProvider, SONIC_MAINNET_CHAIN_ID, SonicSpokeProvider, EvmSpokeProvider, SuiSpokeProvider, IconSpokeProvider, InjectiveSpokeProvider, SolanaSpokeProvider, NearSpokeProvider, BitcoinSpokeService, normalizePsbtToBase64, isLegacybnUSDToken, Sodax } from '@sodax/sdk';
+import { SpokeService, deriveUserWalletAddress, STELLAR_MAINNET_CHAIN_ID, StellarSpokeProvider, StellarSpokeService, HubService, spokeChainConfig, BitcoinSpokeProvider, SONIC_MAINNET_CHAIN_ID, SonicSpokeProvider, EvmSpokeProvider, SuiSpokeProvider, IconSpokeProvider, InjectiveSpokeProvider, SolanaSpokeProvider, NearSpokeProvider, BitcoinSpokeService, normalizePsbtToBase64, isLegacybnUSDToken, ClService, Sodax } from '@sodax/sdk';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { isAddress, parseUnits } from 'viem';
 import { ICON_MAINNET_CHAIN_ID } from '@sodax/types';
@@ -214,12 +214,6 @@ function useSpokeProvider(spokeChainId, walletProvider) {
   }, [spokeChainId, xChainType, walletProvider, rpcConfig]);
   return spokeProvider;
 }
-
-// src/hooks/bitcoin/radfiConstants.ts
-var ACCESS_TOKEN_TTL = 10 * 60 * 1e3;
-var REFRESH_TOKEN_TTL = 7 * 24 * 60 * 60 * 1e3;
-
-// src/hooks/bitcoin/useRadfiAuth.ts
 var SESSION_KEY = (address) => `radfi_session_${address}`;
 function saveRadfiSession(address, session) {
   try {
@@ -241,16 +235,6 @@ function clearRadfiSession(address) {
   } catch {
   }
 }
-function isAccessTokenExpired(address) {
-  const session = loadRadfiSession(address);
-  if (!session) return true;
-  return Date.now() >= session.accessTokenExpiry;
-}
-function isRefreshTokenExpired(address) {
-  const session = loadRadfiSession(address);
-  if (!session) return true;
-  return Date.now() >= session.refreshTokenExpiry;
-}
 function useRadfiAuth(spokeProvider) {
   return useMutation({
     mutationFn: async () => {
@@ -266,27 +250,25 @@ function useRadfiAuth(spokeProvider) {
           accessToken,
           refreshToken,
           tradingAddress,
-          publicKey,
-          accessTokenExpiry: Date.now() + ACCESS_TOKEN_TTL,
-          refreshTokenExpiry: Date.now() + REFRESH_TOKEN_TTL
+          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) {
-          if (existingSession && !isRefreshTokenExpired(walletAddress)) {
+        if (isAlreadyRegistered && existingSession?.refreshToken) {
+          try {
             const refreshed = await spokeProvider.radfi.refreshAccessToken(existingSession.refreshToken);
             const session = {
               ...existingSession,
               accessToken: refreshed.accessToken,
-              refreshToken: refreshed.refreshToken,
-              accessTokenExpiry: Date.now() + ACCESS_TOKEN_TTL,
-              refreshTokenExpiry: Date.now() + REFRESH_TOKEN_TTL
+              refreshToken: refreshed.refreshToken
             };
-            spokeProvider.setRadfiAccessToken(refreshed.accessToken);
+            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."
@@ -297,7 +279,7 @@ function useRadfiAuth(spokeProvider) {
     }
   });
 }
-var POLL_INTERVAL = 3e4;
+var REFRESH_INTERVAL = 5 * 60 * 1e3;
 function useRadfiSession(spokeProvider) {
   const [walletAddress, setWalletAddress] = useState();
   const [isAuthed, setIsAuthed] = useState(false);
@@ -316,17 +298,15 @@ function useRadfiSession(spokeProvider) {
       const updated = {
         ...session,
         accessToken,
-        refreshToken,
-        accessTokenExpiry: Date.now() + ACCESS_TOKEN_TTL
-        // Keep the original refreshTokenExpiry — don't roll it forward on every silent refresh
+        refreshToken
       };
       saveRadfiSession(address, updated);
-      spokeProvider.setRadfiAccessToken(accessToken);
+      spokeProvider.setRadfiAccessToken(accessToken, refreshToken);
       setIsAuthed(true);
       setTradingAddress(updated.tradingAddress || void 0);
     } catch {
       clearRadfiSession(address);
-      spokeProvider.setRadfiAccessToken("");
+      spokeProvider.setRadfiAccessToken("", "");
       setIsAuthed(false);
       setTradingAddress(void 0);
     } finally {
@@ -335,39 +315,22 @@ function useRadfiSession(spokeProvider) {
   }, [spokeProvider]);
   useEffect(() => {
     if (!spokeProvider) return;
-    const fetchAndRestore = () => {
-      spokeProvider.walletProvider.getWalletAddress().then((addr) => {
-        setWalletAddress(addr);
-        const session = loadRadfiSession(addr);
-        if (!session || isRefreshTokenExpired(addr)) return;
-        if (!isAccessTokenExpired(addr)) {
-          spokeProvider.setRadfiAccessToken(session.accessToken);
-          setIsAuthed(true);
-          setTradingAddress(session.tradingAddress || void 0);
-        } else {
-          silentRefresh(addr);
-        }
-      }).catch(() => {
-      });
-    };
-    fetchAndRestore();
-    const id = setInterval(fetchAndRestore, 3e3);
-    return () => clearInterval(id);
+    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]);
   useEffect(() => {
     if (!walletAddress || !spokeProvider) return;
     const id = setInterval(() => {
-      if (isRefreshTokenExpired(walletAddress)) {
-        clearRadfiSession(walletAddress);
-        spokeProvider.setRadfiAccessToken("");
-        setIsAuthed(false);
-        setTradingAddress(void 0);
-        return;
-      }
-      if (isAccessTokenExpired(walletAddress)) {
-        silentRefresh(walletAddress);
-      }
-    }, POLL_INTERVAL);
+      silentRefresh(walletAddress);
+    }, REFRESH_INTERVAL);
     return () => clearInterval(id);
   }, [walletAddress, spokeProvider, silentRefresh]);
   const { mutateAsync: loginMutate, isPending: isLoginPending } = useRadfiAuth(spokeProvider);
@@ -466,6 +429,41 @@ function useRenewUtxos(spokeProvider) {
     }
   });
 }
+function useRadfiWithdraw(spokeProvider) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ amount, tokenId, withdrawTo }) => {
+      if (!spokeProvider) {
+        throw new Error("Bitcoin spoke provider not found");
+      }
+      const userAddress = await spokeProvider.walletProvider.getWalletAddress();
+      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 = 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 useMutation({
@@ -985,6 +983,54 @@ var useBackendUserIntents = ({
     }
   });
 };
+var useBackendSubmitSwapTx = (params) => {
+  const { sodax } = useSodaxContext();
+  const defaultMutationOptions = {
+    retry: 3
+  };
+  const mutationOptions = {
+    ...defaultMutationOptions,
+    ...params?.mutationOptions
+  };
+  return 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 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 = {
@@ -1774,11 +1820,623 @@ function useMigrationApprove(params, spokeProvider) {
     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 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 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 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 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 = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ params, spokeProvider }) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider is required");
+      }
+      if (!params) {
+        throw new Error("Deposit params are required");
+      }
+      const depositResult = await sodax.dex.assetService.deposit({
+        params,
+        spokeProvider
+      });
+      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 = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ params, spokeProvider }) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider is required");
+      }
+      const withdrawResult = await sodax.dex.assetService.withdraw({
+        params,
+        spokeProvider
+      });
+      if (!withdrawResult.ok) {
+        throw new Error(`Withdraw failed: ${withdrawResult.error.code}`);
+      }
+      return withdrawResult.value;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances"] });
+    }
+  });
+}
+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 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 = useQueryClient();
+  return 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] = useState("");
+  const [liquidityToken1Amount, setLiquidityToken1Amount] = useState("");
+  const [lastEditedToken, setLastEditedToken] = useState(null);
+  const { minPriceNum, maxPriceNum, isValidPriceRange } = 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 } = useMemo(() => {
+    if (!poolData || !isValidPriceRange) {
+      return {
+        tickLower: null,
+        tickUpper: null,
+        currentTick: null
+      };
+    }
+    try {
+      const lower = ClService.priceToTick(minPriceNum, poolData.token0, poolData.token1, poolData.tickSpacing);
+      const upper = ClService.priceToTick(maxPriceNum, poolData.token0, poolData.token1, poolData.tickSpacing);
+      return {
+        tickLower: lower,
+        tickUpper: upper,
+        currentTick: BigInt(poolData.currentTick)
+      };
+    } catch (err) {
+      console.error("Failed to calculate ticks:", err);
+      return {
+        tickLower: null,
+        tickUpper: null,
+        currentTick: null
+      };
+    }
+  }, [minPriceNum, maxPriceNum, poolData, isValidPriceRange]);
+  const handleToken0AmountChange = useCallback(
+    (value) => {
+      setLiquidityToken0Amount(value);
+      setLastEditedToken("token0");
+      if (!value || !poolData || !tickLower || !tickUpper || !currentTick) {
+        return;
+      }
+      const amount0 = Number.parseFloat(value);
+      if (amount0 <= 0 || !isValidPriceRange) {
+        return;
+      }
+      try {
+        const amount0BigInt = BigInt(Math.floor(amount0 * 10 ** poolData.token0.decimals));
+        const amount1BigInt = 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 = 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 = 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]
+  );
+  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 = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ params, spokeProvider }) => {
+      if (params.tokenId && params.isValidPosition) {
+        const increaseResult = await sodax.dex.clService.increaseLiquidity({
+          params: {
+            poolKey: params.poolKey,
+            tokenId: BigInt(params.tokenId),
+            tickLower: params.tickLower,
+            tickUpper: params.tickUpper,
+            liquidity: params.liquidity,
+            amount0Max: params.amount0Max,
+            amount1Max: params.amount1Max,
+            sqrtPriceX96: params.sqrtPriceX96
+          },
+          spokeProvider
+        });
+        if (!increaseResult.ok) {
+          throw new Error(`Increase liquidity failed: ${increaseResult.error?.code || "Unknown error"}`);
+        }
+        return increaseResult.value;
+      }
+      const supplyResult = await sodax.dex.clService.supplyLiquidity({
+        params: {
+          poolKey: params.poolKey,
+          tickLower: params.tickLower,
+          tickUpper: params.tickUpper,
+          liquidity: params.liquidity,
+          amount0Max: params.amount0Max,
+          amount1Max: params.amount1Max,
+          sqrtPriceX96: params.sqrtPriceX96
+        },
+        spokeProvider
+      });
+      if (!supplyResult.ok) {
+        throw new Error(`Supply liquidity failed: ${supplyResult.error?.code || "Unknown error"}`);
+      }
+      return supplyResult.value;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["dex", "poolBalances"] });
+      queryClient.invalidateQueries({ queryKey: ["dex", "positionInfo"] });
+    }
+  });
+}
+function useDecreaseLiquidity() {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ params, spokeProvider }) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider is required");
+      }
+      const decreaseResult = await sodax.dex.clService.decreaseLiquidity({
+        params,
+        spokeProvider
+      });
+      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,
+    amount: parseUnits(String(amount), token.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 = parseUnits(liquidityToken0Amount, poolData.token0.decimals);
+  const amount1BigInt = parseUnits(liquidityToken1Amount, poolData.token1.decimals);
+  const token0 = poolData.token0;
+  const token1 = poolData.token1;
+  const tickSpacing = poolData.tickSpacing;
+  const tickLower = ClService.priceToTick(minPriceNum, token0, token1, tickSpacing);
+  const tickUpper = ClService.priceToTick(maxPriceNum, token0, token1, tickSpacing);
+  const slippageMultiplier = BigInt(Math.floor((100 - slippage) * 100));
+  const amount0ForLiquidity = amount0BigInt * slippageMultiplier / 10000n;
+  const amount1ForLiquidity = amount1BigInt * slippageMultiplier / 10000n;
+  const liquidity = ClService.calculateLiquidityFromAmounts(
+    amount0ForLiquidity,
+    amount1ForLiquidity,
+    tickLower,
+    tickUpper,
+    BigInt(poolData.currentTick)
+  );
+  const tokenId = positionId ? BigInt(positionId) : void 0;
+  return {
+    poolKey,
+    tickLower,
+    tickUpper,
+    liquidity,
+    amount0Max: amount0BigInt,
+    amount1Max: amount1BigInt,
+    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: parseUnits(String(amount), token.decimals),
+    poolToken: token.address,
+    dst
+  };
+}
+
+// src/hooks/dex/useCreateDepositParams.ts
+function useCreateDepositParams({
+  tokenIndex,
+  amount,
+  poolData,
+  poolSpokeAssets
+}) {
+  return 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 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 useMemo(() => {
+    return createDecreaseLiquidityParamsProps({ poolKey, tokenId, percentage, positionInfo, slippageTolerance });
+  }, [poolKey, tokenId, percentage, positionInfo, slippageTolerance]);
+}
+function useCreateWithdrawParams({
+  tokenIndex,
+  amount,
+  poolData,
+  poolSpokeAssets,
+  dst
+}) {
+  return 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 = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ params, spokeProvider }) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider is required");
+      }
+      const result = await sodax.dex.clService.claimRewards({
+        params,
+        spokeProvider
+      });
+      if (!result.ok) {
+        throw new Error(`Claim rewards failed: ${result.error?.code || "Unknown error"}`);
+      }
+      return result.value;
+    },
+    onSuccess: (_, { params, spokeProvider }) => {
+      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 Sodax(config);
   return /* @__PURE__ */ React.createElement(SodaxContext.Provider, { value: { sodax, testnet, rpcConfig } }, children);
 };
 
-export { MIGRATION_MODE_BNUSD, MIGRATION_MODE_ICX_SODA, SodaxProvider, clearRadfiSession, isAccessTokenExpired, isRefreshTokenExpired, loadRadfiSession, saveRadfiSession, useAToken, useATokensBalances, useBackendAllMoneyMarketAssets, useBackendAllMoneyMarketBorrowers, useBackendIntentByHash, useBackendIntentByTxHash, useBackendMoneyMarketAsset, useBackendMoneyMarketAssetBorrowers, useBackendMoneyMarketAssetSuppliers, useBackendMoneyMarketPosition, useBackendOrderbook, useBackendUserIntents, useBitcoinBalance, useBorrow, useBridge, useBridgeAllowance, useBridgeApprove, useCancelLimitOrder, useCancelSwap, useCancelUnstake, useClaim, useConvertedAssets, useCreateLimitOrder, useDeriveUserWalletAddress, useEstimateGas, useExpiredUtxos, useFundTradingWallet, useGetBridgeableAmount, useGetBridgeableTokens, useGetUserHubWalletAddress, useHubProvider, useInstantUnstake, useInstantUnstakeAllowance, useInstantUnstakeApprove, useInstantUnstakeRatio, useMMAllowance, useMMApprove, useMigrate, useMigrationAllowance, useMigrationApprove, useQuote, useRadfiAuth, useRadfiSession, useRenewUtxos, useRepay, useRequestTrustline, useReservesData, useReservesUsdFormat, useSodaxContext, useSpokeProvider, useStake, useStakeAllowance, useStakeApprove, useStakeRatio, useStakingConfig, useStakingInfo, useStatus, useStellarTrustlineCheck, useSupply, useSwap, useSwapAllowance, useSwapApprove, useTradingWalletBalance, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserFormattedSummary, useUserReservesData, useWithdraw };
+export { MIGRATION_MODE_BNUSD, MIGRATION_MODE_ICX_SODA, SodaxProvider, clearRadfiSession, createDecreaseLiquidityParamsProps, createDepositParamsProps, createSupplyLiquidityParamsProps, createWithdrawParamsProps, loadRadfiSession, saveRadfiSession, useAToken, useATokensBalances, useBackendAllMoneyMarketAssets, useBackendAllMoneyMarketBorrowers, useBackendIntentByHash, useBackendIntentByTxHash, useBackendMoneyMarketAsset, useBackendMoneyMarketAssetBorrowers, useBackendMoneyMarketAssetSuppliers, useBackendMoneyMarketPosition, useBackendOrderbook, useBackendSubmitSwapTx, useBackendSubmitSwapTxStatus, useBackendUserIntents, useBitcoinBalance, useBorrow, useBridge, useBridgeAllowance, useBridgeApprove, useCancelLimitOrder, useCancelSwap, useCancelUnstake, useClaim, useClaimRewards, useConvertedAssets, useCreateDecreaseLiquidityParams, useCreateDepositParams, useCreateLimitOrder, useCreateSupplyLiquidityParams, useCreateWithdrawParams, useDecreaseLiquidity, useDeriveUserWalletAddress, useDexAllowance, useDexApprove, useDexDeposit, useDexWithdraw, useEstimateGas, useExpiredUtxos, useFundTradingWallet, useGetBridgeableAmount, useGetBridgeableTokens, useGetUserHubWalletAddress, useHubProvider, useInstantUnstake, useInstantUnstakeAllowance, useInstantUnstakeApprove, useInstantUnstakeRatio, useLiquidityAmounts, useMMAllowance, useMMApprove, useMigrate, useMigrationAllowance, useMigrationApprove, usePoolBalances, usePoolData, usePools, usePositionInfo, useQuote, useRadfiAuth, useRadfiSession, useRadfiWithdraw, useRenewUtxos, useRepay, useRequestTrustline, useReservesData, useReservesUsdFormat, useSodaxContext, useSpokeProvider, useStake, useStakeAllowance, useStakeApprove, useStakeRatio, useStakingConfig, useStakingInfo, useStatus, useStellarTrustlineCheck, useSupply, useSupplyLiquidity, useSwap, useSwapAllowance, useSwapApprove, useTradingWalletBalance, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserFormattedSummary, useUserReservesData, useWithdraw };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map