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

package/src/hooks/dex/usePools.ts

@@ -0,0 +1,48 @@
+import { type QueryObserverOptions, useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { PoolKey } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+export 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));
+ */
+export function usePools(params?: UsePoolsProps): UseQueryResult<PoolKey[], Error> {
+  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 (): Promise<PoolKey[]> => {
+      return sodax.dex.clService.getPools();
+    },
+  });
+}

package/src/hooks/dex/usePositionInfo.ts

@@ -0,0 +1,88 @@
+import { type QueryObserverOptions, useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { ClPositionInfo, PoolKey } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+export interface UsePositionInfoResponse {
+  positionInfo: ClPositionInfo;
+  isValid: boolean;
+}
+
+export 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.
+ */
+export function usePositionInfo({
+  tokenId,
+  poolKey,
+  queryOptions = {
+    queryKey: ['dex', 'positionInfo', tokenId, poolKey],
+    enabled: tokenId !== null && poolKey !== null && tokenId !== '',
+    staleTime: 10000, // Consider data stale after 10 seconds
+  },
+}: UsePositionInfoProps): UseQueryResult<UsePositionInfoResponse, Error> {
+  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);
+
+      // Validate that position belongs to current pool
+      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,
+  });
+}

package/src/hooks/dex/useSupplyLiquidity.ts

@@ -0,0 +1,91 @@
+import { useMutation, useQueryClient, type UseMutationResult } from '@tanstack/react-query';
+import type { HubTxHash, SpokeTxHash, SpokeProvider } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { UseCreateSupplyLiquidityParamsResult } from './useCreateSupplyLiquidityParams';
+
+export 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',
+ * });
+ * ```
+ */
+export function useSupplyLiquidity(): UseMutationResult<[SpokeTxHash, HubTxHash], Error, UseSupplyLiquidityProps> {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({ params, spokeProvider }: UseSupplyLiquidityProps) => {
+      // Check if we're increasing an existing position or minting a new one
+      if (params.tokenId && params.isValidPosition) {
+        // Increase liquidity in existing position
+        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;
+      }
+
+      // Mint new position
+      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: () => {
+      // Invalidate relevant queries
+      queryClient.invalidateQueries({ queryKey: ['dex', 'poolBalances'] });
+      queryClient.invalidateQueries({ queryKey: ['dex', 'positionInfo'] });
+    },
+  });
+}

package/src/hooks/index.ts

@@ -7,3 +7,4 @@ export * from './backend';
 export * from './bridge';
 export * from './staking';
 export * from './migrate';
+export * from './dex';

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from './hooks';
 export * from './providers';
+export * from './utils';

package/src/utils/dex-utils.ts

@@ -0,0 +1,177 @@
+import type {
+  UseCreateDecreaseLiquidityParamsProps,
+  UseCreateDepositParamsProps,
+  UseCreateSupplyLiquidityParamsProps,
+  UseCreateSupplyLiquidityParamsResult,
+  UseCreateWithdrawParamsProps,
+} from '@/hooks/dex';
+import {
+  ClService,
+  type CreateAssetWithdrawParams,
+  type ConcentratedLiquidityDecreaseLiquidityParams,
+  type CreateAssetDepositParams,
+} from '@sodax/sdk';
+import { parseUnits } from 'viem';
+
+export function createDecreaseLiquidityParamsProps({
+  poolKey,
+  tokenId,
+  percentage,
+  positionInfo,
+  slippageTolerance,
+}: UseCreateDecreaseLiquidityParamsProps): ConcentratedLiquidityDecreaseLiquidityParams {
+  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');
+  }
+
+  // Calculate liquidity to remove based on percentage
+  const liquidityToRemove =
+    percentageNum === 100
+      ? positionInfo.liquidity
+      : (positionInfo.liquidity * BigInt(Math.floor(percentageNum * 100))) / 10000n;
+
+  // Calculate expected token amounts from this liquidity
+  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;
+
+  // Apply slippage to minimum amounts
+  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,
+  };
+}
+
+export function createDepositParamsProps({
+  tokenIndex,
+  amount,
+  poolData,
+  poolSpokeAssets,
+}: UseCreateDepositParamsProps): CreateAssetDepositParams {
+  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,
+  };
+}
+
+export function createSupplyLiquidityParamsProps({
+  poolData,
+  poolKey,
+  minPrice,
+  maxPrice,
+  liquidityToken0Amount,
+  liquidityToken1Amount,
+  slippageTolerance,
+  positionId,
+  isValidPosition,
+}: UseCreateSupplyLiquidityParamsProps): UseCreateSupplyLiquidityParamsResult {
+  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);
+
+  // Convert prices to ticks
+  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);
+
+  // Apply slippage BEFORE calculating liquidity
+  const slippageMultiplier = BigInt(Math.floor((100 - slippage) * 100)); // e.g., 0.5% => 9950
+
+  const amount0ForLiquidity = (amount0BigInt * slippageMultiplier) / 10000n;
+  const amount1ForLiquidity = (amount1BigInt * slippageMultiplier) / 10000n;
+
+  // Calculate liquidity based on reduced amounts (accounting for slippage)
+  const liquidity = ClService.calculateLiquidityFromAmounts(
+    amount0ForLiquidity,
+    amount1ForLiquidity,
+    tickLower,
+    tickUpper,
+    BigInt(poolData.currentTick),
+  );
+  const tokenId = positionId ? BigInt(positionId) : undefined;
+
+  return {
+    poolKey,
+    tickLower,
+    tickUpper,
+    liquidity,
+    amount0Max: amount0BigInt,
+    amount1Max: amount1BigInt,
+    sqrtPriceX96: poolData.sqrtPriceX96,
+    positionId,
+    isValidPosition,
+    tokenId,
+  };
+}
+
+export function createWithdrawParamsProps({
+  tokenIndex,
+  amount,
+  poolData,
+  poolSpokeAssets,
+  dst,
+}: UseCreateWithdrawParamsProps): CreateAssetWithdrawParams {
+  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,
+  };
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './dex-utils';

package/src/hooks/bitcoin/radfiConstants.ts

@@ -1,2 +0,0 @@
-export const ACCESS_TOKEN_TTL = 10 * 60 * 1000;           // 10 minutes
-export const REFRESH_TOKEN_TTL = 7 * 24 * 60 * 60 * 1000; // 7 days