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

package/src/hooks/bridge/useBridgeApprove.ts

@@ -1,68 +1,43 @@
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type { CreateBridgeIntentParams, SpokeProvider } from '@sodax/sdk';
-import { useMutation, useQueryClient } from '@tanstack/react-query';
+// packages/dapp-kit/src/hooks/bridge/useBridgeApprove.ts
+import type { BridgeParams, SpokeChainKey, TxReturnType } from '@sodax/sdk';
+import { useQueryClient } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
 
-interface UseBridgeApproveReturn {
-  approve: (params: CreateBridgeIntentParams) => Promise<boolean>;
-  isLoading: boolean;
-  error: Error | null;
-  resetError: () => void;
-}
+/**
+ * Mutation variables for {@link useBridgeApprove}. Generic over `K extends SpokeChainKey`
+ * (defaults to the full union). Sophisticated callers can lock K at the hook call site to narrow
+ * the `walletProvider` and `params.srcChainKey` types.
+ */
+export type UseBridgeApproveVars<K extends SpokeChainKey = SpokeChainKey> = Omit<BridgeParams<K, false>, 'raw'>;
 
 /**
- * Hook for approving token spending for bridge actions
- * @param spokeProvider The spoke provider instance for the chain
- * @returns Object containing approve function, loading state, error state and reset function
- * @example
- * ```tsx
- * const { approve, isLoading, error } = useBridgeApprove(spokeProvider);
+ * React hook for approving ERC-20 token spending (or trustline establishment) for a bridge
+ * action.
  *
- * // Approve tokens for bridge action
- * await approve({
- *   srcChainId: '0x2105.base',
- *   srcAsset: '0x...',
- *   amount: 1000n,
- *   dstChainId: '0x89.polygon',
- *   dstAsset: '0x...',
- *   recipient: '0x...'
- * });
- * ```
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped tx return value on success. Invalidates all
+ * `['bridge', 'allowance', ...]` queries so any pending allowance check refreshes.
  */
-export function useBridgeApprove(spokeProvider: SpokeProvider | undefined): UseBridgeApproveReturn {
+export function useBridgeApprove<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxReturnType<K, false>, UseBridgeApproveVars<K>> = {}): SafeUseMutationResult<
+  TxReturnType<K, false>,
+  Error,
+  UseBridgeApproveVars<K>
+> {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
 
-  const {
-    mutateAsync: approve,
-    isPending,
-    error,
-    reset: resetError,
-  } = useMutation({
-    mutationFn: async (params: CreateBridgeIntentParams) => {
-      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) => {
-      // Invalidate allowance query to refetch the new allowance
-      queryClient.invalidateQueries({ queryKey: ['bridge-allowance', params] });
+  return useSafeMutation<TxReturnType<K, false>, Error, UseBridgeApproveVars<K>>({
+    mutationKey: ['bridge', 'approve'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.bridge.approve({ ...vars, raw: false } as BridgeParams<K, false>)),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ['bridge', 'allowance'] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     },
   });
-
-  return {
-    approve,
-    isLoading: isPending,
-    error: error,
-    resetError,
-  };
 }

package/src/hooks/bridge/useGetBridgeableAmount.ts

@@ -1,51 +1,37 @@
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
 import type { BridgeLimit, XToken } from '@sodax/sdk';
+import type { ReadHookParams } from '../shared/types.js';
 
-/**
- * Hook for getting the amount available to be bridged.
- *
- * This hook is used to check if a target chain has enough balance to bridge when bridging.
- * It automatically queries and tracks the available amount to be bridged.
- *
- * @param {SpokeChainId | undefined} chainId - The chain ID to get the balance for
- * @param {string | undefined} token - The token address to get the balance for
- *
- * @returns {UseQueryResult<BridgeLimit, Error>} A React Query result containing:
- *   - data: Data about available amount to be bridged
- *   - error: Any error that occurred during the check
- *
- * @example
- * ```typescript
- * const { data: balance, isLoading } = useSpokeAssetManagerTokenBalance(chainId, tokenAddress);
- *
- * if (balance) {
- *   console.log('Asset manager token balance:', balance.toString());
- * }
- * ```
- */
-export function useGetBridgeableAmount(
-  from: XToken | undefined,
-  to: XToken | undefined,
-): UseQueryResult<BridgeLimit, Error> {
+export type UseGetBridgeableAmountParams = ReadHookParams<
+  BridgeLimit,
+  {
+    from: XToken | undefined;
+    to: XToken | undefined;
+  }
+>;
+
+export function useGetBridgeableAmount({
+  params,
+  queryOptions,
+}: UseGetBridgeableAmountParams = {}): UseQueryResult<BridgeLimit, Error> {
   const { sodax } = useSodaxContext();
+  const from = params?.from;
+  const to = params?.to;
 
-  return useQuery({
-    queryKey: ['spoke-asset-manager-token-balance', from, to],
+  return useQuery<BridgeLimit, Error>({
+    queryKey: ['bridge', 'bridgeableAmount', from, to],
     queryFn: async () => {
       if (!from || !to) {
-        return { amount: 0n, decimals: 0, type: 'DEPOSIT_LIMIT' } as const;
+        throw new Error('from and to tokens are required');
       }
-
       const result = await sodax.bridge.getBridgeableAmount(from, to);
-
-      if (result.ok) {
-        return result.value;
+      if (!result.ok) {
+        throw result.error;
       }
-
-      console.error('Error getting bridgeable amount:', result.error);
-      return { amount: 0n, decimals: 0, type: 'DEPOSIT_LIMIT' } as const;
+      return result.value;
     },
     enabled: !!from && !!to,
+    ...queryOptions,
   });
 }

package/src/hooks/bridge/useGetBridgeableTokens.ts

@@ -1,62 +1,39 @@
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
-import type { XToken, SpokeChainId } from '@sodax/sdk';
-import { useSodaxContext } from '../shared';
+import type { XToken, SpokeChainKey } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/index.js';
+import type { ReadHookParams } from '../shared/types.js';
 
-/**
-/**
- * Hook for retrieving all bridgeable tokens from a source token on one chain to a destination chain.
- *
- * This hook queries and tracks the set of tokens on the destination chain that can be bridged to,
- * given a source chain, destination chain, and source token address.
- *
- * @param {SpokeChainId | undefined} from - The source chain ID
- * @param {SpokeChainId | undefined} to - The destination chain ID
- * @param {string | undefined} token - The source token address
- *
- * @returns {UseQueryResult<XToken[], Error>} A React Query result containing:
- *   - data: Array of bridgeable tokens (XToken[]) on the destination chain
- *   - error: Any error that occurred during the query
- *
- *
- * @example
- * ```typescript
- * const { data: bridgeableTokens, isLoading } = useGetBridgeableTokens(
- *   fromChainId,
- *   toChainId,
- *   fromTokenAddress
- * );
- *
- * if (bridgeableTokens && bridgeableTokens.length > 0) {
- *   bridgeableTokens.forEach(token => {
- *     console.log(`Bridgeable token: ${token.symbol} (${token.address}) on chain ${token.xChainId}`);
- *   });
- * } else {
- *   console.log('No bridgeable tokens found for the selected route.');
- * }
- * ```
- */
-export function useGetBridgeableTokens(
-  from: SpokeChainId | undefined,
-  to: SpokeChainId | undefined,
-  token: string | undefined,
-): UseQueryResult<XToken[], Error> {
+export type UseGetBridgeableTokensParams = ReadHookParams<
+  XToken[],
+  {
+    from: SpokeChainKey | undefined;
+    to: SpokeChainKey | undefined;
+    token: string | undefined;
+  }
+>;
+
+export function useGetBridgeableTokens({
+  params,
+  queryOptions,
+}: UseGetBridgeableTokensParams = {}): UseQueryResult<XToken[], Error> {
   const { sodax } = useSodaxContext();
+  const from = params?.from;
+  const to = params?.to;
+  const token = params?.token;
 
-  return useQuery({
-    queryKey: ['bridgeable-tokens', from, to, token],
-    queryFn: async () => {
+  return useQuery<XToken[], Error>({
+    queryKey: ['bridge', 'bridgeableTokens', from, to, token],
+    queryFn: () => {
       if (!from || !to || !token) {
-        return [];
+        throw new Error('from, to and token are required');
       }
-
       const result = sodax.bridge.getBridgeableTokens(from, to, token);
-      if (result.ok) {
-        return result.value;
+      if (!result.ok) {
+        throw result.error;
       }
-
-      console.error('Error getting bridgeable tokens:', result.error);
-      return [];
+      return result.value;
     },
     enabled: !!from && !!to && !!token,
+    ...queryOptions,
   });
 }

package/src/hooks/dex/index.ts

@@ -1,16 +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';
+export * from './usePools.js';
+export * from './usePoolData.js';
+export * from './usePoolBalances.js';
+export * from './usePositionInfo.js';
+export * from './useDexDeposit.js';
+export * from './useDexWithdraw.js';
+export * from './useDexAllowance.js';
+export * from './useDexApprove.js';
+export * from './useLiquidityAmounts.js';
+export * from './useSupplyLiquidity.js';
+export * from './useDecreaseLiquidity.js';
+export * from './useCreateDepositParams.js';
+export * from './useCreateSupplyLiquidityParams.js';
+export * from './useCreateDecreaseLiquidityParams.js';
+export * from './useCreateWithdrawParams.js';
+export * from './useClaimRewards.js';

package/src/hooks/dex/useClaimRewards.ts

@@ -1,68 +1,49 @@
-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';
+// packages/dapp-kit/src/hooks/dex/useClaimRewards.ts
+import type { ClLiquidityClaimRewardsAction, SpokeChainKey, TxHashPair } from '@sodax/sdk';
+import { useQueryClient } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
 
-export type UseClaimRewardsParams = {
-  params: ConcentratedLiquidityClaimRewardsParams;
-  spokeProvider: SpokeProvider;
-};
+/**
+ * Mutation variables for {@link useClaimRewards}. Generic over `K extends SpokeChainKey` (defaults
+ * to the full union). Sophisticated callers can lock K at the hook call site to narrow the
+ * `walletProvider` and `params.srcChainKey` types.
+ */
+export type UseClaimRewardsVars<K extends SpokeChainKey = SpokeChainKey> = Omit<
+  ClLiquidityClaimRewardsAction<K, false>,
+  'raw'
+>;
 
 /**
- * React hook for creating a mutation to claim DEX rewards for a concentrated liquidity position.
+ * React hook for claiming accrued fees on 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,
- * });
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped `TxHashPair` on success.
  */
-export function useClaimRewards(): UseMutationResult<
-  [SpokeTxHash, HubTxHash],
-  ConcentratedLiquidityError<ConcentratedLiquidityErrorCode>,
-  UseClaimRewardsParams
+export function useClaimRewards<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxHashPair, UseClaimRewardsVars<K>> = {}): SafeUseMutationResult<
+  TxHashPair,
+  Error,
+  UseClaimRewardsVars<K>
 > {
   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
+  return useSafeMutation<TxHashPair, Error, UseClaimRewardsVars<K>>({
+    mutationKey: ['dex', 'claimRewards'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.dex.clService.claimRewards({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      // `usePositionInfo` keys by string tokenId — stringify the bigint to keep the structural match.
       queryClient.invalidateQueries({
-        queryKey: ['dex', 'poolBalances', params.poolKey, spokeProvider.chainConfig.chain.id],
+        queryKey: ['dex', 'positionInfo', params.tokenId.toString(), params.poolKey],
       });
-      queryClient.invalidateQueries({ queryKey: ['dex', 'positionInfo', params.tokenId, params.poolKey] });
-      queryClient.invalidateQueries({ queryKey: ['dex', 'poolData', params.poolKey] });
+      queryClient.invalidateQueries({ queryKey: ['dex', 'poolBalances', params.srcChainKey, params.srcAddress] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     },
   });
 }

package/src/hooks/dex/useCreateDecreaseLiquidityParams.ts

@@ -1,5 +1,5 @@
-import { createDecreaseLiquidityParamsProps } from '@/utils/dex-utils';
-import type { ClPositionInfo, ConcentratedLiquidityDecreaseLiquidityParams, PoolKey } from '@sodax/sdk';
+import { createDecreaseLiquidityParamsProps, type DecreaseLiquidityParamsCore } from '@/utils/dex-utils.js';
+import type { ClPositionInfo, PoolKey } from '@sodax/sdk';
 import { useMemo } from 'react';
 
 export type UseCreateDecreaseLiquidityParamsProps = {
@@ -10,23 +10,10 @@ export type UseCreateDecreaseLiquidityParamsProps = {
   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.
+ * React hook to memoize the decrease-liquidity-specific subset of {@link ClDecreaseLiquidityParams}
+ * (`{ poolKey, tokenId, liquidity, amount0Min, amount1Min }`). Callers add `srcChainKey` +
+ * `srcAddress` at the mutation call site.
  */
 export function useCreateDecreaseLiquidityParams({
   poolKey,
@@ -34,8 +21,8 @@ export function useCreateDecreaseLiquidityParams({
   percentage,
   positionInfo,
   slippageTolerance,
-}: UseCreateDecreaseLiquidityParamsProps): ConcentratedLiquidityDecreaseLiquidityParams {
-  return useMemo<ConcentratedLiquidityDecreaseLiquidityParams>(() => {
+}: UseCreateDecreaseLiquidityParamsProps): DecreaseLiquidityParamsCore {
+  return useMemo<DecreaseLiquidityParamsCore>(() => {
     return createDecreaseLiquidityParamsProps({ poolKey, tokenId, percentage, positionInfo, slippageTolerance });
   }, [poolKey, tokenId, percentage, positionInfo, slippageTolerance]);
 }

package/src/hooks/dex/useCreateDepositParams.ts

@@ -1,6 +1,6 @@
 import { useMemo } from 'react';
-import type { CreateAssetDepositParams, PoolData, PoolSpokeAssets } from '@sodax/sdk';
-import { createDepositParamsProps } from '@/utils/dex-utils';
+import type { PoolData, PoolSpokeAssets } from '@sodax/sdk';
+import { createDepositParamsProps, type DepositParamsCore } from '@/utils/dex-utils.js';
 
 export type UseCreateDepositParamsProps = {
   tokenIndex: 0 | 1;
@@ -9,35 +9,21 @@ export type UseCreateDepositParamsProps = {
   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.
+ * React hook to memoize the deposit-specific subset of {@link CreateAssetDepositParams}
+ * (`{ asset, amount, poolToken, dst? }`). Callers add `srcChainKey` + `srcAddress` at the mutation
+ * call site.
  */
 export function useCreateDepositParams({
   tokenIndex,
   amount,
   poolData,
   poolSpokeAssets,
-}: UseCreateDepositParamsProps): CreateAssetDepositParams | undefined {
-  return useMemo<CreateAssetDepositParams | undefined>(() => {
+}: UseCreateDepositParamsProps): DepositParamsCore | undefined {
+  return useMemo<DepositParamsCore | 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

@@ -1,10 +1,6 @@
-import { createSupplyLiquidityParamsProps } from '@/utils/dex-utils';
-import type {
-  ConcentratedLiquiditySupplyParams,
-  ConcentratedLiquidityIncreaseLiquidityParams,
-  PoolData,
-  PoolKey,
-} from '@sodax/sdk';
+import { createSupplyLiquidityParamsProps } from '@/utils/dex-utils.js';
+import type { ClSupplyParams, ClIncreaseLiquidityParams, PoolData, PoolKey } from '@sodax/sdk';
+import type { SpokeChainKey } from '@sodax/sdk';
 import { useMemo } from 'react';
 
 export type UseCreateSupplyLiquidityParamsProps = {
@@ -19,33 +15,22 @@ export type UseCreateSupplyLiquidityParamsProps = {
   isValidPosition?: boolean;
 };
 
-export type UseCreateSupplyLiquidityParamsResult = ConcentratedLiquiditySupplyParams &
-  Omit<ConcentratedLiquidityIncreaseLiquidityParams, 'tokenId'> & {
+/**
+ * Subset of {@link ClSupplyParams} / {@link ClIncreaseLiquidityParams} produced by
+ * {@link useCreateSupplyLiquidityParams}. Callers add `srcChainKey` + `srcAddress` at the mutation
+ * call site. `tokenId` and `isValidPosition` distinguish the mint-new vs increase-existing path.
+ */
+export type UseCreateSupplyLiquidityParamsResult = Omit<ClSupplyParams<SpokeChainKey>, 'srcChainKey' | 'srcAddress'> &
+  Omit<ClIncreaseLiquidityParams<SpokeChainKey>, 'srcChainKey' | 'srcAddress' | '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.
+ * React hook to memoize concentrated-liquidity supply parameters for a given pool. Returns the
+ * pool/tick/liquidity/amount fields without `srcChainKey`/`srcAddress` — callers add those at the
+ * mutation call site.
  */
 export function useCreateSupplyLiquidityParams({
   poolData,

package/src/hooks/dex/useCreateWithdrawParams.ts

@@ -1,6 +1,6 @@
-import type { CreateAssetWithdrawParams, DestinationParamsType, PoolData, PoolSpokeAssets } from '@sodax/sdk';
+import type { DestinationParamsType, PoolData, PoolSpokeAssets } from '@sodax/sdk';
 import { useMemo } from 'react';
-import { createWithdrawParamsProps } from '@/utils/dex-utils';
+import { createWithdrawParamsProps, type WithdrawParamsCore } from '@/utils/dex-utils.js';
 
 export type UseCreateWithdrawParamsProps = {
   tokenIndex: 0 | 1;
@@ -11,21 +11,9 @@ export type UseCreateWithdrawParamsProps = {
 };
 
 /**
- * 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.
+ * React hook to memoize the withdraw-specific subset of {@link CreateAssetWithdrawParams}
+ * (`{ asset, amount, poolToken, dst? }`). Callers add `srcChainKey` + `srcAddress` at the mutation
+ * call site.
  */
 export function useCreateWithdrawParams({
   tokenIndex,
@@ -33,12 +21,11 @@ export function useCreateWithdrawParams({
   poolData,
   poolSpokeAssets,
   dst,
-}: UseCreateWithdrawParamsProps): CreateAssetWithdrawParams | undefined {
-  return useMemo<CreateAssetWithdrawParams | undefined>(() => {
+}: UseCreateWithdrawParamsProps): WithdrawParamsCore | undefined {
+  return useMemo<WithdrawParamsCore | undefined>(() => {
     if (!amount || Number.parseFloat(String(amount)) <= 0) {
       return undefined;
     }
-
     return createWithdrawParamsProps({ tokenIndex, amount, poolData, poolSpokeAssets, dst });
   }, [tokenIndex, amount, poolData, poolSpokeAssets, dst]);
 }