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

package/src/hooks/backend/useBackendMoneyMarketAsset.ts

@@ -1,27 +1,34 @@
 // packages/dapp-kit/src/hooks/backend/useMoneyMarketAsset.ts
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import type { MoneyMarketAsset } from '@sodax/sdk';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
+export type UseBackendMoneyMarketAssetParams = {
+  params: {
+    reserveAddress: string | undefined;
+  };
+  queryOptions?: UseQueryOptions<MoneyMarketAsset | undefined, Error>;
+};
+
 /**
- * Hook for fetching specific money market asset details from the backend API.
+ * React hook to fetch a specific money market asset from the backend API.
  *
- * This hook provides access to detailed information for a specific money market asset,
- * including reserve information, liquidity rates, borrow rates, and market statistics.
- * The data is automatically fetched and cached using React Query.
+ * @param params - The hook input parameter object (may be undefined):
+ *   - `params`: An object containing:
+ *       - `reserveAddress` (string | undefined): Reserve contract address to fetch asset details. Disables query if undefined or empty.
+ *   - `queryOptions` (optional): React Query options for advanced configuration (e.g. caching, staleTime, retry, etc.).
  *
- * @param {string | undefined} reserveAddress - The reserve contract address. If undefined, the query will be disabled.
- *
- * @returns {UseQueryResult<MoneyMarketAsset | undefined>} A query result object containing:
- *   - data: The money market asset data when available
- *   - isLoading: Boolean indicating if the request is in progress
- *   - error: Error object if the request failed
- *   - refetch: Function to manually trigger a data refresh
+ * @returns A React Query result object: {@link UseQueryResult} for {@link MoneyMarketAsset} or `undefined` on error or if disabled,
+ *   including:
+ *   - `data`: The money market asset (when available) or `undefined`.
+ *   - `isLoading`: Whether the query is running.
+ *   - `error`: An error encountered by the query (if any).
+ *   - `refetch`: Function to manually refetch the asset.
  *
  * @example
- * ```typescript
- * const { data: asset, isLoading, error } = useMoneyMarketAsset('0xabc...');
- *
+ * const { data: asset, isLoading, error } = useBackendMoneyMarketAsset({
+ *   params: { reserveAddress: '0xabc...' },
+ * });
  * if (isLoading) return <div>Loading asset...</div>;
  * if (error) return <div>Error: {error.message}</div>;
  * if (asset) {
@@ -29,29 +36,35 @@ import { useSodaxContext } from '../shared/useSodaxContext';
  *   console.log('Liquidity rate:', asset.liquidityRate);
  *   console.log('Variable borrow rate:', asset.variableBorrowRate);
  * }
- * ```
  *
  * @remarks
- * - The query is disabled when reserveAddress is undefined or empty
- * - Uses React Query for efficient caching and state management
- * - Automatically handles error states and loading indicators
- * - Returns comprehensive asset information for the specified reserve
+ * - Query is disabled if `params`, `params.params`, or `params.params.reserveAddress` is missing or empty.
+ * - Uses React Query for caching and background-state management.
+ * - Loading and error handling are managed automatically.
  */
 export const useBackendMoneyMarketAsset = (
-  reserveAddress: string | undefined,
-): UseQueryResult<MoneyMarketAsset | undefined> => {
+  params: UseBackendMoneyMarketAssetParams | undefined,
+): UseQueryResult<MoneyMarketAsset | undefined, Error> => {
   const { sodax } = useSodaxContext();
 
+  const defaultQueryOptions = {
+    queryKey: ['api', 'mm', 'asset', params?.params?.reserveAddress],
+    enabled: !!params?.params?.reserveAddress && params?.params?.reserveAddress.length > 0,
+    retry: 3,
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions,
+  };
+
   return useQuery({
-    queryKey: ['backend', 'moneymarket', 'asset', reserveAddress],
+    ...queryOptions,
     queryFn: async (): Promise<MoneyMarketAsset | undefined> => {
-      if (!reserveAddress) {
+      if (!params?.params?.reserveAddress) {
         return undefined;
       }
 
-      return sodax.backendApi.getMoneyMarketAsset(reserveAddress);
+      return sodax.backendApi.getMoneyMarketAsset(params.params.reserveAddress);
     },
-    enabled: !!reserveAddress && reserveAddress.length > 0,
-    retry: 3,
   });
 };

package/src/hooks/backend/useBackendMoneyMarketAssetBorrowers.ts

@@ -1,31 +1,36 @@
 // packages/dapp-kit/src/hooks/backend/useMoneyMarketAssetBorrowers.ts
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import type { MoneyMarketAssetBorrowers } from '@sodax/sdk';
 import { useSodaxContext } from '../shared/useSodaxContext';
+import type { BackendPaginationParams } from './types';
+
+export type UseBackendMoneyMarketAssetBorrowersParams = {
+  params: {
+    reserveAddress: string | undefined;
+  };
+  pagination: BackendPaginationParams;
+  queryOptions?: UseQueryOptions<MoneyMarketAssetBorrowers | undefined, Error>;
+};
 
 /**
- * Hook for fetching borrowers for a specific money market asset from the backend API.
- *
- * This hook provides access to the list of borrowers for a specific money market asset,
- * with pagination support. The data is automatically fetched and cached using React Query.
+ * React hook for fetching borrowers for a specific money market asset from the backend API with pagination.
  *
- * @param {Object} params - Parameters for fetching asset borrowers
- * @param {string | undefined} params.reserveAddress - The reserve contract address. If undefined, the query will be disabled.
- * @param {string} params.offset - The offset for pagination (number as string)
- * @param {string} params.limit - The limit for pagination (number as string)
+ * @param {UseBackendMoneyMarketAssetBorrowersParams | undefined} params - Query parameters:
+ *   - `params`: Object containing:
+ *       - `reserveAddress`: Reserve contract address for which to fetch borrowers, or `undefined` to disable query.
+ *   - `pagination`: Pagination controls with `offset` and `limit` (both required as strings).
+ *   - `queryOptions` (optional): React Query options to override defaults (e.g. `staleTime`, `enabled`, etc.).
  *
- * @returns {UseQueryResult<MoneyMarketAssetBorrowers | undefined>} A query result object containing:
- *   - data: The asset borrowers data when available
- *   - isLoading: Boolean indicating if the request is in progress
- *   - error: Error object if the request failed
- *   - refetch: Function to manually trigger a data refresh
+ * @returns {UseQueryResult<MoneyMarketAssetBorrowers | undefined, Error>} React Query result object including:
+ *   - `data`: The money market asset borrowers data, or `undefined` if not available.
+ *   - `isLoading`: Boolean indicating whether the query is loading.
+ *   - `error`: An Error instance if the request failed.
+ *   - `refetch`: Function to manually trigger a data refresh.
  *
  * @example
- * ```typescript
- * const { data: borrowers, isLoading, error } = useMoneyMarketAssetBorrowers({
- *   reserveAddress: '0xabc...',
- *   offset: '0',
- *   limit: '20'
+ * const { data: borrowers, isLoading, error } = useBackendMoneyMarketAssetBorrowers({
+ *   params: { reserveAddress: '0xabc...' },
+ *   pagination: { offset: '0', limit: '20' }
  * });
  *
  * if (isLoading) return <div>Loading borrowers...</div>;
@@ -34,34 +39,38 @@ import { useSodaxContext } from '../shared/useSodaxContext';
  *   console.log('Total borrowers:', borrowers.total);
  *   console.log('Borrowers:', borrowers.borrowers);
  * }
- * ```
  *
  * @remarks
- * - The query is disabled when reserveAddress is undefined or empty
- * - Uses React Query for efficient caching and state management
- * - Automatically handles error states and loading indicators
- * - Supports pagination through offset and limit parameters
+ * - The query is disabled if `reserveAddress`, `offset`, or `limit` are not provided.
+ * - Uses React Query for caching, retries, and auto error/loading management.
+ * - Pagination is handled via `pagination.offset` and `pagination.limit`.
  */
-export const useBackendMoneyMarketAssetBorrowers = (params: {
-  reserveAddress: string | undefined;
-  offset: string;
-  limit: string;
-}): UseQueryResult<MoneyMarketAssetBorrowers | undefined> => {
+export const useBackendMoneyMarketAssetBorrowers = (
+  params: UseBackendMoneyMarketAssetBorrowersParams | undefined,
+): UseQueryResult<MoneyMarketAssetBorrowers | undefined, Error> => {
   const { sodax } = useSodaxContext();
 
+  const defaultQueryOptions = {
+    queryKey: ['api', 'mm', 'asset', 'borrowers', params],
+    enabled: !!params?.params?.reserveAddress && !!params.pagination.offset && !!params.pagination.limit,
+    retry: 3,
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions,
+  };
+
   return useQuery({
-    queryKey: ['backend', 'moneymarket', 'asset', 'borrowers', params],
+    ...queryOptions,
     queryFn: async (): Promise<MoneyMarketAssetBorrowers | undefined> => {
-      if (!params.reserveAddress || !params.offset || !params.limit) {
+      if (!params?.params?.reserveAddress || !params.pagination.offset || !params.pagination.limit) {
         return undefined;
       }
 
-      return sodax.backendApi.getMoneyMarketAssetBorrowers(params.reserveAddress, {
-        offset: params.offset,
-        limit: params.limit,
+      return sodax.backendApi.getMoneyMarketAssetBorrowers(params.params.reserveAddress, {
+        offset: params.pagination.offset,
+        limit: params.pagination.limit,
       });
     },
-    enabled: !!params.reserveAddress && !!params.offset && !!params.limit,
-    retry: 3,
   });
 };

package/src/hooks/backend/useBackendMoneyMarketAssetSuppliers.ts

@@ -1,31 +1,36 @@
 // packages/dapp-kit/src/hooks/backend/useMoneyMarketAssetSuppliers.ts
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import type { MoneyMarketAssetSuppliers } from '@sodax/sdk';
 import { useSodaxContext } from '../shared/useSodaxContext';
+import type { BackendPaginationParams } from './types';
+
+export type UseBackendMoneyMarketAssetSuppliersParams = {
+  params: {
+    reserveAddress: string | undefined;
+  };
+  pagination: BackendPaginationParams;
+  queryOptions?: UseQueryOptions<MoneyMarketAssetSuppliers | undefined, Error>;
+};
 
 /**
- * Hook for fetching suppliers for a specific money market asset from the backend API.
- *
- * This hook provides access to the list of suppliers for a specific money market asset,
- * with pagination support. The data is automatically fetched and cached using React Query.
+ * React hook for fetching suppliers for a specific money market asset from the backend API, with pagination support.
  *
- * @param {Object} params - Parameters for fetching asset suppliers
- * @param {string | undefined} params.reserveAddress - The reserve contract address. If undefined, the query will be disabled.
- * @param {string} params.offset - The offset for pagination (number as string)
- * @param {string} params.limit - The limit for pagination (number as string)
+ * @param {UseBackendMoneyMarketAssetSuppliersParams | undefined} params - Hook parameters:
+ *   - `params`: Object containing:
+ *       - `reserveAddress`: The reserve contract address to query, or undefined to disable the query.
+ *   - `pagination`: Backend pagination controls (`offset` and `limit` as strings).
+ *   - `queryOptions` (optional): React Query options to override defaults.
  *
- * @returns {UseQueryResult<MoneyMarketAssetSuppliers | undefined>} A query result object containing:
- *   - data: The asset suppliers data when available
- *   - isLoading: Boolean indicating if the request is in progress
- *   - error: Error object if the request failed
- *   - refetch: Function to manually trigger a data refresh
+ * @returns {UseQueryResult<MoneyMarketAssetSuppliers | undefined, Error>} - Query result object with:
+ *   - `data`: The asset suppliers data when available.
+ *   - `isLoading`: Indicates if the request is in progress.
+ *   - `error`: Error object if the request failed.
+ *   - `refetch`: Function to trigger a manual data refresh.
  *
  * @example
- * ```typescript
- * const { data: suppliers, isLoading, error } = useMoneyMarketAssetSuppliers({
- *   reserveAddress: '0xabc...',
- *   offset: '0',
- *   limit: '20'
+ * const { data: suppliers, isLoading, error } = useBackendMoneyMarketAssetSuppliers({
+ *   params: { reserveAddress: '0xabc...' },
+ *   pagination: { offset: '0', limit: '20' }
  * });
  *
  * if (isLoading) return <div>Loading suppliers...</div>;
@@ -34,34 +39,38 @@ import { useSodaxContext } from '../shared/useSodaxContext';
  *   console.log('Total suppliers:', suppliers.total);
  *   console.log('Suppliers:', suppliers.suppliers);
  * }
- * ```
  *
  * @remarks
- * - The query is disabled when reserveAddress is undefined or empty
- * - Uses React Query for efficient caching and state management
- * - Automatically handles error states and loading indicators
- * - Supports pagination through offset and limit parameters
+ * - The query is disabled if `reserveAddress`, `offset`, or `limit` are not provided.
+ * - Uses React Query for efficient caching, automatic retries, and error/loading handling.
+ * - Pagination is handled via `pagination.offset` and `pagination.limit`.
  */
-export const useBackendMoneyMarketAssetSuppliers = (params: {
-  reserveAddress: string | undefined;
-  offset: string;
-  limit: string;
-}): UseQueryResult<MoneyMarketAssetSuppliers | undefined> => {
+export const useBackendMoneyMarketAssetSuppliers = (
+  params: UseBackendMoneyMarketAssetSuppliersParams | undefined,
+): UseQueryResult<MoneyMarketAssetSuppliers | undefined, Error> => {
   const { sodax } = useSodaxContext();
 
+  const defaultQueryOptions = {
+    queryKey: ['api', 'mm', 'asset', 'suppliers', params],
+    enabled: !!params?.params?.reserveAddress && !!params.pagination.offset && !!params.pagination.limit,
+    retry: 3,
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions,
+  };
+
   return useQuery({
-    queryKey: ['backend', 'moneymarket', 'asset', 'suppliers', params],
+    ...queryOptions,
     queryFn: async (): Promise<MoneyMarketAssetSuppliers | undefined> => {
-      if (!params.reserveAddress || !params.offset || !params.limit) {
+      if (!params?.params?.reserveAddress || !params.pagination.offset || !params.pagination.limit) {
         return undefined;
       }
 
-      return sodax.backendApi.getMoneyMarketAssetSuppliers(params.reserveAddress, {
-        offset: params.offset,
-        limit: params.limit,
+      return sodax.backendApi.getMoneyMarketAssetSuppliers(params.params.reserveAddress, {
+        offset: params.pagination.offset,
+        limit: params.pagination.limit,
       });
     },
-    enabled: !!params.reserveAddress && !!params.offset && !!params.limit,
-    retry: 3,
   });
 };

package/src/hooks/backend/useBackendMoneyMarketPosition.ts

@@ -1,56 +1,53 @@
-// packages/dapp-kit/src/hooks/backend/useMoneyMarketPosition.ts
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import type { MoneyMarketPosition } from '@sodax/sdk';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
+export type UseBackendMoneyMarketPositionParams = {
+  userAddress: string | undefined;
+  queryOptions?: UseQueryOptions<MoneyMarketPosition | undefined, Error>;
+};
+
 /**
- * Hook for fetching money market position for a specific user from the backend API.
- *
- * This hook provides access to a user's money market positions, including their
- * aToken balances, variable debt token balances, and associated reserve information.
- * The data is automatically fetched and cached using React Query.
+ * React hook for fetching a user's money market position from the backend API.
  *
- * @param {string | undefined} userAddress - The user's wallet address. If undefined, the query will be disabled.
+ * @param {UseBackendMoneyMarketPositionParams | undefined} params - Parameters object:
+ *   - userAddress: The user's wallet address to fetch positions for. If undefined or empty, the query is disabled.
+ *   - queryOptions: (Optional) React Query options to customize behavior (e.g., staleTime, enabled).
  *
- * @returns {UseQueryResult<MoneyMarketPosition | undefined>} A query result object containing:
- *   - data: The money market position data when available
- *   - isLoading: Boolean indicating if the request is in progress
- *   - error: Error object if the request failed
- *   - refetch: Function to manually trigger a data refresh
+ * @returns {UseQueryResult<MoneyMarketPosition | undefined, Error>} - React Query result object with:
+ *   - data: The user's money market position data, or undefined if not available.
+ *   - isLoading: Loading state.
+ *   - error: An Error instance if fetching failed.
+ *   - refetch: Function to manually trigger a refetch.
  *
  * @example
- * ```typescript
- * const { data: position, isLoading, error } = useMoneyMarketPosition('0x123...');
- *
- * if (isLoading) return <div>Loading position...</div>;
- * if (error) return <div>Error: {error.message}</div>;
- * if (position) {
- *   console.log('User address:', position.userAddress);
- *   console.log('Positions:', position.positions);
- * }
- * ```
- *
- * @remarks
- * - The query is disabled when userAddress is undefined or empty
- * - Uses React Query for efficient caching and state management
- * - Automatically handles error states and loading indicators
- * - Includes user's aToken and debt token balances across all reserves
+ * const { data, isLoading, error } = useBackendMoneyMarketPosition({
+ *   userAddress: '0xabc...',
+ *   queryOptions: { staleTime: 60000 },
+ * });
  */
 export const useBackendMoneyMarketPosition = (
-  userAddress: string | undefined,
-): UseQueryResult<MoneyMarketPosition | undefined> => {
+  params: UseBackendMoneyMarketPositionParams | undefined,
+): UseQueryResult<MoneyMarketPosition | undefined, Error> => {
   const { sodax } = useSodaxContext();
 
+  const defaultQueryOptions = {
+    queryKey: ['api', 'mm', 'position', params?.userAddress],
+    enabled: !!params?.userAddress && params?.userAddress.length > 0,
+    retry: 3,
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions,
+  };
+
   return useQuery({
-    queryKey: ['backend', 'moneymarket', 'position', userAddress],
+    ...queryOptions,
     queryFn: async (): Promise<MoneyMarketPosition | undefined> => {
-      if (!userAddress) {
+      if (!params?.userAddress) {
         return undefined;
       }
-
-      return sodax.backendApi.getMoneyMarketPosition(userAddress);
+      return sodax.backendApi.getMoneyMarketPosition(params.userAddress);
     },
-    enabled: !!userAddress && userAddress.length > 0,
-    retry: 3,
   });
 };

package/src/hooks/backend/useBackendOrderbook.ts

@@ -1,63 +1,63 @@
-// packages/dapp-kit/src/hooks/backend/useOrderbook.ts
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import type { OrderbookResponse } from '@sodax/sdk';
 import { useSodaxContext } from '../shared/useSodaxContext';
+import type { BackendPaginationParams } from './types';
+
+export type UseBackendOrderbookParams = {
+  queryOptions?: UseQueryOptions<OrderbookResponse | undefined, Error>;
+  pagination?: BackendPaginationParams;
+};
 
 /**
  * Hook for fetching the solver orderbook from the backend API.
  *
- * This hook provides access to the solver orderbook data, including intent states
- * and intent data for all available intents. The data is automatically fetched
- * and cached using React Query with pagination support.
- *
- * @param {Object} params - Pagination parameters for the orderbook
- * @param {string} params.offset - The offset for pagination (number as string)
- * @param {string} params.limit - The limit for pagination (number as string)
+ * @param {UseBackendOrderbookParams | undefined} params - Optional parameters:
+ *   - `pagination`: Pagination configuration (see `BackendPaginationParams`), including
+ *      `offset` and `limit` (both required for fetch to be enabled).
+ *   - `queryOptions`: Optional React Query options to override default behavior.
  *
- * @returns {UseQueryResult<OrderbookResponse | undefined>} A query result object containing:
- *   - data: The orderbook response data when available
- *   - isLoading: Boolean indicating if the request is in progress
- *   - error: Error object if the request failed
- *   - refetch: Function to manually trigger a data refresh
+ * @returns {UseQueryResult<OrderbookResponse | undefined, Error>} React Query result object:
+ *   - `data`: The orderbook response, or undefined if unavailable.
+ *   - `isLoading`: Loading state.
+ *   - `error`: Error instance if the query failed.
+ *   - `refetch`: Function to re-trigger the query.
  *
  * @example
- * ```typescript
- * const { data: orderbook, isLoading, error } = useOrderbook({
- *   offset: '0',
- *   limit: '10'
+ * const { data, isLoading, error } = useBackendOrderbook({
+ *   pagination: { offset: '0', limit: '10' },
+ *   queryOptions: { staleTime: 60000 },
  * });
  *
- * if (isLoading) return <div>Loading orderbook...</div>;
- * if (error) return <div>Error: {error.message}</div>;
- * if (orderbook) {
- *   console.log('Total intents:', orderbook.total);
- *   console.log('Intents:', orderbook.data);
- * }
- * ```
- *
  * @remarks
- * - The query is disabled when params are undefined or invalid
- * - Uses React Query for efficient caching and state management
- * - Automatically handles error states and loading indicators
- * - Stale time of 30 seconds for real-time orderbook data
- * - Supports pagination through offset and limit parameters
+ * - Query is disabled if `params?.pagination`, `offset`, or `limit` are missing/empty.
+ * - Caches and manages server state using React Query.
+ * - Default `staleTime` is 30 seconds to support near-real-time updates.
  */
 export const useBackendOrderbook = (
-  params: { offset: string; limit: string } | undefined,
+  params: UseBackendOrderbookParams | undefined,
 ): UseQueryResult<OrderbookResponse | undefined> => {
   const { sodax } = useSodaxContext();
 
+  const defaultQueryOptions = {
+    queryKey: ['api', 'solver', 'orderbook', params?.pagination?.offset, params?.pagination?.limit],
+    enabled: !!params?.pagination && !!params?.pagination.offset && !!params?.pagination.limit,
+    staleTime: 30 * 1000, // 30 seconds for real-time data
+    retry: 3,
+  };
+
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions, // override default query options if provided
+  };
+
   return useQuery({
-    queryKey: ['backend', 'solver', 'orderbook', params],
+    ...queryOptions,
     queryFn: async (): Promise<OrderbookResponse | undefined> => {
-      if (!params || !params.offset || !params.limit) {
+      if (!params?.pagination || !params?.pagination.offset || !params?.pagination.limit) {
         return undefined;
       }
 
-      return sodax.backendApi.getOrderbook(params);
+      return sodax.backendApi.getOrderbook(params.pagination);
     },
-    enabled: !!params && !!params.offset && !!params.limit,
-    staleTime: 30 * 1000, // 30 seconds for real-time data
-    retry: 3,
   });
 };

package/src/hooks/backend/useBackendUserIntents.ts

@@ -0,0 +1,81 @@
+import type { UserIntentsResponse, Address } from '@sodax/sdk';
+// packages/dapp-kit/src/hooks/backend/useBackendUserIntents.ts
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { BackendPaginationParams } from './types';
+
+export type GetUserIntentsParams = {
+  userAddress: Address;
+  startDate?: number;
+  endDate?: number;
+};
+
+export type UseBackendUserIntentsParams = {
+  params?: GetUserIntentsParams;
+  queryOptions?: UseQueryOptions<UserIntentsResponse | undefined, Error>;
+  pagination?: BackendPaginationParams;
+};
+
+/**
+ * React hook for fetching user-created intents from the backend API for a given user address,
+ * with optional support for a date filtering range.
+ *
+ * @param {UseBackendUserIntentsParams} args - Query configuration.
+ *   @param {GetUserIntentsParams | undefined} args.params - User intent filter parameters.
+ *     @param {Address} args.params.userAddress - The wallet address of the user (required).
+ *     @param {number} [args.params.startDate] - Include intents created after this timestamp (ms).
+ *     @param {number} [args.params.endDate] - Include intents created before this timestamp (ms).
+ *   @param {UseQueryOptions<UserIntentsResponse | undefined, Error>} [args.queryOptions] - Optional React Query options.
+ *   @param {BackendPaginationParams} [args.pagination] - (currently ignored) Pagination options.
+ *
+ * @returns {UseQueryResult<UserIntentsResponse | undefined, Error>} React Query result:
+ *   - `data`: The user intent response, or undefined if unavailable.
+ *   - `isLoading`: `true` if loading.
+ *   - `error`: An Error instance if any occurred.
+ *   - `refetch`: Function to refetch data.
+ *
+ * @example
+ * const { data: userIntents, isLoading, error } = useBackendUserIntents({
+ *   params: { userAddress: "0x123..." }
+ * });
+ *
+ * @example
+ * const { data } = useBackendUserIntents({
+ *   params: {
+ *     userAddress: "0xabc...",
+ *     startDate: Date.now() - 1_000_000,
+ *     endDate: Date.now(),
+ *   },
+ * });
+ *
+ * @remarks
+ * The query is disabled if `params` or `params.userAddress` is missing or empty. Uses React Query for
+ * cache/state management and auto-retries failed requests three times by default.
+ */
+export const useBackendUserIntents = ({
+  params,
+  queryOptions,
+}: UseBackendUserIntentsParams): UseQueryResult<UserIntentsResponse | undefined, Error> => {
+  const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ['api', 'intent', 'user', params],
+    enabled: !!params && !!params.userAddress && params.userAddress.length > 0,
+    retry: 3,
+  };
+
+  queryOptions = {
+    ...defaultQueryOptions,
+    ...queryOptions, // override default query options if provided
+  };
+
+  return useQuery({
+    ...queryOptions,
+    queryFn: async (): Promise<UserIntentsResponse | undefined> => {
+      if (!params?.userAddress) {
+        return undefined;
+      }
+
+      return sodax.backendApi.getUserIntents(params);
+    },
+  });
+};

package/src/hooks/mm/index.ts

@@ -8,3 +8,4 @@ export * from './useMMAllowance';
 export * from './useMMApprove';
 export * from './useAToken';
 export * from './useReservesUsdFormat';
+export * from './useUserFormattedSummary';