@sodax/dapp-kit 1.0.1-beta-rc3 → 1.0.2-beta

package/src/hooks/mm/useReservesUsdFormat.ts

@@ -1,37 +1,46 @@
 import type { FormatReserveUSDResponse, ReserveData } from '@sodax/sdk';
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
+export type UseReservesUsdFormatParams = {
+  queryOptions?: UseQueryOptions<
+    (ReserveData & { priceInMarketReferenceCurrency: string } & FormatReserveUSDResponse)[],
+    Error
+  >;
+};
+
 /**
- * Hook for fetching formatted summary of Sodax user portfolio (holdings, total liquidity,
- *  collateral, borrows, liquidation threshold, health factor, available borrowing power, etc..).
+ * Hook for fetching reserves data formatted with USD values in the Sodax money market.
  *
- * This hook provides access to the current state of user portfolio in the money market protocol.
- * The data is automatically fetched and cached using React Query.
+ * This hook returns an array of reserve objects, each extended with its price in the market reference
+ * currency and formatted USD values. Data is automatically fetched and cached using React Query.
  *
- * @example
- * ```typescript
- * const { data: userFormattedSummary, isLoading, error } = useUserFormattedSummary();
- * ```
+ * @param params (optional) - Object including:
+ *   - queryOptions: Custom React Query options such as `queryKey`, cache behavior, or refetching policy.
+ *
+ * @returns {UseQueryResult<(ReserveData & { priceInMarketReferenceCurrency: string } & FormatReserveUSDResponse)[], Error>} React Query result object containing:
+ *   - data: Array of reserves with USD-formatted values, or undefined if loading
+ *   - isLoading: Boolean loading state
+ *   - isError: Boolean error state
+ *   - error: Error object, if present
  *
- * @returns A React Query result object containing:
- *   - data: The formatted summary of Sodax user portfolio when available
- *   - isLoading: Loading state indicator
- *   - error: Any error that occurred during data fetching
+ * @example
+ * const { data: reservesUSD, isLoading, error } = useReservesUsdFormat();
  */
-export function useReservesUsdFormat(): UseQueryResult<
-  (ReserveData & { priceInMarketReferenceCurrency: string } & FormatReserveUSDResponse)[],
-  Error
-> {
+export function useReservesUsdFormat(
+  params?: UseReservesUsdFormatParams,
+): UseQueryResult<(ReserveData & { priceInMarketReferenceCurrency: string } & FormatReserveUSDResponse)[], Error> {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = { queryKey: ['mm', 'reservesUsdFormat'] };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions, // override default query options if provided
+  };
 
   return useQuery({
-    queryKey: ['reservesUsdFormat'],
+    ...queryOptions,
     queryFn: async () => {
-      // fetch reserves and hub wallet address
       const reserves = await sodax.moneyMarket.data.getReservesHumanized();
-
-      // format reserves
       return sodax.moneyMarket.data.formatReservesUSD(sodax.moneyMarket.data.buildReserveDataWithPrice(reserves));
     },
   });

package/src/hooks/mm/useSupply.ts

@@ -1,7 +1,5 @@
-import type { SpokeProvider } from '@sodax/sdk';
-import type { SpokeChainId, XToken } from '@sodax/types';
+import type { MoneyMarketError, MoneyMarketSupplyParams, RelayErrorCode, SpokeProvider } from '@sodax/sdk';
 import { useMutation, type UseMutationResult } from '@tanstack/react-query';
-import { parseUnits } from 'viem';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
 interface SupplyResponse {
@@ -9,58 +7,58 @@ interface SupplyResponse {
   value: [string, string];
 }
 
+export type UseSupplyParams = {
+  params: MoneyMarketSupplyParams;
+  spokeProvider: SpokeProvider;
+};
+
 /**
- * Hook for supplying tokens to the Sodax money market.
- *
- * This hook provides functionality to supply tokens to the money market protocol,
- * handling the entire supply process including transaction creation, submission,
- * and cross-chain communication.
+ * React hook for supplying tokens to the Sodax money market protocol.
  *
- * @param {XToken} spokeToken - The token to supply on the spoke chain. Must be an XToken with valid address and chain information.
- * @param {SpokeProvider} spokeProvider - The spoke provider to use for the supply transaction. Must be a valid SpokeProvider instance.
+ * Provides a mutation for performing the supply operation using React Query. Useful
+ * for UI components needing to manage the full state (pending, error, etc.) of a supply
+ * transaction. It handles transaction creation, cross-chain logic, and errors.
  *
- * @returns {UseMutationResult<SupplyResponse, Error, string>} A mutation result object with the following properties:
- *   - mutateAsync: Function to execute the supply transaction
- *   - isPending: Boolean indicating if a transaction is in progress
- *   - error: Error object if the last transaction failed, null otherwise
+ * @returns {UseMutationResult<SupplyResponse, MoneyMarketError<'CREATE_SUPPLY_INTENT_FAILED' | 'SUPPLY_UNKNOWN_ERROR' | RelayErrorCode>, UseSupplyParams>}
+ *   Mutation result object from React Query, where:
+ *   - mutateAsync(params: UseSupplyParams): Promise<SupplyResponse>
+ *     Initiates a supply transaction using the given MoneyMarketSupplyParams and SpokeProvider.
+ *   - isPending: boolean indicating if a transaction is in progress.
+ *   - error: MoneyMarketError if an error occurred while supplying, otherwise undefined.
  *
  * @example
  * ```typescript
- * const { mutateAsync: supply, isPending, error } = useSupply(spokeToken);
- * await supply('100');
+ * const { mutateAsync: supply, isPending, error } = useSupply();
+ * await supply({ params: supplyParams, spokeProvider });
  * ```
  *
- * @throws {Error} When:
- *   - spokeProvider is not available
+ * @throws {Error|MoneyMarketError<...>} When:
+ *   - `spokeProvider` is not provided or invalid.
+ *   - The underlying supply transaction fails.
  */
-export function useSupply(
-  spokeToken: XToken,
-  spokeProvider: SpokeProvider | undefined,
-): UseMutationResult<SupplyResponse, Error, string> {
+export function useSupply(): UseMutationResult<
+  SupplyResponse,
+  MoneyMarketError<'CREATE_SUPPLY_INTENT_FAILED' | 'SUPPLY_UNKNOWN_ERROR' | RelayErrorCode>,
+  UseSupplyParams
+> {
   const { sodax } = useSodaxContext();
 
-  return useMutation<SupplyResponse, Error, string>({
-    mutationFn: async (amount: string, toChainId?: SpokeChainId, toAddress?: string) => {
+  return useMutation<
+    SupplyResponse,
+    MoneyMarketError<'CREATE_SUPPLY_INTENT_FAILED' | 'SUPPLY_UNKNOWN_ERROR' | RelayErrorCode>,
+    UseSupplyParams
+  >({
+    mutationFn: async ({ params, spokeProvider }: UseSupplyParams) => {
       if (!spokeProvider) {
         throw new Error('spokeProvider is not found');
       }
 
-      const response = await sodax.moneyMarket.supply(
-        {
-          token: spokeToken.address,
-          amount: parseUnits(amount, spokeToken.decimals),
-          action: 'supply',
-          toChainId: toChainId,
-          toAddress: toAddress,
-        },
-        spokeProvider,
-      );
+      const response = await sodax.moneyMarket.supply(params, spokeProvider);
 
       if (!response.ok) {
-        throw new Error('Failed to supply tokens');
+        throw response.error;
       }
 
-      console.log('Supply transaction submitted:', response);
       return response;
     },
   });

package/src/hooks/mm/useUserFormattedSummary.ts

@@ -1,34 +1,58 @@
 import type { FormatUserSummaryResponse, FormatReserveUSDResponse, SpokeProvider } from '@sodax/sdk';
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
+export type UseUserFormattedSummaryParams = {
+  spokeProvider?: SpokeProvider;
+  address?: string;
+  queryOptions?: UseQueryOptions<FormatUserSummaryResponse<FormatReserveUSDResponse>, Error>;
+};
+
 /**
- * Hook for fetching formatted summary of Sodax user portfolio (holdings, total liquidity,
- *  collateral, borrows, liquidation threshold, health factor, available borrowing power, etc..).
+ * React hook to fetch a formatted summary of a user's Sodax money market portfolio.
  *
- * This hook provides access to the current state of user portfolio in the money market protocol.
- * The data is automatically fetched and cached using React Query.
+ * Accepts an optional params object:
+ *   - `spokeProvider`: The SpokeProvider instance for the target chain
+ *   - `address`: The user wallet address to get the summary for
+ *   - `queryOptions`: Optional React Query options (key, caching, intervals, etc)
  *
- * @example
- * ```typescript
- * const { data: userFormattedSummary, isLoading, error } = useUserFormattedSummary(spokeProvider, address);
- * ```
+ * The hook returns a React Query result object containing the formatted summary, loading and error state.
+ * The query is enabled only if both the spokeProvider and address are provided.
+ *
+ * @param params Optional parameters:
+ *   - spokeProvider: SpokeProvider to query chain data (required for enabled query)
+ *   - address: User account address (required for enabled query)
+ *   - queryOptions: React Query options for customization (optional)
+ *
+ * @returns {UseQueryResult<FormatUserSummaryResponse<FormatReserveUSDResponse>, Error>}
+ *   A result object from React Query including:
+ *     - data: The user's formatted portfolio summary (or undefined if not loaded)
+ *     - isLoading: Boolean loading state
+ *     - isError: Boolean error state
+ *     - error: Error if thrown in fetching
  *
- * @returns A React Query result object containing:
- *   - data: The formatted summary of Sodax user portfolio when available
- *   - isLoading: Loading state indicator
- *   - error: Any error that occurred during data fetching
+ * @example
+ * const { data, isLoading, error } = useUserFormattedSummary({ spokeProvider, address });
  */
 export function useUserFormattedSummary(
-  spokeProvider: SpokeProvider | undefined,
-  address: string | undefined,
+  params?: UseUserFormattedSummaryParams,
 ): UseQueryResult<FormatUserSummaryResponse<FormatReserveUSDResponse>, Error> {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ['mm', 'userFormattedSummary', params?.spokeProvider?.chainConfig.chain.id, params?.address],
+    enabled: !!params?.spokeProvider && !!params?.address,
+    refetchInterval: 5000,
+  };
+
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions, // override default query options if provided
+  }
 
   return useQuery({
-    queryKey: ['userFormattedSummary', spokeProvider?.chainConfig.chain.id, address],
+    ...queryOptions,
     queryFn: async () => {
-      if (!spokeProvider || !address) {
+      if (!params?.spokeProvider || !params?.address) {
         throw new Error('Spoke provider or address is not defined');
       }
 
@@ -41,14 +65,12 @@ export function useUserFormattedSummary(
       );
 
       // fetch user reserves
-      const userReserves = await sodax.moneyMarket.data.getUserReservesHumanized(spokeProvider);
+      const userReserves = await sodax.moneyMarket.data.getUserReservesHumanized(params?.spokeProvider);
 
       // format user summary
       return sodax.moneyMarket.data.formatUserSummary(
         sodax.moneyMarket.data.buildUserSummaryRequest(reserves, formattedReserves, userReserves),
       );
     },
-    enabled: !!spokeProvider && !!address,
-    refetchInterval: 5000,
   });
 }

package/src/hooks/mm/useUserReservesData.ts

@@ -1,40 +1,55 @@
 import type { SpokeProvider, UserReserveData } from '@sodax/sdk';
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
+export type UseUserReservesDataParams = {
+  spokeProvider: SpokeProvider | undefined;
+  address: string | undefined;
+  queryOptions?: UseQueryOptions<readonly [readonly UserReserveData[], number], Error>;
+};
+
 /**
  * Hook for fetching user reserves data from the Sodax money market.
  *
- * This hook provides access to the current state of user reserves in the money market protocol.
- * The data is automatically fetched and cached using React Query.
+ * @param params (optional) - Object including:
+ *   - spokeProvider: The SpokeProvider instance required for data fetching. If not provided, data fetching is disabled.
+ *   - address: The user's address (string) whose reserves data will be fetched. If not provided, data fetching is disabled.
+ *   - queryOptions: (optional) Custom React Query options such as `queryKey`, `enabled`, or cache policy.
  *
- * @example
- * ```typescript
- * const { data: userReservesData, isLoading, error } = useUserReservesData(spokeProvider, address);
- * ```
+ * @returns {UseQueryResult<readonly [readonly UserReserveData[], number], Error>} React Query result object containing:
+ *   - data: A tuple with array of UserReserveData and associated number, or undefined if loading
+ *   - isLoading: Boolean loading state
+ *   - isError: Boolean error state
+ *   - error: Error object, if present
  *
- * @returns A React Query result object containing:
- *   - data: The user reserves data when available
- *   - isLoading: Loading state indicator
- *   - error: Any error that occurred during data fetching
+ * @example
+ * const { data: userReservesData, isLoading, error } = useUserReservesData({
+ *   spokeProvider,
+ *   address,
+ * });
  */
 export function useUserReservesData(
-  spokeProvider: SpokeProvider | undefined,
-  address: string | undefined,
-  refetchInterval = 5000,
+  params?: UseUserReservesDataParams,
 ): UseQueryResult<readonly [readonly UserReserveData[], number], Error> {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions =  {
+    queryKey: ['mm', 'userReservesData', params?.spokeProvider?.chainConfig.chain.id, params?.address],
+    enabled: !!params?.spokeProvider && !!params?.address,
+    refetchInterval: 5000,
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions,  // override default query options if provided
+  };
 
   return useQuery({
-    queryKey: ['userReserves', spokeProvider?.chainConfig.chain.id, address],
+    ...queryOptions,
     queryFn: async () => {
-      if (!spokeProvider) {
+      if (!params?.spokeProvider || !params?.address) {
         throw new Error('Spoke provider or address is not defined');
       }
 
-      return await sodax.moneyMarket.data.getUserReservesData(spokeProvider);
+      return await sodax.moneyMarket.data.getUserReservesData(params.spokeProvider);
     },
-    enabled: !!spokeProvider && !!address,
-    refetchInterval,
   });
 }

package/src/hooks/mm/useWithdraw.ts

@@ -1,66 +1,64 @@
-import type { SpokeProvider } from '@sodax/sdk';
-import type { SpokeChainId, XToken } from '@sodax/types';
+import type { MoneyMarketError, MoneyMarketWithdrawParams, RelayErrorCode, SpokeProvider } from '@sodax/sdk';
 import { useMutation, type UseMutationResult } from '@tanstack/react-query';
-import { parseUnits } from 'viem';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
+export type UseWithdrawParams = {
+  params: MoneyMarketWithdrawParams;
+  spokeProvider: SpokeProvider;
+};
+
 interface WithdrawResponse {
   ok: true;
   value: [string, string];
 }
 
 /**
- * Hook for withdrawing supplied tokens from the Sodax money market.
+ * Hook for performing withdrawals from the Sodax money market.
  *
- * This hook provides functionality to withdraw previously supplied tokens from the money market protocol,
- * handling the entire withdrawal process including transaction creation, submission,
- * and cross-chain communication.
+ * This hook exposes a mutation that executes the complete withdrawal logic, including transaction
+ * creation and handling cross-chain communication. It leverages React Query's mutation API for
+ * easy asynchronous handling and status tracking within UI components.
  *
- * @param {XToken} spokeToken - The token to withdraw from the spoke chain. Must be an XToken with valid address and chain information.
- * @param {SpokeProvider} spokeProvider - The spoke provider to use for the withdraw transaction. Must be a valid SpokeProvider instance.
+ * @returns {UseMutationResult<WithdrawResponse, MoneyMarketError<'CREATE_WITHDRAW_INTENT_FAILED' | 'WITHDRAW_UNKNOWN_ERROR' | RelayErrorCode>, UseWithdrawParams>}
+ *   Mutation result object, with:
+ *   - mutateAsync: (params: UseWithdrawParams) => Promise<WithdrawResponse>
+ *       Initiates the withdrawal using the provided params.
+ *   - isPending: boolean indicating if a transaction is in progress.
+ *   - error: MoneyMarketError if an error occurred while withdrawing, otherwise undefined.
  *
- * @returns {UseMutationResult<WithdrawResponse, Error, string>} A mutation result object with the following properties:
- *   - mutateAsync: Function to execute the withdraw transaction
- *   - isPending: Boolean indicating if a transaction is in progress
  * @example
  * ```typescript
- * const { mutateAsync: withdraw, isPending, error } = useWithdraw(spokeToken);
- * await withdraw('100');
+ * const { mutateAsync: withdraw, isPending, error } = useWithdraw();
+ * await withdraw({ params: withdrawParams, spokeProvider });
  * ```
  *
  * @throws {Error} When:
- *   - spokeProvider is not available
- *   - Transaction execution fails
+ *   - spokeProvider is not provided or invalid.
+ *   - Underlying withdrawal logic fails.
  */
-export function useWithdraw(
-  spokeToken: XToken,
-  spokeProvider: SpokeProvider | undefined,
-): UseMutationResult<WithdrawResponse, Error, string> {
+export function useWithdraw(): UseMutationResult<
+  WithdrawResponse,
+  MoneyMarketError<'CREATE_WITHDRAW_INTENT_FAILED' | 'WITHDRAW_UNKNOWN_ERROR' | RelayErrorCode>,
+  UseWithdrawParams
+> {
   const { sodax } = useSodaxContext();
 
-  return useMutation<WithdrawResponse, Error, string>({
-    mutationFn: async (amount: string, toChainId?: SpokeChainId, toAddress?: string) => {
+  return useMutation<
+    WithdrawResponse,
+    MoneyMarketError<'CREATE_WITHDRAW_INTENT_FAILED' | 'WITHDRAW_UNKNOWN_ERROR' | RelayErrorCode>,
+    UseWithdrawParams
+  >({
+    mutationFn: async ({ params, spokeProvider }) => {
       if (!spokeProvider) {
         throw new Error('spokeProvider is not found');
       }
 
-      const response = await sodax.moneyMarket.withdraw(
-        {
-          token: spokeToken.address,
-          // vault token on hub chain decimals is 18
-          amount: parseUnits(amount, 18),
-          action: 'withdraw',
-          toChainId: toChainId,
-          toAddress: toAddress,
-        },
-        spokeProvider,
-      );
+      const response = await sodax.moneyMarket.withdraw(params, spokeProvider);
 
       if (!response.ok) {
-        throw new Error('Failed to withdraw tokens');
+        throw response.error;
       }
 
-      console.log('Withdraw transaction submitted:', response);
       return response;
     },
   });

package/src/hooks/swap/index.ts

@@ -4,3 +4,5 @@ export * from './useStatus';
 export * from './useSwapAllowance';
 export * from './useSwapApprove';
 export * from './useCancelSwap';
+export * from './useCreateLimitOrder';
+export * from './useCancelLimitOrder';

package/src/hooks/swap/useCancelLimitOrder.ts

@@ -0,0 +1,53 @@
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { Intent, IntentError, IntentErrorCode, Result, SpokeProvider } from '@sodax/sdk';
+import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+
+type CancelLimitOrderParams = {
+  intent: Intent;
+  spokeProvider: SpokeProvider;
+  timeout?: number;
+};
+
+type CancelLimitOrderResult = Result<[string, string], IntentError<IntentErrorCode>>;
+
+/**
+ * Hook for canceling a limit order intent and submitting it to the Relayer API.
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * This hook wraps cancelLimitOrder which cancels the intent on the spoke chain,
+ * submits it to the relayer API, and waits for execution on the destination/hub chain.
+ *
+ * @returns {UseMutationResult} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: cancelLimitOrder, isPending } = useCancelLimitOrder();
+ *
+ * const handleCancelLimitOrder = async () => {
+ *   const result = await cancelLimitOrder({
+ *     intent: intentObject,
+ *     spokeProvider,
+ *     timeout: 60000 // optional, defaults to 60 seconds
+ *   });
+ *
+ *   if (result.ok) {
+ *     const [cancelTxHash, dstTxHash] = result.value;
+ *     console.log('Cancel transaction hash:', cancelTxHash);
+ *     console.log('Destination transaction hash:', dstTxHash);
+ *   }
+ * };
+ * ```
+ */
+export function useCancelLimitOrder(): UseMutationResult<CancelLimitOrderResult, Error, CancelLimitOrderParams> {
+  const { sodax } = useSodaxContext();
+
+  return useMutation<CancelLimitOrderResult, Error, CancelLimitOrderParams>({
+    mutationFn: async ({ intent, spokeProvider, timeout }: CancelLimitOrderParams): Promise<CancelLimitOrderResult> => {
+      return sodax.swaps.cancelLimitOrder({
+        intent,
+        spokeProvider,
+        timeout,
+      });
+    },
+  });
+}

package/src/hooks/swap/useCreateLimitOrder.ts

@@ -0,0 +1,72 @@
+import { useSodaxContext } from '../shared/useSodaxContext';
+import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+import type {
+  CreateLimitOrderParams,
+  SolverExecutionResponse,
+  Intent,
+  IntentError,
+  IntentErrorCode,
+  IntentDeliveryInfo,
+  Result,
+  SpokeProvider,
+} from '@sodax/sdk';
+
+type CreateLimitOrderResult = Result<
+  [SolverExecutionResponse, Intent, IntentDeliveryInfo],
+  IntentError<IntentErrorCode>
+>;
+
+/**
+ * Hook for creating a limit order intent (no deadline, must be cancelled manually by user).
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * Limit orders remain active until manually cancelled by the user. Unlike swaps, limit orders
+ * do not have a deadline (deadline is automatically set to 0n).
+ *
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for creating the limit order
+ * @returns {UseMutationResult} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: createLimitOrder, isPending } = useCreateLimitOrder(spokeProvider);
+ *
+ * const handleCreateLimitOrder = async () => {
+ *   const result = await createLimitOrder({
+ *     inputToken: '0x...',
+ *     outputToken: '0x...',
+ *     inputAmount: 1000000000000000000n,
+ *     minOutputAmount: 900000000000000000n,
+ *     allowPartialFill: false,
+ *     srcChain: '0xa4b1.arbitrum',
+ *     dstChain: '0x89.polygon',
+ *     srcAddress: '0x...',
+ *     dstAddress: '0x...',
+ *     solver: '0x0000000000000000000000000000000000000000',
+ *     data: '0x'
+ *   });
+ *
+ *   if (result.ok) {
+ *     const [solverExecutionResponse, intent, intentDeliveryInfo] = result.value;
+ *     console.log('Limit order created:', intent);
+ *     console.log('Intent hash:', solverExecutionResponse.intent_hash);
+ *   }
+ * };
+ * ```
+ */
+export function useCreateLimitOrder(
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<CreateLimitOrderResult, Error, CreateLimitOrderParams> {
+  const { sodax } = useSodaxContext();
+
+  return useMutation<CreateLimitOrderResult, Error, CreateLimitOrderParams>({
+    mutationFn: async (params: CreateLimitOrderParams) => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+      return sodax.swaps.createLimitOrder({
+        intentParams: params,
+        spokeProvider,
+      });
+    },
+  });
+}

package/src/hooks/swap/useSwapAllowance.ts

@@ -1,14 +1,14 @@
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext';
-import type { CreateIntentParams, SpokeProvider } from '@sodax/sdk';
+import type { CreateIntentParams, CreateLimitOrderParams, SpokeProvider } from '@sodax/sdk';
 
 /**
- * Hook for checking token allowance for money market operations.
+ * Hook for checking token allowance for swap 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.
+ * This hook verifies if the user has approved enough tokens for a specific swap action.
+ * It automatically queries and tracks the allowance status.
  *
- * @param {CreateIntentParams} params - The parameters for the intent to check allowance for.
+ * @param {CreateIntentParams | CreateLimitOrderParams} 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:
@@ -18,11 +18,11 @@ import type { CreateIntentParams, SpokeProvider } from '@sodax/sdk';
  *
  * @example
  * ```typescript
- * const { data: hasAllowed, isLoading } = useMMAllowance(params, spokeProvider);
+ * const { data: hasAllowed, isLoading } = useSwapAllowance(params, spokeProvider);
  * ```
  */
 export function useSwapAllowance(
-  params: CreateIntentParams | undefined,
+  params: CreateIntentParams | CreateLimitOrderParams | undefined,
   spokeProvider: SpokeProvider | undefined,
 ): UseQueryResult<boolean, Error> {
   const { sodax } = useSodaxContext();

package/src/hooks/swap/useSwapApprove.ts

@@ -1,17 +1,17 @@
 import { useSodaxContext } from '../shared/useSodaxContext';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
-import type { CreateIntentParams, SpokeProvider } from '@sodax/sdk';
+import type { CreateIntentParams, CreateLimitOrderParams, SpokeProvider } from '@sodax/sdk';
 
 interface UseApproveReturn {
-  approve: ({ params }: { params: CreateIntentParams }) => Promise<boolean>;
+  approve: ({ params }: { params: CreateIntentParams | CreateLimitOrderParams }) => Promise<boolean>;
   isLoading: boolean;
   error: Error | null;
   resetError: () => void;
 }
 
 /**
- * Hook for approving token spending for money market actions
- * @param token The token to approve spending for
+ * Hook for approving token spending for swap actions
+ * @param params The parameters for the intent to approve spending for
  * @param spokeProvider The spoke provider instance for the chain
  * @returns Object containing approve function, loading state, error state and reset function
  * @example
@@ -24,7 +24,7 @@ interface UseApproveReturn {
  */
 
 export function useSwapApprove(
-  params: CreateIntentParams | undefined,
+  params: CreateIntentParams | CreateLimitOrderParams | undefined,
   spokeProvider: SpokeProvider | undefined,
 ): UseApproveReturn {
   const { sodax } = useSodaxContext();
@@ -36,7 +36,7 @@ export function useSwapApprove(
     error,
     reset: resetError,
   } = useMutation({
-    mutationFn: async ({ params }: { params: CreateIntentParams | undefined }) => {
+    mutationFn: async ({ params }: { params: CreateIntentParams | CreateLimitOrderParams | undefined }) => {
       if (!spokeProvider) {
         throw new Error('Spoke provider not found');
       }