@sodax/dapp-kit 0.0.1-rc.3 → 0.0.1-rc.30

package/src/hooks/staking/useStakingConfig.ts

@@ -0,0 +1,40 @@
+// packages/dapp-kit/src/hooks/staking/useStakingConfig.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { StakingConfig } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for fetching staking configuration from the stakedSoda contract.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 30000)
+ * @returns {UseQueryResult<StakingConfig, Error>} Query result object containing staking config and state
+ *
+ * @example
+ * ```typescript
+ * const { data: stakingConfig, isLoading, error } = useStakingConfig();
+ *
+ * if (isLoading) return <div>Loading staking config...</div>;
+ * if (stakingConfig) {
+ *   console.log('Unstaking period (days):', stakingConfig.unstakingPeriod / 86400n);
+ *   console.log('Max penalty (%):', stakingConfig.maxPenalty);
+ * }
+ * ```
+ */
+export function useStakingConfig(refetchInterval = 30000): UseQueryResult<StakingConfig, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'stakingConfig'],
+    queryFn: async () => {
+      const result = await sodax.staking.getStakingConfig();
+
+      if (!result.ok) {
+        throw new Error(`Failed to fetch staking config: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    refetchInterval,
+  });
+}

package/src/hooks/staking/useStakingInfo.ts

@@ -0,0 +1,50 @@
+// packages/dapp-kit/src/hooks/staking/useStakingInfo.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { StakingInfo, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for fetching comprehensive staking information for a user.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the query
+ * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 5000)
+ * @returns {UseQueryResult<StakingInfo, Error>} Query result object containing staking info and state
+ *
+ * @example
+ * ```typescript
+ * const { data: stakingInfo, isLoading, error } = useStakingInfo(spokeProvider);
+ *
+ * if (isLoading) return <div>Loading staking info...</div>;
+ * if (stakingInfo) {
+ *   console.log('Total staked:', stakingInfo.totalStaked);
+ *   console.log('User staked:', stakingInfo.userStaked);
+ *   console.log('xSODA balance:', stakingInfo.userXSodaBalance);
+ * }
+ * ```
+ */
+export function useStakingInfo(
+  spokeProvider: SpokeProvider | undefined,
+  refetchInterval = 5000,
+): UseQueryResult<StakingInfo, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'stakingInfo', spokeProvider?.chainConfig.chain.id],
+    queryFn: async () => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      const result = await sodax.staking.getStakingInfoFromSpoke(spokeProvider);
+
+      if (!result.ok) {
+        throw new Error(`Failed to fetch staking info: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    enabled: !!spokeProvider,
+    refetchInterval,
+  });
+}

package/src/hooks/staking/useUnstake.ts

@@ -0,0 +1,54 @@
+// packages/dapp-kit/src/hooks/staking/useUnstake.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { UnstakeParams, SpokeTxHash, HubTxHash, SpokeProvider } from '@sodax/sdk';
+import { useMutation, useQueryClient, type UseMutationResult } from '@tanstack/react-query';
+
+/**
+ * Hook for executing unstake transactions to unstake xSODA shares.
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the unstake
+ * @returns {UseMutationResult<[SpokeTxHash, HubTxHash], Error, Omit<UnstakeParams, 'action'>>} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: unstake, isPending } = useUnstake(spokeProvider);
+ *
+ * const handleUnstake = async () => {
+ *   const result = await unstake({
+ *     amount: 1000000000000000000n, // 1 xSODA
+ *     account: '0x...'
+ *   });
+ *
+ *   console.log('Unstake successful:', result);
+ * };
+ * ```
+ */
+export function useUnstake(
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<[SpokeTxHash, HubTxHash], Error, Omit<UnstakeParams, 'action'>> {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  return useMutation<[SpokeTxHash, HubTxHash], Error, Omit<UnstakeParams, 'action'>>({
+    mutationFn: async (params: Omit<UnstakeParams, 'action'>) => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      const result = await sodax.staking.unstake({ ...params, action: 'unstake' }, spokeProvider);
+
+      if (!result.ok) {
+        throw new Error(`Unstake failed: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    onSuccess: () => {
+      // Invalidate relevant queries to refresh data
+      queryClient.invalidateQueries({ queryKey: ['stakingInfo'] });
+      queryClient.invalidateQueries({ queryKey: ['unstakingInfo'] });
+      queryClient.invalidateQueries({ queryKey: ['unstakingInfoWithPenalty'] });
+    },
+  });
+}

package/src/hooks/staking/useUnstakeAllowance.ts

@@ -0,0 +1,58 @@
+// packages/dapp-kit/src/hooks/staking/useStakeAllowance.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { UnstakeParams, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for checking xSODA token allowance for unstaking operations.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {Omit<UnstakeParams, 'action'> | undefined} params - The unstaking parameters. If undefined, the query will be disabled.
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the allowance check
+ * @returns {UseQueryResult<boolean, Error>} Query result object containing allowance data and state
+ *
+ * @example
+ * ```typescript
+ * const { data: hasAllowed, isLoading } = useUnstakeAllowance(
+ *   {
+ *     amount: 1000000000000000000n, // 1 xSODA
+ *     account: '0x...'
+ *   },
+ *   spokeProvider
+ * );
+ *
+ * if (isLoading) return <div>Checking allowance...</div>;
+ * if (hasAllowed) {
+ *   console.log('Sufficient allowance for unstaking');
+ * }
+ * ```
+ */
+export function useUnstakeAllowance(
+  params: Omit<UnstakeParams, 'action'> | undefined,
+  spokeProvider: SpokeProvider | undefined,
+): UseQueryResult<boolean, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'unstakeAllowance', params, spokeProvider?.chainConfig.chain.id],
+    queryFn: async () => {
+      if (!params || !spokeProvider) {
+        return false;
+      }
+
+      const result = await sodax.staking.isAllowanceValid({
+        params: { ...params, action: 'unstake' },
+        spokeProvider,
+      });
+
+      if (!result.ok) {
+        console.error(`Unstake allowance check failed: ${result.error.code}, error: ${result.error.error}`);
+        throw new Error(`Unstake allowance check failed: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    enabled: !!params && !!spokeProvider,
+    refetchInterval: 5000, // Refetch every 5 seconds
+  });
+}

package/src/hooks/staking/useUnstakeApprove.ts

@@ -0,0 +1,52 @@
+// packages/dapp-kit/src/hooks/staking/useStakeApprove.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { TxReturnType, UnstakeParams } from '@sodax/sdk';
+import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+import type { SpokeProvider } from '@sodax/sdk';
+
+/**
+ * Hook for approving xSODA token spending for unstaking operations.
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the approval
+ * @returns {UseMutationResult<TxReturnType<SpokeProvider, false>, Error, Omit<UnstakeParams, 'action'>>} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: approve, isPending } = useUnstakeApprove(spokeProvider);
+ *
+ * const handleApprove = async () => {
+ *   const result = await approve({
+ *     amount: 1000000000000000000n, // 1 xSODA
+ *     account: '0x...'
+ *   });
+ *
+ *   console.log('Approval successful:', result);
+ * };
+ * ```
+ */
+export function useUnstakeApprove(
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<TxReturnType<SpokeProvider, false>, Error, Omit<UnstakeParams, 'action'>> {
+  const { sodax } = useSodaxContext();
+
+  return useMutation<TxReturnType<SpokeProvider, false>, Error, Omit<UnstakeParams, 'action'>>({
+    mutationFn: async (params: Omit<UnstakeParams, 'action'>) => {
+      console.log('useUnstakeApprove called with params:', params);
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      const result = await sodax.staking.approve({
+        params: { ...params, action: 'unstake' },
+        spokeProvider,
+      });
+
+      if (!result.ok) {
+        throw new Error(`Unstake approval failed: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+  });
+}

package/src/hooks/staking/useUnstakingInfo.ts

@@ -0,0 +1,53 @@
+// packages/dapp-kit/src/hooks/staking/useUnstakingInfoWithPenalty.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { UnstakingInfo, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for fetching unstaking information from the stakedSoda contract.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {string | undefined} userAddress - The user address to fetch unstaking info for
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider instance
+ * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 5000)
+ * @returns {UseQueryResult<UnstakingInfo, Error>} Query result object containing unstaking info and state
+ *
+ * @example
+ * ```typescript
+ * const { data: unstakingInfo, isLoading, error } = useUnstakingInfo(userAddress, spokeProvider);
+ *
+ * if (isLoading) return <div>Loading unstaking info...</div>;
+ * if (unstakingInfo) {
+ *   console.log('Total unstaking:', unstakingInfo.totalUnstaking);
+ *   unstakingInfo.userUnstakeSodaRequests.forEach(request => {
+ *     console.log('Request amount:', request.request.amount);
+ *   });
+ * }
+ * ```
+ */
+export function useUnstakingInfo(
+  userAddress: string | undefined,
+  spokeProvider: SpokeProvider | undefined,
+  refetchInterval = 5000,
+): UseQueryResult<UnstakingInfo, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'unstakingInfoWithPenalty', spokeProvider?.chainConfig.chain.id, userAddress],
+    queryFn: async () => {
+      if (!spokeProvider || !userAddress) {
+        throw new Error('Spoke provider or user address not found');
+      }
+
+      const result = await sodax.staking.getUnstakingInfo(spokeProvider);
+
+      if (!result.ok) {
+        throw new Error(`Failed to fetch unstaking info: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    enabled: !!spokeProvider && !!userAddress,
+    refetchInterval,
+  });
+}

package/src/hooks/staking/useUnstakingInfoWithPenalty.ts

@@ -0,0 +1,59 @@
+// packages/dapp-kit/src/hooks/staking/useUnstakingInfoWithPenalty.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { UnstakingInfo, UnstakeRequestWithPenalty, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+export type UnstakingInfoWithPenalty = UnstakingInfo & {
+  requestsWithPenalty: UnstakeRequestWithPenalty[];
+};
+
+/**
+ * Hook for fetching unstaking information with penalty calculations from the stakedSoda contract.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {string | undefined} userAddress - The user address to fetch unstaking info for
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider instance
+ * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 5000)
+ * @returns {UseQueryResult<UnstakingInfoWithPenalty, Error>} Query result object containing unstaking info with penalties and state
+ *
+ * @example
+ * ```typescript
+ * const { data: unstakingInfo, isLoading, error } = useUnstakingInfoWithPenalty(userAddress, spokeProvider);
+ *
+ * if (isLoading) return <div>Loading unstaking info...</div>;
+ * if (unstakingInfo) {
+ *   console.log('Total unstaking:', unstakingInfo.totalUnstaking);
+ *   unstakingInfo.requestsWithPenalty.forEach(request => {
+ *     console.log('Penalty:', request.penaltyPercentage + '%');
+ *     console.log('Claimable amount:', request.claimableAmount);
+ *   });
+ * }
+ * ```
+ */
+export function useUnstakingInfoWithPenalty(
+  userAddress: string | undefined,
+  spokeProvider: SpokeProvider | undefined,
+  refetchInterval = 5000,
+): UseQueryResult<UnstakingInfoWithPenalty, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'unstakingInfoWithPenalty', spokeProvider?.chainConfig.chain.id, userAddress],
+    queryFn: async () => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      // Get unstaking info with penalty calculations
+      const penaltyResult = await sodax.staking.getUnstakingInfoWithPenalty(spokeProvider);
+
+      if (!penaltyResult.ok) {
+        throw new Error(`Failed to fetch unstaking info with penalty: ${penaltyResult.error.code}`);
+      }
+
+      return penaltyResult.value;
+    },
+    enabled: !!spokeProvider && !!userAddress,
+    refetchInterval,
+  });
+}

package/src/hooks/swap/index.ts

@@ -1,3 +1,6 @@
 export * from './useQuote';
-export * from './useCreateIntentOrder';
+export * from './useSwap';
 export * from './useStatus';
+export * from './useSwapAllowance';
+export * from './useSwapApprove';
+export * from './useCancelSwap';

package/src/hooks/swap/useCancelSwap.ts

@@ -0,0 +1,44 @@
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { Intent, Result, SpokeProvider, TxReturnType } from '@sodax/sdk';
+import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+
+type CancelIntentParams = {
+  intent: Intent;
+  raw?: boolean;
+};
+
+type CancelIntentResult = Result<TxReturnType<SpokeProvider, boolean>>;
+
+/**
+ * Hook for canceling a swap intent order.
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for canceling the intent
+ * @returns {UseMutationResult} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: cancelSwap, isPending } = useCancelSwap(spokeProvider);
+ *
+ * const handleCancelSwap = async () => {
+ *   const result = await cancelSwap({
+ *     intent: intentObject,
+ *     raw: false // optional, defaults to false
+ *   });
+ * };
+ * ```
+ */
+export function useCancelSwap(
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<CancelIntentResult, Error, CancelIntentParams> {
+  const { sodax } = useSodaxContext();
+
+  return useMutation<CancelIntentResult, Error, CancelIntentParams>({
+    mutationFn: async ({ intent, raw = false }: CancelIntentParams) => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+      return sodax.solver.cancelIntent(intent, spokeProvider, raw);
+    },
+  });
+}

package/src/hooks/swap/useQuote.ts

@@ -1,15 +1,16 @@
-import type { IntentErrorResponse, IntentQuoteRequest, IntentQuoteResponse, Result } from '@sodax/sdk';
+import type { SolverErrorResponse, SolverIntentQuoteRequest, SolverIntentQuoteResponse, Result } from '@sodax/sdk';
 import { useSodaxContext } from '../shared/useSodaxContext';
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
 
 /**
  * Hook for fetching a quote for an intent-based swap.
  *
  * This hook provides real-time quote data for an intent-based swap.
  *
- * @param {IntentQuoteRequest | undefined} payload - The intent quote request parameters. If undefined, the query will be disabled.
+ * @param {SolverIntentQuoteRequest | undefined} payload - The intent quote request parameters. If undefined, the query will be disabled.
  *
- * @returns {UseQueryResult<Result<IntentQuoteResponse, IntentErrorResponse> | undefined>} A query result object containing:
+ * @returns {UseQueryResult<Result<SolverIntentQuoteResponse, SolverErrorResponse> | undefined>} A query result object containing:
  *   - data: The quote result from the solver
  *   - isLoading: Boolean indicating if the quote is being fetched
  *   - error: Error object if the quote request failed
@@ -38,11 +39,24 @@ import { useQuery, type UseQueryResult } from '@tanstack/react-query';
  * - Uses React Query for efficient caching and state management
  */
 export const useQuote = (
-  payload: IntentQuoteRequest | undefined,
-): UseQueryResult<Result<IntentQuoteResponse, IntentErrorResponse> | undefined> => {
+  payload: SolverIntentQuoteRequest | undefined,
+): UseQueryResult<Result<SolverIntentQuoteResponse, SolverErrorResponse> | undefined> => {
   const { sodax } = useSodaxContext();
+  
+  // Create a serializable query key by converting BigInt to string
+  const queryKey = useMemo(() => {
+    if (!payload) return ['quote', undefined];
+    return [
+      'quote',
+      {
+        ...payload,
+        amount: payload.amount.toString(),
+      },
+    ];
+  }, [payload]);
+
   return useQuery({
-    queryKey: [payload],
+    queryKey,
     queryFn: async () => {
       if (!payload) {
         return undefined;

package/src/hooks/swap/useStatus.ts

@@ -1,4 +1,4 @@
-import type { Hex, IntentErrorResponse, IntentStatusResponse, Result } from '@sodax/sdk';
+import type { Hex, SolverErrorResponse, SolverIntentStatusResponse, Result } from '@sodax/sdk';
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
@@ -9,7 +9,7 @@ import { useSodaxContext } from '../shared/useSodaxContext';
  *
  * @param {Hex} intent_tx_hash - The transaction hash of the intent order on the hub chain
  *
- * @returns {UseQueryResult<Result<IntentStatusResponse, IntentErrorResponse> | undefined>} A query result object containing:
+ * @returns {UseQueryResult<Result<SolverIntentStatusResponse, SolverErrorResponse> | undefined>} A query result object containing:
  *   - data: The status result from the solver
  *   - isLoading: Boolean indicating if the status is being fetched
  *   - error: Error object if the status request failed
@@ -32,7 +32,7 @@ import { useSodaxContext } from '../shared/useSodaxContext';
 
 export const useStatus = (
   intent_tx_hash: Hex,
-): UseQueryResult<Result<IntentStatusResponse, IntentErrorResponse> | undefined> => {
+): UseQueryResult<Result<SolverIntentStatusResponse, SolverErrorResponse> | undefined> => {
   const { sodax } = useSodaxContext();
   return useQuery({
     queryKey: [intent_tx_hash],

package/src/hooks/swap/{useCreateIntentOrder.ts → useSwap.ts}

@@ -1,35 +1,31 @@
 import { useSodaxContext } from '../shared/useSodaxContext';
 import type {
   CreateIntentParams,
-  SpokeChainId,
-  IntentExecutionResponse,
+  SolverExecutionResponse,
   Result,
-  IntentSubmitErrorCode,
+  IntentErrorCode,
   Intent,
-  PacketData,
-  IntentSubmitError,
+  IntentError,
+  SpokeProvider,
+  IntentDeliveryInfo,
 } from '@sodax/sdk';
-import { useSpokeProvider } from '../provider/useSpokeProvider';
-import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+import { useMutation, type UseMutationResult, useQueryClient } from '@tanstack/react-query';
 
-type CreateIntentResult = Result<
-  [IntentExecutionResponse, Intent, PacketData],
-  IntentSubmitError<IntentSubmitErrorCode>
->;
+type CreateIntentResult = Result<[SolverExecutionResponse, Intent, IntentDeliveryInfo], IntentError<IntentErrorCode>>;
 
 /**
- * Hook for creating and submitting an intent order for cross-chain swaps.
+ * Hook for creating and submitting an swap intent order for cross-chain swaps.
  * Uses React Query's useMutation for better state management and caching.
  *
- * @param {SpokeChainId} chainId - The source chain ID where the swap will originate
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the swap
  * @returns {UseMutationResult} Mutation result object containing mutation function and state
  *
  * @example
  * ```typescript
- * const { mutateAsync: createIntent, isPending } = useCreateIntentOrder('0xa4b1.arbitrum');
+ * const { mutateAsync: swap, isPending } = useSwap(spokeProvider);
  *
  * const handleSwap = async () => {
- *   const result = await createIntent({
+ *   const result = await swap({
  *     token_src: '0x...',
  *     token_src_blockchain_id: 'arbitrum',
  *     token_dst: '0x...',
@@ -40,18 +36,25 @@ type CreateIntentResult = Result<
  * };
  * ```
  */
-export function useCreateIntentOrder(
-  chainId: SpokeChainId,
+export function useSwap(
+  spokeProvider: SpokeProvider | undefined,
 ): UseMutationResult<CreateIntentResult, Error, CreateIntentParams> {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(chainId);
+  const queryClient = useQueryClient();
 
   return useMutation<CreateIntentResult, Error, CreateIntentParams>({
     mutationFn: async (params: CreateIntentParams) => {
       if (!spokeProvider) {
         throw new Error('Spoke provider not found');
       }
-      return sodax.solver.createAndSubmitIntent(params, spokeProvider);
+      return sodax.solver.swap({
+        intentParams: params,
+        spokeProvider,
+      });
+    },
+    onSuccess: () => {
+      // Invalidate balance queries to refresh both source and destination token balances
+      queryClient.invalidateQueries({ queryKey: ['xBalances'] });
     },
   });
 }

package/src/hooks/swap/useSwapAllowance.ts

@@ -0,0 +1,48 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { CreateIntentParams, SpokeProvider } from '@sodax/sdk';
+
+/**
+ * Hook for checking token allowance for money market operations.
+ *
+ * This hook verifies if the user has approved enough tokens for a specific money market action
+ * (borrow/repay). It automatically queries and tracks the allowance status.
+ *
+ * @param {CreateIntentParams} params - The parameters for the intent to check allowance for.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for allowance checks
+ *
+ * @returns {UseQueryResult<boolean, Error>} A React Query result containing:
+ *   - data: Boolean indicating if allowance is sufficient
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during the check
+ *
+ * @example
+ * ```typescript
+ * const { data: hasAllowed, isLoading } = useMMAllowance(params, spokeProvider);
+ * ```
+ */
+export function useSwapAllowance(
+  params: CreateIntentParams | undefined,
+  spokeProvider: SpokeProvider | undefined,
+): UseQueryResult<boolean, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['allowance', params],
+    queryFn: async () => {
+      if (!spokeProvider || !params) {
+        return false;
+      }
+      const allowance = await sodax.solver.isAllowanceValid({
+        intentParams: params,
+        spokeProvider,
+      });
+      if (allowance.ok) {
+        return allowance.value;
+      }
+      return false;
+    },
+    enabled: !!spokeProvider && !!params,
+    refetchInterval: 2000,
+  });
+}