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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sodax/dapp-kit",
   "license": "MIT",
-  "version": "1.3.1-beta-rc3",
+  "version": "1.3.1-beta",
   "description": "dapp-kit of New World",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,8 +16,8 @@
   },
   "dependencies": {
     "viem": "2.29.2",
-    "@sodax/sdk": "1.3.1-beta-rc3",
-    "@sodax/types": "1.3.1-beta-rc3"
+    "@sodax/sdk": "1.3.1-beta",
+    "@sodax/types": "1.3.1-beta"
   },
   "devDependencies": {
     "@types/react": "19.0.8",

package/src/hooks/bitcoin/index.ts

@@ -5,3 +5,4 @@ export * from './useBitcoinBalance';
 export * from './useTradingWalletBalance';
 export * from './useExpiredUtxos';
 export * from './useRenewUtxos';
+export * from './useRadfiWithdraw';

package/src/hooks/bitcoin/useRadfiAuth.ts

@@ -1,14 +1,11 @@
 import type { BitcoinSpokeProvider } from '@sodax/sdk';
 import { useMutation, type UseMutationResult } from '@tanstack/react-query';
-import { ACCESS_TOKEN_TTL, REFRESH_TOKEN_TTL } from './radfiConstants';
 
 export type RadfiSession = {
   accessToken: string;
   refreshToken: string;
   tradingAddress: string;
   publicKey: string;
-  accessTokenExpiry: number;
-  refreshTokenExpiry: number;
 };
 
 type RadfiAuthResult = {
@@ -41,21 +38,9 @@ export function clearRadfiSession(address: string): void {
   } catch {}
 }
 
-export function isAccessTokenExpired(address: string): boolean {
-  const session = loadRadfiSession(address);
-  if (!session) return true;
-  return Date.now() >= session.accessTokenExpiry;
-}
-
-export function isRefreshTokenExpired(address: string): boolean {
-  const session = loadRadfiSession(address);
-  if (!session) return true;
-  return Date.now() >= session.refreshTokenExpiry;
-}
-
 /**
  * Hook to authenticate with Radfi using BIP322 message signing.
- * Saves full session (accessToken, refreshToken, tradingAddress, expiry) to localStorage.
+ * Saves session (accessToken, refreshToken, tradingAddress, publicKey) to localStorage.
  */
 export function useRadfiAuth(
   spokeProvider: BitcoinSpokeProvider | undefined,
@@ -78,8 +63,6 @@ export function useRadfiAuth(
           refreshToken,
           tradingAddress,
           publicKey,
-          accessTokenExpiry: Date.now() + ACCESS_TOKEN_TTL,
-          refreshTokenExpiry: Date.now() + REFRESH_TOKEN_TTL,
         };
 
         saveRadfiSession(walletAddress, session);
@@ -92,23 +75,22 @@ export function useRadfiAuth(
           err instanceof Error &&
           (err.message.includes('duplicatedPubKey') || err.message.includes('4008'));
 
-        if (isAlreadyRegistered) {
-          if (existingSession && !isRefreshTokenExpired(walletAddress)) {
-            // Try silent refresh
+        if (isAlreadyRegistered && existingSession?.refreshToken) {
+          try {
             const refreshed = await spokeProvider.radfi.refreshAccessToken(existingSession.refreshToken);
             const session: RadfiSession = {
               ...existingSession,
               accessToken: refreshed.accessToken,
               refreshToken: refreshed.refreshToken,
-              accessTokenExpiry: Date.now() + ACCESS_TOKEN_TTL,
-              refreshTokenExpiry: Date.now() + REFRESH_TOKEN_TTL,
             };
-            spokeProvider.setRadfiAccessToken(refreshed.accessToken);
+            spokeProvider.setRadfiAccessToken(refreshed.accessToken, refreshed.refreshToken);
             saveRadfiSession(walletAddress, session);
             return { accessToken: refreshed.accessToken, refreshToken: refreshed.refreshToken, tradingAddress: existingSession.tradingAddress };
+          } catch {
+            // Refresh also failed — clear stale session and guide user
+            clearRadfiSession(walletAddress);
           }
 
-          // No valid session to refresh — guide the user
           throw new Error(
             'This wallet is already registered with Radfi from another session. ' +
             'Please clear your browser storage for this site and try again, ' +

package/src/hooks/bitcoin/useRadfiSession.ts

@@ -5,13 +5,10 @@ import {
   loadRadfiSession,
   saveRadfiSession,
   clearRadfiSession,
-  isAccessTokenExpired,
-  isRefreshTokenExpired,
   type RadfiSession,
 } from './useRadfiAuth';
 
-import { ACCESS_TOKEN_TTL } from './radfiConstants';
-const POLL_INTERVAL = 30_000; // 30 s — access tokens expire every 10 min, no need to poll faster
+const REFRESH_INTERVAL = 5 * 60 * 1000; // 5 min — refresh before access token expires (10 min TTL)
 
 export type UseRadfiSessionReturn = {
   walletAddress: string | undefined;
@@ -23,8 +20,9 @@ export type UseRadfiSessionReturn = {
 
 /**
  * Manages the full Radfi session lifecycle:
- * - Restores session from localStorage on mount
- * - Polls every 2s: silently refreshes accessToken before expiry, resets auth when refreshToken expires
+ * - On mount / wallet switch: refreshes token to validate session
+ * - Single interval (~5 min): refreshes access token. If refresh fails → clears session, isAuthed=false
+ * - ensureRadfiAccessToken (SDK layer) acts as safety net before swap/bridge
  * - Exposes login() and isAuthed for UI
  */
 export function useRadfiSession(
@@ -52,17 +50,15 @@ export function useRadfiSession(
         ...session,
         accessToken,
         refreshToken,
-        accessTokenExpiry: Date.now() + ACCESS_TOKEN_TTL,
-        // Keep the original refreshTokenExpiry — don't roll it forward on every silent refresh
       };
 
       saveRadfiSession(address, updated);
-      spokeProvider.setRadfiAccessToken(accessToken);
+      spokeProvider.setRadfiAccessToken(accessToken, refreshToken);
       setIsAuthed(true);
       setTradingAddress(updated.tradingAddress || undefined);
     } catch {
       clearRadfiSession(address);
-      spokeProvider.setRadfiAccessToken('');
+      spokeProvider.setRadfiAccessToken('', '');
       setIsAuthed(false);
       setTradingAddress(undefined);
     } finally {
@@ -70,52 +66,34 @@ export function useRadfiSession(
     }
   }, [spokeProvider]);
 
-  // ── Poll wallet address + restore session eagerly ────────────────────────
+  // ── On mount / wallet switch: reset state + refresh to validate session ──
   useEffect(() => {
     if (!spokeProvider) return;
 
-    const fetchAndRestore = () => {
-      spokeProvider.walletProvider.getWalletAddress()
-        .then((addr) => {
-          setWalletAddress(addr);
-          // Eagerly restore session in the same tick to avoid extra render cycle
-          const session = loadRadfiSession(addr);
-          if (!session || isRefreshTokenExpired(addr)) return;
-
-          if (!isAccessTokenExpired(addr)) {
-            spokeProvider.setRadfiAccessToken(session.accessToken);
-            setIsAuthed(true);
-            setTradingAddress(session.tradingAddress || undefined);
-          } else {
-            // Access token expired but refresh valid — trigger silent refresh
-            silentRefresh(addr);
-          }
-        })
-        .catch(() => {});
-    };
-
-    fetchAndRestore();
-    const id = setInterval(fetchAndRestore, 3000);
-    return () => clearInterval(id);
+    // Reset state immediately to avoid stale data from previous wallet
+    setIsAuthed(false);
+    setTradingAddress(undefined);
+    setWalletAddress(undefined);
+
+    spokeProvider.walletProvider.getWalletAddress()
+      .then((addr) => {
+        setWalletAddress(addr);
+        const session = loadRadfiSession(addr);
+        if (!session?.refreshToken) return;
+
+        // Always refresh on mount to validate the session is actually valid
+        silentRefresh(addr);
+      })
+      .catch(() => {});
   }, [spokeProvider, silentRefresh]);
 
-  // ── Polling: check expiry every 30s ──────────────────────────────────────
+  // ── Interval: refresh token every 5 min to keep access token fresh ──────
   useEffect(() => {
     if (!walletAddress || !spokeProvider) return;
 
     const id = setInterval(() => {
-      if (isRefreshTokenExpired(walletAddress)) {
-        clearRadfiSession(walletAddress);
-        spokeProvider.setRadfiAccessToken('');
-        setIsAuthed(false);
-        setTradingAddress(undefined);
-        return;
-      }
-
-      if (isAccessTokenExpired(walletAddress)) {
-        silentRefresh(walletAddress);
-      }
-    }, POLL_INTERVAL);
+      silentRefresh(walletAddress);
+    }, REFRESH_INTERVAL);
 
     return () => clearInterval(id);
   }, [walletAddress, spokeProvider, silentRefresh]);

package/src/hooks/bitcoin/useRadfiWithdraw.ts

@@ -0,0 +1,85 @@
+import { normalizePsbtToBase64, type BitcoinSpokeProvider } from '@sodax/sdk';
+import { useMutation, useQueryClient, type UseMutationResult } from '@tanstack/react-query';
+import { loadRadfiSession } from './useRadfiAuth';
+
+type WithdrawToUserParams = {
+  amount: string;
+  tokenId: string;
+  withdrawTo: string;
+};
+
+type WithdrawResult = {
+  txId: string;
+  fee: number;
+};
+
+/**
+ * Hook to withdraw BTC from Radfi trading wallet to user's personal wallet.
+ *
+ * Flow:
+ * 1. Build withdraw transaction via Radfi API (returns unsigned PSBT)
+ * 2. User signs the PSBT with their wallet
+ * 3. Submit signed PSBT back to Radfi for co-signing and broadcasting
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync: withdraw, isPending } = useRadfiWithdraw(spokeProvider);
+ *
+ * const handleWithdraw = async () => {
+ *   const result = await withdraw({
+ *     amount: '10000',
+ *     tokenId: '0:0',
+ *     withdrawTo: 'bc1q...', // user's segwit address
+ *   });
+ *   console.log('Withdrawn:', result.txId);
+ * };
+ * ```
+ */
+export function useRadfiWithdraw(
+  spokeProvider: BitcoinSpokeProvider | undefined,
+): UseMutationResult<WithdrawResult, Error, WithdrawToUserParams> {
+  const queryClient = useQueryClient();
+
+  return useMutation<WithdrawResult, Error, WithdrawToUserParams>({
+    mutationFn: async ({ amount, tokenId, withdrawTo }: WithdrawToUserParams) => {
+      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.');
+      }
+
+      // Step 1: Build the withdraw transaction
+      const buildResult = await spokeProvider.radfi.withdrawToUser(
+        { userAddress, amount, tokenId, withdrawTo },
+        accessToken,
+      );
+
+      // Step 2: Sign the PSBT with user's wallet
+      const signedTx = await spokeProvider.walletProvider.signTransaction(
+        buildResult.base64Psbt,
+        false,
+      );
+
+      const signedBase64Tx = normalizePsbtToBase64(signedTx);
+
+      // Step 3: Submit to Radfi for co-signing and broadcasting
+      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'] });
+    },
+  });
+}

package/src/hooks/bitcoin/useRenewUtxos.ts

@@ -19,7 +19,7 @@ type RenewUtxosParams = {
  * const { mutateAsync: renewUtxos, isPending } = useRenewUtxos(spokeProvider);
  *
  * const handleRenew = async (expiredUtxos: RadfiUtxo[]) => {
- *   const txIdVouts = expiredUtxos.map(u => `${u.txId}:${u.vout}`);
+ *   const txIdVouts = expiredUtxos.map(u => u.txidVout);
  *   const txId = await renewUtxos({ txIdVouts });
  *   console.log('Renewed:', txId);
  * };

package/src/hooks/dex/index.ts

@@ -0,0 +1,16 @@
+export * from './usePools';
+export * from './usePoolData';
+export * from './usePoolBalances';
+export * from './usePositionInfo';
+export * from './useDexDeposit';
+export * from './useDexWithdraw';
+export * from './useDexAllowance';
+export * from './useDexApprove';
+export * from './useLiquidityAmounts';
+export * from './useSupplyLiquidity';
+export * from './useDecreaseLiquidity';
+export * from './useCreateDepositParams';
+export * from './useCreateSupplyLiquidityParams';
+export * from './useCreateDecreaseLiquidityParams';
+export * from './useCreateWithdrawParams';
+export * from './useClaimRewards';

package/src/hooks/dex/useClaimRewards.ts

@@ -0,0 +1,68 @@
+import type {
+  ConcentratedLiquidityClaimRewardsParams,
+  ConcentratedLiquidityError,
+  ConcentratedLiquidityErrorCode,
+  SpokeProvider,
+  SpokeTxHash,
+  HubTxHash,
+} from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+import { useMutation, type UseMutationResult, useQueryClient } from '@tanstack/react-query';
+
+export type UseClaimRewardsParams = {
+  params: ConcentratedLiquidityClaimRewardsParams;
+  spokeProvider: SpokeProvider;
+};
+
+/**
+ * React hook for creating a mutation to claim DEX rewards for a concentrated liquidity position.
+ *
+ * @returns {UseMutationResult<[SpokeTxHash, HubTxHash], ConcentratedLiquidityError<ConcentratedLiquidityErrorCode>, UseClaimRewardsParams>}
+ *   Returns a react-query mutation result object:
+ *   - On success: resolves to a tuple `[SpokeTxHash, HubTxHash]`.
+ *   - On error: the error is of type `ConcentratedLiquidityError<ConcentratedLiquidityErrorCode>`.
+ *   - The mutation function expects an argument of type {@link UseClaimRewardsParams}
+ *     containing `params` (the claim parameters) and `spokeProvider` (the target provider).
+ *   - On mutation success, invalidates the queries `'dex/poolBalances'` and `'dex/positionInfo'`.
+ *
+ * @example
+ * const claimRewardsMutation = useClaimRewards();
+ * claimRewardsMutation.mutateAsync({
+ *   params: { poolKey, tokenId, tickLower, tickUpper },
+ *   spokeProvider,
+ * });
+ */
+export function useClaimRewards(): UseMutationResult<
+  [SpokeTxHash, HubTxHash],
+  ConcentratedLiquidityError<ConcentratedLiquidityErrorCode>,
+  UseClaimRewardsParams
+> {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({ params, spokeProvider }: UseClaimRewardsParams) => {
+      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 }) => {
+      // Invalidate relevant queries
+      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] });
+    },
+  });
+}

package/src/hooks/dex/useCreateDecreaseLiquidityParams.ts

@@ -0,0 +1,41 @@
+import { createDecreaseLiquidityParamsProps } from '@/utils/dex-utils';
+import type { ClPositionInfo, ConcentratedLiquidityDecreaseLiquidityParams, PoolKey } from '@sodax/sdk';
+import { useMemo } from 'react';
+
+export type UseCreateDecreaseLiquidityParamsProps = {
+  poolKey: PoolKey;
+  tokenId: string | bigint;
+  percentage: string | number;
+  positionInfo: ClPositionInfo;
+  slippageTolerance: string | number;
+};
+
+
+/**
+ * React hook to create the decrease liquidity parameters for a given pool and position.
+ *
+ * Purpose:
+ *   - Provides a hook which memoizes the decrease liquidity parameters for a given pool and position.
+ *
+ * Usage:
+ *   - Call the function with the pool key, token ID, percentage, position info, and slippage tolerance to create the decrease liquidity parameters.
+ *
+ * Params:
+ * @param poolKey - The pool key of the pool to decrease the liquidity from.
+ * @param tokenId - The token ID of the position to decrease the liquidity from.
+ * @param percentage - The percentage of liquidity to decrease.
+ * @param positionInfo - The position info of the position to decrease the liquidity from.
+ * @param slippageTolerance - The slippage tolerance to use for the decrease.
+ * @returns The decrease liquidity parameters.
+ */
+export function useCreateDecreaseLiquidityParams({
+  poolKey,
+  tokenId,
+  percentage,
+  positionInfo,
+  slippageTolerance,
+}: UseCreateDecreaseLiquidityParamsProps): ConcentratedLiquidityDecreaseLiquidityParams {
+  return useMemo<ConcentratedLiquidityDecreaseLiquidityParams>(() => {
+    return createDecreaseLiquidityParamsProps({ poolKey, tokenId, percentage, positionInfo, slippageTolerance });
+  }, [poolKey, tokenId, percentage, positionInfo, slippageTolerance]);
+}

package/src/hooks/dex/useCreateDepositParams.ts

@@ -0,0 +1,43 @@
+import { useMemo } from 'react';
+import type { CreateAssetDepositParams, PoolData, PoolSpokeAssets } from '@sodax/sdk';
+import { createDepositParamsProps } from '@/utils/dex-utils';
+
+export type UseCreateDepositParamsProps = {
+  tokenIndex: 0 | 1;
+  amount: string | number;
+  poolData: PoolData;
+  poolSpokeAssets: PoolSpokeAssets;
+};
+
+
+/**
+ * React hook to create the deposit parameters for a given pool and token.
+ *
+ * Purpose:
+ *   - Provides a hook which memoizes the deposit parameters for a given pool and token.
+ *
+ * Usage:
+ *   - Call the function with the token index, amount, pool data, pool key, and spoke provider to create the deposit parameters.
+ *
+ * Params:
+ * @param tokenIndex - The index of the token to deposit.
+ * @param amount - The amount of the token to deposit.
+ * @param poolData - The pool data of the pool to deposit to.
+ * @param poolKey - The pool key of the pool to deposit to.
+ * @param spokeProvider - The spoke provider to use for the deposit.
+ * @returns The deposit parameters or undefined if the pool key, spoke provider, or amount is not set.
+ */
+export function useCreateDepositParams({
+  tokenIndex,
+  amount,
+  poolData,
+  poolSpokeAssets,
+}: UseCreateDepositParamsProps): CreateAssetDepositParams | undefined {
+  return useMemo<CreateAssetDepositParams | undefined>(() => {
+    if (!amount || Number.parseFloat(String(amount)) <= 0) {
+      return undefined;
+    }
+
+    return createDepositParamsProps({ tokenIndex, amount, poolData, poolSpokeAssets });
+  }, [tokenIndex, amount, poolData, poolSpokeAssets]);
+}

package/src/hooks/dex/useCreateSupplyLiquidityParams.ts

@@ -0,0 +1,84 @@
+import { createSupplyLiquidityParamsProps } from '@/utils/dex-utils';
+import type {
+  ConcentratedLiquiditySupplyParams,
+  ConcentratedLiquidityIncreaseLiquidityParams,
+  PoolData,
+  PoolKey,
+} from '@sodax/sdk';
+import { useMemo } from 'react';
+
+export type UseCreateSupplyLiquidityParamsProps = {
+  poolData: PoolData;
+  poolKey: PoolKey;
+  minPrice: string;
+  maxPrice: string;
+  liquidityToken0Amount: string;
+  liquidityToken1Amount: string;
+  slippageTolerance: string | number;
+  positionId?: string | null;
+  isValidPosition?: boolean;
+};
+
+export type UseCreateSupplyLiquidityParamsResult = ConcentratedLiquiditySupplyParams &
+  Omit<ConcentratedLiquidityIncreaseLiquidityParams, 'tokenId'> & {
+    tokenId?: string | bigint;
+    positionId?: string | null;
+    isValidPosition?: boolean;
+  };
+
+/**
+ * React hook to create the supply liquidity parameters for a given pool.
+ *
+ * Purpose:
+ *   - Provides a hook which memoizes the supply liquidity parameters for a given pool.
+ *
+ * Usage:
+ *   - Call the function with the pool data, pool key, minimum price, maximum price, liquidity token0 amount, liquidity token1 amount, slippage tolerance, position id, and validity of the position to create the supply liquidity parameters.
+ *
+ * Params:
+ * @param poolData - The pool data of the pool to supply liquidity to.
+ * @param poolKey - The pool key of the pool to supply liquidity to.
+ * @param minPrice - The minimum price of the liquidity to supply.
+ * @param maxPrice - The maximum price of the liquidity to supply.
+ * @param liquidityToken0Amount - The amount of the token0 to supply.
+ * @param liquidityToken1Amount - The amount of the token1 to supply.
+ * @param slippageTolerance - The slippage tolerance to use for the supply.
+ * @param positionId - The position id of the position to supply liquidity to.
+ * @param isValidPosition - Whether the position is valid.
+ * @returns The supply liquidity parameters.
+ */
+export function useCreateSupplyLiquidityParams({
+  poolData,
+  poolKey,
+  minPrice,
+  maxPrice,
+  liquidityToken0Amount,
+  liquidityToken1Amount,
+  slippageTolerance,
+  positionId,
+  isValidPosition,
+}: UseCreateSupplyLiquidityParamsProps): UseCreateSupplyLiquidityParamsResult {
+  return useMemo<UseCreateSupplyLiquidityParamsResult>(() => {
+    return createSupplyLiquidityParamsProps({
+      poolData,
+      poolKey,
+      minPrice,
+      maxPrice,
+      liquidityToken0Amount,
+      liquidityToken1Amount,
+      slippageTolerance,
+      positionId,
+      isValidPosition,
+    });
+  }, [
+    minPrice,
+    maxPrice,
+    liquidityToken0Amount,
+    liquidityToken1Amount,
+    slippageTolerance,
+    poolData,
+    poolKey,
+    positionId,
+    isValidPosition,
+  ]);
+}

package/src/hooks/dex/useCreateWithdrawParams.ts

@@ -0,0 +1,44 @@
+import type { CreateAssetWithdrawParams, DestinationParamsType, PoolData, PoolSpokeAssets } from '@sodax/sdk';
+import { useMemo } from 'react';
+import { createWithdrawParamsProps } from '@/utils/dex-utils';
+
+export type UseCreateWithdrawParamsProps = {
+  tokenIndex: 0 | 1;
+  amount: string | number;
+  poolData: PoolData;
+  poolSpokeAssets: PoolSpokeAssets;
+  dst?: DestinationParamsType;
+};
+
+/**
+ * React hook to create the withdrawal parameters for a given pool and token.
+ *
+ * Purpose:
+ *   - Provides a hook which memoizes the withdrawal parameters for a given pool and token.
+ *
+ * Usage:
+ *   - Call the function with the token index, amount, pool data, pool spoke assets, and destination parameters to create the withdrawal parameters.
+ *
+ * Params:
+ * @param tokenIndex - The index of the token to withdraw.
+ * @param amount - The amount of the token to withdraw.
+ * @param poolData - The pool data of the pool to withdraw from.
+ * @param poolSpokeAssets - The pool spoke assets of the pool to withdraw from.
+ * @param dst - The destination parameters for the withdrawal.
+ * @returns The withdrawal parameters or undefined if the amount is not set.
+ */
+export function useCreateWithdrawParams({
+  tokenIndex,
+  amount,
+  poolData,
+  poolSpokeAssets,
+  dst,
+}: UseCreateWithdrawParamsProps): CreateAssetWithdrawParams | undefined {
+  return useMemo<CreateAssetWithdrawParams | undefined>(() => {
+    if (!amount || Number.parseFloat(String(amount)) <= 0) {
+      return undefined;
+    }
+
+    return createWithdrawParamsProps({ tokenIndex, amount, poolData, poolSpokeAssets, dst });
+  }, [tokenIndex, amount, poolData, poolSpokeAssets, dst]);
+}