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

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { Sodax, SpokeProvider, GetEstimateGasReturnType, TxReturnType, SpokeChainId, StellarSpokeProvider, EvmHubProvider, IWalletProvider, BitcoinSpokeProvider, RadfiWalletBalance, RadfiUtxo, MoneyMarketBorrowParams, MoneyMarketError, RelayErrorCode, MoneyMarketRepayParams, MoneyMarketSupplyParams, MoneyMarketWithdrawParams, UserReserveData, AggregatedReserveData, BaseCurrencyInfo, MoneyMarketParams, XToken, ReserveData, FormatReserveUSDResponse, FormatUserSummaryResponse, SolverIntentQuoteRequest, Result, SolverIntentQuoteResponse, SolverErrorResponse, SolverExecutionResponse, Intent, IntentDeliveryInfo, IntentError, IntentErrorCode, CreateIntentParams, Hex, SolverIntentStatusResponse, CreateLimitOrderParams, IntentResponse, Address as Address$1, UserIntentsResponse, RequestOverrideConfig, OrderbookResponse, MoneyMarketPosition, MoneyMarketAsset, MoneyMarketAssetBorrowers, MoneyMarketAssetSuppliers, MoneyMarketBorrowers, CreateBridgeIntentParams, SpokeTxHash, HubTxHash, BridgeError, BridgeErrorCode, BridgeLimit, StakeParams, UnstakeParams, ClaimParams, CancelUnstakeParams, StakingInfo, UnstakingInfo, UnstakeRequestWithPenalty, StakingConfig, InstantUnstakeParams, SodaxConfig } from '@sodax/sdk';
+import { Sodax, SpokeProvider, GetEstimateGasReturnType, TxReturnType, SpokeChainId, StellarSpokeProvider, EvmHubProvider, IWalletProvider, BitcoinSpokeProvider, RadfiWalletBalance, RadfiUtxo, MoneyMarketBorrowParams, MoneyMarketError, RelayErrorCode, MoneyMarketRepayParams, MoneyMarketSupplyParams, MoneyMarketWithdrawParams, UserReserveData, AggregatedReserveData, BaseCurrencyInfo, MoneyMarketParams, XToken, ReserveData, FormatReserveUSDResponse, FormatUserSummaryResponse, SolverIntentQuoteRequest, Result, SolverIntentQuoteResponse, SolverErrorResponse, SolverExecutionResponse, Intent, IntentDeliveryInfo, IntentError, IntentErrorCode, CreateIntentParams, Hex, SolverIntentStatusResponse, CreateLimitOrderParams, IntentResponse, Address as Address$1, UserIntentsResponse, RequestOverrideConfig, OrderbookResponse, MoneyMarketPosition, MoneyMarketAsset, MoneyMarketAssetBorrowers, MoneyMarketAssetSuppliers, MoneyMarketBorrowers, CreateBridgeIntentParams, SpokeTxHash, HubTxHash, BridgeError, BridgeErrorCode, BridgeLimit, StakeParams, UnstakeParams, ClaimParams, CancelUnstakeParams, StakingInfo, UnstakingInfo, UnstakeRequestWithPenalty, StakingConfig, InstantUnstakeParams, PoolKey, PoolData, ClPositionInfo, CreateAssetDepositParams, CreateAssetWithdrawParams, ConcentratedLiquiditySupplyParams, ConcentratedLiquidityIncreaseLiquidityParams, ConcentratedLiquidityDecreaseLiquidityParams, PoolSpokeAssets, DestinationParamsType, ConcentratedLiquidityClaimRewardsParams, ConcentratedLiquidityError, ConcentratedLiquidityErrorCode, SodaxConfig } from '@sodax/sdk';
 import { RpcConfig, SpokeChainId as SpokeChainId$1, SubmitSwapTxResponse, SubmitSwapTxRequest, SubmitSwapTxStatusResponse, XToken as XToken$1 } from '@sodax/types';
-import { UseMutationResult, UseQueryResult, UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
+import { UseMutationResult, UseQueryResult, UseQueryOptions, UseMutationOptions, QueryObserverOptions } from '@tanstack/react-query';
 import { Address } from 'viem';
 import { ReactNode, ReactElement } from 'react';
 
@@ -184,8 +184,6 @@ type RadfiSession = {
     refreshToken: string;
     tradingAddress: string;
     publicKey: string;
-    accessTokenExpiry: number;
-    refreshTokenExpiry: number;
 };
 type RadfiAuthResult = {
     accessToken: string;
@@ -195,11 +193,9 @@ type RadfiAuthResult = {
 declare function saveRadfiSession(address: string, session: RadfiSession): void;
 declare function loadRadfiSession(address: string): RadfiSession | null;
 declare function clearRadfiSession(address: string): void;
-declare function isAccessTokenExpired(address: string): boolean;
-declare function isRefreshTokenExpired(address: string): boolean;
 /**
  * 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.
  */
 declare function useRadfiAuth(spokeProvider: BitcoinSpokeProvider | undefined): UseMutationResult<RadfiAuthResult, Error, void>;
 
@@ -212,8 +208,9 @@ 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
  */
 declare function useRadfiSession(spokeProvider: BitcoinSpokeProvider | undefined): UseRadfiSessionReturn;
@@ -274,7 +271,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);
  * };
@@ -282,6 +279,39 @@ type RenewUtxosParams = {
  */
 declare function useRenewUtxos(spokeProvider: BitcoinSpokeProvider | undefined): UseMutationResult<string, Error, RenewUtxosParams>;
 
+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);
+ * };
+ * ```
+ */
+declare function useRadfiWithdraw(spokeProvider: BitcoinSpokeProvider | undefined): UseMutationResult<WithdrawResult, Error, WithdrawToUserParams>;
+
 interface BorrowResponse {
     ok: true;
     value: [string, string];
@@ -2000,6 +2030,541 @@ interface UseApproveReturn {
  */
 declare function useMigrationApprove(params: MigrationIntentParams | undefined, spokeProvider: SpokeProvider | undefined): UseApproveReturn;
 
+type UsePoolsProps = {
+    /**
+     * Optional react-query QueryObserverOptions for customizing query behavior such as
+     * staleTime, refetchInterval, cacheTime, etc. These are merged with sensible defaults.
+     */
+    queryOptions?: QueryObserverOptions<PoolKey[], Error>;
+};
+/**
+ * Loads and caches the available list of pools from the DEX service's ConcentratedLiquidityService.
+ *
+ * By default, the query result is cached indefinitely (with `staleTime` set to Infinity), reflecting the
+ * assumption that the pools list is mostly static.
+ *
+ * @param params
+ *   Optional configuration object:
+ *   - queryOptions: Partial QueryObserverOptions for react-query (merged with built-in defaults).
+ *
+ * @returns
+ *   A UseQueryResult object from @tanstack/react-query containing:
+ *   - `data`: Array of PoolKey objects or undefined if not loaded or errored.
+ *   - Status fields: `isLoading`, `isError`, `error`, etc.
+ *
+ * @example
+ *   const { data: pools, isLoading, error } = usePools();
+ *   if (isLoading) return <div>Loading pools...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *   if (pools) pools.forEach((pool, idx) => console.log(pool.id, pool.fee));
+ */
+declare function usePools(params?: UsePoolsProps): UseQueryResult<PoolKey[], Error>;
+
+type UsePoolDataProps = {
+    poolKey: PoolKey | null;
+    enabled?: boolean;
+    queryOptions?: QueryObserverOptions<PoolData, Error>;
+};
+/**
+ * React hook to fetch on-chain data for a given DEX pool.
+ *
+ * @param {UsePoolDataProps} props - The props object:
+ *   - `poolKey`: PoolKey | null — The unique identifier for the pool to fetch data for. If null, disables the query.
+ *   - `enabled`: boolean (optional) — Whether the query is enabled. Defaults to enabled if a poolKey is provided, otherwise false.
+ *   - `queryOptions`: QueryObserverOptions<PoolData, Error> (optional) — Additional React Query options (e.g., staleTime, refetchInterval).
+ *
+ * @returns {UseQueryResult<PoolData, Error>} React Query result containing pool data (`data`), loading state (`isLoading`), error (`error`), and status fields.
+ *
+ * @example
+ * ```typescript
+ * const { data: poolData, isLoading, error } = usePoolData({ poolKey });
+ * if (isLoading) return <div>Loading…</div>;
+ * if (error) return <div>Error!</div>;
+ * if (poolData) {
+ *   // poolData is available
+ * }
+ * ```
+ *
+ * @remarks
+ * - Refetches pool data every 30 seconds by default, and may be configured via `queryOptions`.
+ * - If `poolKey` is `null`, the query is disabled and no network request is performed.
+ * - Throws an error if `poolKey` is missing when the query is enabled.
+ */
+declare function usePoolData({ poolKey, queryOptions, }: UsePoolDataProps): UseQueryResult<PoolData, Error>;
+
+interface UsePoolBalancesResponse {
+    token0Balance: bigint;
+    token1Balance: bigint;
+}
+interface UsePoolBalancesProps {
+    poolData: PoolData | null;
+    poolKey: PoolKey | null;
+    spokeProvider: SpokeProvider | null;
+    enabled?: boolean;
+    queryOptions?: QueryObserverOptions<UsePoolBalancesResponse, Error>;
+}
+/**
+ * React hook to query a user's token balances for a DEX pool.
+ *
+ * Given the pool data (with token addresses), the pool's key, and a SpokeProvider,
+ * fetches the user's protocol balances for both token0 and token1 for the specified pool.
+ * Queries are auto-refreshed; advanced options can be customized via `queryOptions`.
+ *
+ * @param {UsePoolBalancesProps} props
+ *   Object containing:
+ *   - `poolData`: {PoolData | null} - Pool info (must include token0 and token1 addresses). Required unless disabling.
+ *   - `poolKey`: {PoolKey | null} - Unique key for the DEX pool. Required unless disabling.
+ *   - `spokeProvider`: {SpokeProvider | null} - Provider instance for the chain. Required unless disabling.
+ *   - `enabled`: {boolean} (optional) - Whether to enable the query. Defaults to `true` if all other arguments are provided.
+ *   - `queryOptions`: {QueryObserverOptions<UsePoolBalancesResponse, Error>} (optional) - Advanced react-query options.
+ *
+ * @returns {UseQueryResult<UsePoolBalancesResponse, Error>}
+ *   React Query result object:
+ *   - `data`: `{ token0Balance: bigint, token1Balance: bigint }` if loaded, undefined otherwise.
+ *   - `isLoading`, `isError`, etc. for status handling.
+ *
+ * @remarks
+ * - Throws an error if any of `poolData`, `poolKey`, or `spokeProvider` is missing when enabled.
+ * - Suitable for tracking current protocol/wallet balances for both pool tokens.
+ * - The hook is designed for use within a React component tree that provides the Sodax context.
+ * - Data are automatically refreshed at the provided or default polling interval (default: refetch every 10s).
+ *
+ * @example
+ * ```typescript
+ * const { data, isLoading } = usePoolBalances({ poolData, poolKey, spokeProvider });
+ * if (data) {
+ *   console.log('Balances:', data.token0Balance, data.token1Balance);
+ * }
+ * ```
+ */
+declare function usePoolBalances({ poolData, poolKey, spokeProvider, enabled, queryOptions, }: UsePoolBalancesProps): UseQueryResult<UsePoolBalancesResponse, Error>;
+
+interface UsePositionInfoResponse {
+    positionInfo: ClPositionInfo;
+    isValid: boolean;
+}
+interface UsePositionInfoProps {
+    tokenId: string | null;
+    poolKey: PoolKey | null;
+    queryOptions?: QueryObserverOptions<UsePositionInfoResponse, Error>;
+}
+/**
+ * React hook to fetch and validate CL position details by position NFT token ID.
+ *
+ * Fetches position data on-chain for a given tokenId, and checks if it matches the expected PoolKey.
+ * This is commonly used in DEX dashboards to show or pre-validate user positions by ID.
+ *
+ * @param {string | null} tokenId
+ *   Position NFT token ID to query, as a string. Pass `null` or empty string to disable.
+ * @param {PoolKey | null} poolKey
+ *   PoolKey to match against the position's underlying pool. Pass `null` to disable.
+ * @param {QueryObserverOptions<UsePositionInfoResponse, Error>} [queryOptions]
+ *   Optional react-query options for polling/refresh and config. Merged with sensible defaults.
+ *
+ * @returns {UseQueryResult<UsePositionInfoResponse, Error>}
+ *   Standard React Query result object:
+ *   - `data`: { positionInfo, isValid } if loaded, or undefined if not loaded/error
+ *   - `isLoading`: boolean (query active)
+ *   - `isError`: boolean (query failed)
+ *   - ...other react-query helpers (refetch, status, etc)
+ *
+ * @example
+ * ```typescript
+ * const { data, isLoading, error } = usePositionInfo({ tokenId, poolKey });
+ * if (isLoading) return <div>Loading position...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (data) {
+ *   console.log('Valid for pool:', data.isValid);
+ *   console.log('Liquidity:', data.positionInfo.liquidity);
+ * }
+ * ```
+ *
+ * @remarks
+ * - Validates the underlying position's pool definition (currency0, currency1, fee) with the supplied PoolKey.
+ * - Returns `isValid: false` if any field mismatches.
+ * - Pass `null` as tokenId or poolKey to disable the query.
+ * - Defaults: 10s stale, not enabled if missing arguments. Customizable via `queryOptions`.
+ * - Throws error if called with invalid/null tokenId or poolKey when enabled.
+ */
+declare function usePositionInfo({ tokenId, poolKey, queryOptions, }: UsePositionInfoProps): UseQueryResult<UsePositionInfoResponse, Error>;
+
+type UseDexDepositParams = {
+    params: CreateAssetDepositParams;
+    spokeProvider: SpokeProvider;
+};
+/**
+/**
+ * React hook that provides a mutation to perform a deposit into a DEX pool using the provided parameters and SpokeProvider.
+ *
+ * The hook returns a mutation object for executing the deposit (`mutateAsync`), tracking its state (`isPending`), and any resulting error (`error`).
+ * On successful deposit, all queries matching ['dex', 'poolBalances'] are invalidated and refetched.
+ *
+ * @returns {UseMutationResult<[SpokeTxHash, HubTxHash], Error, UseDexDepositParams>}
+ *   React Query mutation result:
+ *   - `mutateAsync({ params, spokeProvider })`: Triggers the deposit with {@link CreateDepositParams} and the target SpokeProvider.
+ *   - `isPending`: True while the deposit transaction is pending.
+ *   - `error`: Error if the mutation fails.
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: deposit, isPending, error } = useDexDeposit();
+ * await deposit({ params: { asset, amount, poolToken }, spokeProvider });
+ * ```
+ *
+ * @remarks
+ * - Throws if called with missing `spokeProvider` or `params`.
+ * - Upon success, automatically refetches up-to-date pool balances.
+ */
+declare function useDexDeposit(): UseMutationResult<[SpokeTxHash, HubTxHash], Error, UseDexDepositParams>;
+
+type UseDexWithdrawParams = {
+    params: CreateAssetWithdrawParams;
+    spokeProvider: SpokeProvider;
+};
+/**
+ * React hook to provide a mutation for withdrawing assets from a DEX pool.
+ *
+ * This hook returns a mutation result object valid for use with React Query.
+ * The mutation function expects an object with the withdrawal parameters and a SpokeProvider,
+ * and triggers the withdrawal operation on the DEX. On success, it invalidates the relevant
+ * ['dex', 'poolBalances'] query to fetch the updated balances.
+ *
+ * @returns {UseMutationResult<[SpokeTxHash, HubTxHash], Error, UseDexWithdrawParams>}
+ *   Mutation result object. Use its properties to:
+ *   - Call `mutateAsync({ params, spokeProvider })` to perform the withdrawal.
+ *   - Track progress with `isPending`.
+ *   - Access any `error` encountered during the mutation.
+ *
+ * @example
+ * const { mutateAsync: withdraw, isPending, error } = useDexWithdraw();
+ * await withdraw({ params, spokeProvider });
+ */
+declare function useDexWithdraw(): UseMutationResult<[SpokeTxHash, HubTxHash], Error, UseDexWithdrawParams>;
+
+type UseDexAllowanceProps = {
+    params: CreateAssetDepositParams | undefined;
+    spokeProvider: SpokeProvider | null;
+    enabled?: boolean;
+    queryOptions?: QueryObserverOptions<boolean, Error>;
+};
+/**
+ * Hook to check if the user has approved sufficient token allowance for DEX deposits.
+ *
+ * This hook automatically queries and tracks the allowance status, indicating whether
+ * the user has granted enough allowance to allow a specific deposit to the DEX. It leverages
+ * React Query for status, caching, and background refetching.
+ *
+ * @param {CreateAssetDepositParams | undefined} params
+ *   The deposit parameters: asset address, poolToken, and raw amount (BigInt), or undefined to disable.
+ * @param {SpokeProvider | undefined} spokeProvider
+ *   The provider interface for the selected chain. When undefined, the query is disabled.
+ * @param {boolean} [enabled]
+ *   Whether the allowance status check is enabled. Defaults to true if both params and spokeProvider are truthy.
+ * @param {QueryObserverOptions<boolean, Error>} [queryOptions]
+ *   Optional react-query options. Any override here (e.g. staleTime, refetchInterval) will merge with defaults.
+ *
+ * @returns {UseQueryResult<boolean, Error>}
+ *   React Query result object: `data` is boolean (true if allowance is sufficient), plus `isLoading`, `error`, etc.
+ *
+ * @example
+ * ```typescript
+ * const { data: isAllowed, isLoading, error } = useDexAllowance({
+ *   params: { asset, amount: parseUnits('100', 18), poolToken },
+ *   spokeProvider,
+ * });
+ * if (isLoading) return <Spinner />;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (isAllowed) { ... }
+ * ```
+ *
+ * @remarks
+ * - The allowance is checked every 5 seconds as long as enabled, params, and spokeProvider are all defined.
+ * - Returns `false` if allowance cannot be determined or any error occurs in isAllowanceValid.
+ * - Suitable for gating UI actions that require token approval before depositing in the DEX.
+ */
+declare function useDexAllowance({ params, spokeProvider, queryOptions, }: UseDexAllowanceProps): UseQueryResult<boolean, Error>;
+
+type UseDexApproveParams = {
+    params: CreateAssetDepositParams;
+    spokeProvider: SpokeProvider;
+};
+/**
+ * React hook for performing a DEX token allowance approval transaction.
+ *
+ * Returns a mutation object that allows explicitly triggering a token approval
+ * for a DEX deposit, using the specified approval parameters and spoke provider.
+ * On successful approval, the related allowance query is invalidated and refetched
+ * for consistent UI state.
+ *
+ * @returns {UseMutationResult<SpokeTxHash, Error, UseDexApproveParams>}
+ *   React Query mutation result for the approval operation. Use `mutateAsync` with
+ *   an object of shape `{ params, spokeProvider }` to initiate approval.
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: approve, isPending, error } = useDexApprove();
+ * await approve({ params: { asset, amount, poolToken }, spokeProvider });
+ * ```
+ *
+ * @remarks
+ * - Throws if called without both a valid `params` and `spokeProvider`.
+ * - On approval success, the query for ['dex', 'allowance'] is invalidated/refetched.
+ */
+declare function useDexApprove(): UseMutationResult<SpokeTxHash, Error, UseDexApproveParams>;
+
+interface UseLiquidityAmountsResult {
+    liquidityToken0Amount: string;
+    liquidityToken1Amount: string;
+    lastEditedToken: 'token0' | 'token1' | null;
+    setLiquidityToken0Amount: (value: string) => void;
+    setLiquidityToken1Amount: (value: string) => void;
+    handleToken0AmountChange: (value: string) => void;
+    handleToken1AmountChange: (value: string) => void;
+}
+/**
+ * Hook for calculating liquidity amounts based on price range.
+ *
+ * This hook manages the state and calculations for liquidity token amounts.
+ * It automatically calculates the corresponding token amount when one is changed,
+ * based on the current price range and pool data.
+ *
+ * @param {string} minPrice - Minimum price for the liquidity range
+ * @param {string} maxPrice - Maximum price for the liquidity range
+ * @param {PoolData | null} poolData - The pool data containing token information
+ * @returns {UseLiquidityAmountsResult} Object containing amounts, state, and handlers
+ *
+ * @example
+ * ```typescript
+ * const {
+ *   liquidityToken0Amount,
+ *   liquidityToken1Amount,
+ *   handleToken0AmountChange,
+ *   handleToken1AmountChange,
+ * } = useLiquidityAmounts(minPrice, maxPrice, poolData);
+ *
+ * <Input
+ *   value={liquidityToken0Amount}
+ *   onChange={(e) => handleToken0AmountChange(e.target.value)}
+ * />
+ * ```
+ */
+declare function useLiquidityAmounts(minPrice: string, maxPrice: string, poolData: PoolData | null): UseLiquidityAmountsResult;
+
+type UseCreateSupplyLiquidityParamsProps = {
+    poolData: PoolData;
+    poolKey: PoolKey;
+    minPrice: string;
+    maxPrice: string;
+    liquidityToken0Amount: string;
+    liquidityToken1Amount: string;
+    slippageTolerance: string | number;
+    positionId?: string | null;
+    isValidPosition?: boolean;
+};
+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.
+ */
+declare function useCreateSupplyLiquidityParams({ poolData, poolKey, minPrice, maxPrice, liquidityToken0Amount, liquidityToken1Amount, slippageTolerance, positionId, isValidPosition, }: UseCreateSupplyLiquidityParamsProps): UseCreateSupplyLiquidityParamsResult;
+
+type UseSupplyLiquidityProps = {
+    params: UseCreateSupplyLiquidityParamsResult;
+    spokeProvider: SpokeProvider;
+};
+/**
+ * Hook for supplying liquidity to a pool.
+ *
+ * This hook handles both minting new positions and increasing liquidity in existing positions.
+ * It applies slippage tolerance before calculating liquidity and handles the complete transaction flow.
+ *
+ * @param {SpokeProvider} spokeProvider - The spoke provider for the chain
+ * @returns {UseMutationResult<void, Error, SupplyLiquidityParams>} Mutation result with supply function
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: supplyLiquidity, isPending, error } = useSupplyLiquidity(spokeProvider);
+ *
+ * await supplyLiquidity({
+ *   poolData,
+ *   poolKey,
+ *   minPrice: '100',
+ *   maxPrice: '200',
+ *   liquidityToken0Amount: '10',
+ *   liquidityToken1Amount: '20',
+ *   slippageTolerance: '0.5',
+ * });
+ * ```
+ */
+declare function useSupplyLiquidity(): UseMutationResult<[SpokeTxHash, HubTxHash], Error, UseSupplyLiquidityProps>;
+
+type UseDecreaseLiquidityParams = {
+    params: ConcentratedLiquidityDecreaseLiquidityParams;
+    spokeProvider: SpokeProvider;
+};
+/**
+ * React hook that provides a mutation for decreasing liquidity in a concentrated liquidity position.
+ *
+ * This hook returns a mutation for removing liquidity from a position using the provided
+ * `ConcentratedLiquidityDecreaseLiquidityParams` and `SpokeProvider`. The mutation returns a tuple of
+ * the spoke transaction hash and the hub transaction hash upon success.
+ *
+ * @returns {UseMutationResult<[SpokeTxHash, HubTxHash], Error, UseDecreaseLiquidityParams>}
+ *   React Query mutation result:
+ *   - `mutateAsync({ params, spokeProvider })`: Triggers the decrease liquidity mutation.
+ *   - On success, returns `[spokeTxHash, hubTxHash]`.
+ *   - On failure, throws an error.
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: decreaseLiquidity, isPending, error } = useDecreaseLiquidity();
+ *
+ * await decreaseLiquidity({
+ *   params: {
+ *     poolKey,
+ *     tokenId: 123n,
+ *     liquidity: 100000n,
+ *     amount0Min: 0n,
+ *     amount1Min: 0n,
+ *   },
+ *   spokeProvider,
+ * });
+ * ```
+ *
+ * @param {UseDecreaseLiquidityParams} variables
+ *   - `params`: Parameters for the decrease liquidity operation, matching `ConcentratedLiquidityDecreaseLiquidityParams`.
+ *   - `spokeProvider`: The provider instance for the target spoke chain.
+ *
+ * @remarks
+ * - After a successful liquidity decrease, the hook will invalidate DEX pool balances and position info queries.
+ */
+declare function useDecreaseLiquidity(): UseMutationResult<[SpokeTxHash, HubTxHash], Error, UseDecreaseLiquidityParams>;
+
+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.
+ */
+declare function useCreateDepositParams({ tokenIndex, amount, poolData, poolSpokeAssets, }: UseCreateDepositParamsProps): CreateAssetDepositParams | undefined;
+
+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.
+ */
+declare function useCreateDecreaseLiquidityParams({ poolKey, tokenId, percentage, positionInfo, slippageTolerance, }: UseCreateDecreaseLiquidityParamsProps): ConcentratedLiquidityDecreaseLiquidityParams;
+
+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.
+ */
+declare function useCreateWithdrawParams({ tokenIndex, amount, poolData, poolSpokeAssets, dst, }: UseCreateWithdrawParamsProps): CreateAssetWithdrawParams | undefined;
+
+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,
+ * });
+ */
+declare function useClaimRewards(): UseMutationResult<[
+    SpokeTxHash,
+    HubTxHash
+], ConcentratedLiquidityError<ConcentratedLiquidityErrorCode>, UseClaimRewardsParams>;
+
 interface SodaxProviderProps {
     children: ReactNode;
     testnet?: boolean;
@@ -2008,4 +2573,9 @@ interface SodaxProviderProps {
 }
 declare const SodaxProvider: ({ children, testnet, config, rpcConfig }: SodaxProviderProps) => ReactElement;
 
-export { type BackendPaginationParams, MIGRATION_MODE_BNUSD, MIGRATION_MODE_ICX_SODA, type MigrationIntentParams, type MigrationMode, type RadfiSession, SodaxProvider, type UseATokenParams, type UseATokensBalancesParams, type UseBorrowParams, type UseMMAllowanceParams, type UseMMApproveParams, type UseRadfiSessionReturn, type UseRepayParams, type UseReservesDataParams, type UseReservesUsdFormatParams, type UseSupplyParams, type UseUserFormattedSummaryParams, type UseUserReservesDataParams, type UseWithdrawParams, clearRadfiSession, isAccessTokenExpired, isRefreshTokenExpired, 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, 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 };
+declare function createDecreaseLiquidityParamsProps({ poolKey, tokenId, percentage, positionInfo, slippageTolerance, }: UseCreateDecreaseLiquidityParamsProps): ConcentratedLiquidityDecreaseLiquidityParams;
+declare function createDepositParamsProps({ tokenIndex, amount, poolData, poolSpokeAssets, }: UseCreateDepositParamsProps): CreateAssetDepositParams;
+declare function createSupplyLiquidityParamsProps({ poolData, poolKey, minPrice, maxPrice, liquidityToken0Amount, liquidityToken1Amount, slippageTolerance, positionId, isValidPosition, }: UseCreateSupplyLiquidityParamsProps): UseCreateSupplyLiquidityParamsResult;
+declare function createWithdrawParamsProps({ tokenIndex, amount, poolData, poolSpokeAssets, dst, }: UseCreateWithdrawParamsProps): CreateAssetWithdrawParams;
+
+export { type BackendPaginationParams, MIGRATION_MODE_BNUSD, MIGRATION_MODE_ICX_SODA, type MigrationIntentParams, type MigrationMode, type RadfiSession, SodaxProvider, type UseATokenParams, type UseATokensBalancesParams, type UseBorrowParams, type UseClaimRewardsParams, type UseCreateDecreaseLiquidityParamsProps, type UseCreateDepositParamsProps, type UseCreateSupplyLiquidityParamsProps, type UseCreateSupplyLiquidityParamsResult, type UseCreateWithdrawParamsProps, type UseDecreaseLiquidityParams, type UseDexAllowanceProps, type UseDexApproveParams, type UseDexDepositParams, type UseDexWithdrawParams, type UseMMAllowanceParams, type UseMMApproveParams, type UsePoolBalancesProps, type UsePoolBalancesResponse, type UsePoolDataProps, type UsePoolsProps, type UsePositionInfoProps, type UsePositionInfoResponse, type UseRadfiSessionReturn, type UseRepayParams, type UseReservesDataParams, type UseReservesUsdFormatParams, type UseSupplyLiquidityProps, type UseSupplyParams, type UseUserFormattedSummaryParams, type UseUserReservesDataParams, type UseWithdrawParams, 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 };