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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sodax/dapp-kit",
   "license": "MIT",
-  "version": "1.0.1-beta-rc3",
+  "version": "1.0.2-beta",
   "description": "dapp-kit of New World",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,11 +16,11 @@
   },
   "dependencies": {
     "viem": "2.29.2",
-    "@sodax/sdk": "1.0.1-beta-rc3",
-    "@sodax/types": "1.0.1-beta-rc3"
+    "@sodax/types": "1.0.2-beta",
+    "@sodax/sdk": "1.0.2-beta"
   },
   "devDependencies": {
-    "@types/react": "18.3.1",
+    "@types/react": "19.0.8",
     "knip": "5.30.5",
     "tsup": "^8.4.0",
     "typescript": "5.5.4"

package/src/hooks/backend/README.md

@@ -6,119 +6,218 @@ This directory contains React hooks for interacting with the Sodax Backend API t
 
 ### Intent Hooks
 
-#### `useIntentByTxHash(txHash: string | undefined)`
-Fetches intent details by transaction hash.
+#### `useBackendIntentByTxHash(params)`
+
+Fetches intent details by transaction hash. The query is disabled if `txHash` is undefined or empty.
 
 ```typescript
-import { useIntentByTxHash } from '@sodax/dapp-kit';
+import { useBackendIntentByTxHash } from '@sodax/dapp-kit';
 
-const { data: intent, isLoading, error } = useIntentByTxHash('0x123...');
+const { data: intent, isLoading, error } = useBackendIntentByTxHash({
+  params: { txHash: '0x123...' },
+  queryOptions: { staleTime: 1000 }, // optional
+});
 ```
 
-#### `useIntentByHash(intentHash: string | undefined)`
-Fetches intent details by intent hash.
+**Parameters:**
+
+- `params.params.txHash` (string | undefined): Transaction hash used to retrieve the associated intent
+- `params.queryOptions` (optional): React Query options to customize behavior
+
+**Note:** Intents are only created on the hub chain, so `txHash` must originate from there. Default refetch interval is 1 second.
+
+#### `useBackendIntentByHash(params)`
+
+Fetches intent details by intent hash. The query is disabled if `intentHash` is undefined or empty.
 
 ```typescript
-import { useIntentByHash } from '@sodax/dapp-kit';
+import { useBackendIntentByHash } from '@sodax/dapp-kit';
 
-const { data: intent, isLoading, error } = useIntentByHash('0xabc...');
+const { data: intent, isLoading, error } = useBackendIntentByHash({
+  params: { intentHash: '0xabc...' },
+});
 ```
 
+**Parameters:**
+
+- `params.params.intentHash` (string | undefined): The hash identifying the intent to fetch
+- `params.queryOptions` (optional): React Query options to customize behavior
+
+#### `useBackendUserIntents(params)`
+
+Fetches user-created intents from the backend API for a given user address, with optional date filtering.
+
+```typescript
+import { useBackendUserIntents } from '@sodax/dapp-kit';
+
+const { data: userIntents, isLoading, error } = useBackendUserIntents({
+  params: {
+    userAddress: '0x123...',
+    startDate: Date.now() - 1_000_000, // optional
+    endDate: Date.now(), // optional
+  },
+});
+```
+
+**Parameters:**
+
+- `params.params.userAddress` (Address): The wallet address of the user (required)
+- `params.params.startDate` (number, optional): Include intents created after this timestamp (ms)
+- `params.params.endDate` (number, optional): Include intents created before this timestamp (ms)
+- `params.queryOptions` (optional): React Query options to customize behavior
+- `params.pagination` (optional): Currently ignored
+
 ### Solver Hooks
 
-#### `useOrderbook(params: { offset: string; limit: string } | undefined)`
-Fetches the solver orderbook with pagination support.
+#### `useBackendOrderbook(params)`
+
+Fetches the solver orderbook with pagination support. The query is disabled if pagination parameters are missing.
 
 ```typescript
-import { useOrderbook } from '@sodax/dapp-kit';
+import { useBackendOrderbook } from '@sodax/dapp-kit';
 
-const { data: orderbook, isLoading, error } = useOrderbook({
-  offset: '0',
-  limit: '10'
+const { data: orderbook, isLoading, error } = useBackendOrderbook({
+  pagination: { offset: '0', limit: '10' },
+  queryOptions: { staleTime: 60000 }, // optional
 });
 ```
 
+**Parameters:**
+
+- `params.pagination.offset` (string): The offset for pagination (required)
+- `params.pagination.limit` (string): The limit for pagination (required)
+- `params.queryOptions` (optional): React Query options to customize behavior
+
+**Note:** Default `staleTime` is 30 seconds to support near-real-time updates.
+
 ### Money Market Hooks
 
-#### `useMoneyMarketPosition(userAddress: string | undefined)`
-Fetches a user's money market positions.
+#### `useBackendMoneyMarketPosition(params)`
+
+Fetches a user's money market position. The query is disabled if `userAddress` is undefined or empty.
 
 ```typescript
-import { useMoneyMarketPosition } from '@sodax/dapp-kit';
+import { useBackendMoneyMarketPosition } from '@sodax/dapp-kit';
 
-const { data: position, isLoading, error } = useMoneyMarketPosition('0x123...');
+const { data: position, isLoading, error } = useBackendMoneyMarketPosition({
+  userAddress: '0x123...',
+  queryOptions: { staleTime: 60000 }, // optional
+});
 ```
 
-#### `useAllMoneyMarketAssets()`
-Fetches all available money market assets.
+**Parameters:**
+
+- `params.userAddress` (string | undefined): The user's wallet address to fetch positions for
+- `params.queryOptions` (optional): React Query options to customize behavior
+
+#### `useBackendAllMoneyMarketAssets(params)`
+
+Fetches all available money market assets. No required parameters.
 
 ```typescript
-import { useAllMoneyMarketAssets } from '@sodax/dapp-kit';
+import { useBackendAllMoneyMarketAssets } from '@sodax/dapp-kit';
 
-const { data: assets, isLoading, error } = useAllMoneyMarketAssets();
+const { data: assets, isLoading, error } = useBackendAllMoneyMarketAssets({
+  queryOptions: { staleTime: 60000 }, // optional
+});
 ```
 
-#### `useMoneyMarketAsset(reserveAddress: string | undefined)`
-Fetches details for a specific money market asset.
+**Parameters:**
+
+- `params.queryOptions` (optional): React Query options to customize behavior
+
+#### `useBackendMoneyMarketAsset(params)`
+
+Fetches details for a specific money market asset. The query is disabled if `reserveAddress` is undefined or empty.
 
 ```typescript
-import { useMoneyMarketAsset } from '@sodax/dapp-kit';
+import { useBackendMoneyMarketAsset } from '@sodax/dapp-kit';
 
-const { data: asset, isLoading, error } = useMoneyMarketAsset('0xabc...');
+const { data: asset, isLoading, error } = useBackendMoneyMarketAsset({
+  params: { reserveAddress: '0xabc...' },
+});
 ```
 
-#### `useMoneyMarketAssetBorrowers(params)`
-Fetches borrowers for a specific money market asset.
+**Parameters:**
+
+- `params.params.reserveAddress` (string | undefined): Reserve contract address to fetch asset details
+- `params.queryOptions` (optional): React Query options to customize behavior
+
+#### `useBackendMoneyMarketAssetBorrowers(params)`
+
+Fetches borrowers for a specific money market asset with pagination. The query is disabled if `reserveAddress`, `offset`, or `limit` are missing.
 
 ```typescript
-import { useMoneyMarketAssetBorrowers } from '@sodax/dapp-kit';
+import { useBackendMoneyMarketAssetBorrowers } from '@sodax/dapp-kit';
 
-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' },
 });
 ```
 
-#### `useMoneyMarketAssetSuppliers(params)`
-Fetches suppliers for a specific money market asset.
+**Parameters:**
+
+- `params.params.reserveAddress` (string | undefined): Reserve contract address for which to fetch borrowers
+- `params.pagination.offset` (string): The offset for pagination (required)
+- `params.pagination.limit` (string): The limit for pagination (required)
+- `params.queryOptions` (optional): React Query options to customize behavior
+
+#### `useBackendMoneyMarketAssetSuppliers(params)`
+
+Fetches suppliers for a specific money market asset with pagination. The query is disabled if `reserveAddress`, `offset`, or `limit` are missing.
 
 ```typescript
-import { useMoneyMarketAssetSuppliers } from '@sodax/dapp-kit';
+import { useBackendMoneyMarketAssetSuppliers } from '@sodax/dapp-kit';
 
-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' },
 });
 ```
 
-#### `useAllMoneyMarketBorrowers(params)`
-Fetches all money market borrowers across all assets.
+**Parameters:**
+
+- `params.params.reserveAddress` (string | undefined): The reserve contract address to query
+- `params.pagination.offset` (string): The offset for pagination (required)
+- `params.pagination.limit` (string): The limit for pagination (required)
+- `params.queryOptions` (optional): React Query options to customize behavior
+
+#### `useBackendAllMoneyMarketBorrowers(params)`
+
+Fetches all money market borrowers across all assets with pagination. The query is disabled if pagination parameters are missing.
 
 ```typescript
-import { useAllMoneyMarketBorrowers } from '@sodax/dapp-kit';
+import { useBackendAllMoneyMarketBorrowers } from '@sodax/dapp-kit';
 
-const { data: borrowers, isLoading, error } = useAllMoneyMarketBorrowers({
-  offset: '0',
-  limit: '50'
+const { data: borrowers, isLoading, error } = useBackendAllMoneyMarketBorrowers({
+  pagination: { offset: '0', limit: '50' },
 });
 ```
 
+**Parameters:**
+
+- `params.pagination.offset` (string): The offset for pagination (required)
+- `params.pagination.limit` (string): The limit for pagination (required)
+- `params.queryOptions` (optional): React Query options to customize behavior
+
 ## Features
 
 - **Automatic Caching**: All hooks use React Query for efficient data caching
-- **Error Handling**: Built-in error states and retry logic
+- **Error Handling**: Built-in error states and retry logic (default: 3 retries)
 - **Loading States**: Automatic loading indicators
 - **TypeScript Support**: Full type safety with proper TypeScript definitions
-- **Pagination Support**: Built-in pagination for list endpoints
-- **Conditional Queries**: Queries are automatically disabled when required parameters are missing
+- **Pagination Support**: Built-in pagination for list endpoints (offset/limit as strings)
+- **Conditional Queries**: Queries are automatically disabled when required parameters are missing or empty
 - **Context Integration**: Uses `useSodaxContext` for consistent SDK access across the application
+- **Auto-refetch**: `useBackendIntentByTxHash` has a default refetch interval of 1 second for real-time updates
 
 ## Stale Times
 
 Different hooks have different stale times optimized for their data types:
 
+- **`useBackendOrderbook`**: 30 seconds (default) - for near-real-time solver orderbook updates
+- **Other hooks**: No default stale time set - uses React Query defaults. You can customize via `queryOptions.staleTime`
 
 ## Error Handling
 

package/src/hooks/backend/index.ts

@@ -10,6 +10,7 @@
 // Intent hooks
 export { useBackendIntentByTxHash } from './useBackendIntentByTxHash';
 export { useBackendIntentByHash } from './useBackendIntentByHash';
+export { useBackendUserIntents } from './useBackendUserIntents';
 
 // Solver hooks
 export { useBackendOrderbook } from './useBackendOrderbook';
@@ -21,3 +22,4 @@ export { useBackendMoneyMarketAsset } from './useBackendMoneyMarketAsset';
 export { useBackendMoneyMarketAssetBorrowers } from './useBackendMoneyMarketAssetBorrowers';
 export { useBackendMoneyMarketAssetSuppliers } from './useBackendMoneyMarketAssetSuppliers';
 export { useBackendAllMoneyMarketBorrowers } from './useBackendAllMoneyMarketBorrowers';
+export * from './types';

package/src/hooks/backend/types.ts

@@ -0,0 +1,4 @@
+export type BackendPaginationParams = {
+  offset: string;
+  limit: string;
+};

package/src/hooks/backend/useBackendAllMoneyMarketAssets.ts

@@ -1,24 +1,26 @@
 // packages/dapp-kit/src/hooks/backend/useAllMoneyMarketAssets.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 UseBackendAllMoneyMarketAssetsParams = {
+  queryOptions?: UseQueryOptions<MoneyMarketAsset[], Error>;
+};
+
 /**
- * Hook for fetching all money market assets from the backend API.
+ * React hook to fetch all money market assets from the backend API.
  *
- * This hook provides access to all available money market assets, including
- * their reserve information, liquidity rates, borrow rates, and market statistics.
- * The data is automatically fetched and cached using React Query.
+ * @param {UseBackendAllMoneyMarketAssetsParams | undefined} params - Optional parameters:
+ *   - `queryOptions` (optional): React Query options to override default behavior (e.g., caching, retry, etc).
  *
- * @returns {UseQueryResult<MoneyMarketAsset[]>} A query result object containing:
- *   - data: Array of 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 {UseQueryResult<MoneyMarketAsset[], Error>} React Query result object:
+ *   - `data`: Array of all 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.
  *
  * @example
- * ```typescript
- * const { data: assets, isLoading, error } = useAllMoneyMarketAssets();
+ * const { data: assets, isLoading, error } = useBackendAllMoneyMarketAssets();
  *
  * if (isLoading) return <div>Loading assets...</div>;
  * if (error) return <div>Error: {error.message}</div>;
@@ -28,22 +30,31 @@ import { useSodaxContext } from '../shared/useSodaxContext';
  *     console.log(`${asset.symbol}: ${asset.liquidityRate} liquidity rate`);
  *   });
  * }
- * ```
  *
  * @remarks
- * - Uses React Query for efficient caching and state management
- * - Automatically handles error states and loading indicators
- * - Returns comprehensive asset information including rates and statistics
- * - No parameters required - fetches all available assets
+ * - No required parameters — fetches all available money market assets from backend.
+ * - Uses React Query for caching, retries, and loading/error state management.
+ * - Supports overriding React Query config via `queryOptions`.
  */
-export const useBackendAllMoneyMarketAssets = (): UseQueryResult<MoneyMarketAsset[]> => {
+export const useBackendAllMoneyMarketAssets = (
+  params: UseBackendAllMoneyMarketAssetsParams | undefined,
+): UseQueryResult<MoneyMarketAsset[], Error> => {
   const { sodax } = useSodaxContext();
 
+  const defaultQueryOptions = {
+    queryKey: ['api', 'mm', 'assets', 'all'],
+    enabled: true,
+    retry: 3,
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions,
+  };
+
   return useQuery({
-    queryKey: ['backend', 'moneymarket', 'assets', 'all'],
+    ...queryOptions,
     queryFn: async (): Promise<MoneyMarketAsset[]> => {
       return sodax.backendApi.getAllMoneyMarketAssets();
     },
-    retry: 3,
   });
 };

package/src/hooks/backend/useBackendAllMoneyMarketBorrowers.ts

@@ -1,7 +1,13 @@
 // packages/dapp-kit/src/hooks/backend/useAllMoneyMarketBorrowers.ts
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import type { MoneyMarketBorrowers } from '@sodax/sdk';
 import { useSodaxContext } from '../shared/useSodaxContext';
+import type { BackendPaginationParams } from './types';
+
+export type UseBackendAllMoneyMarketBorrowersParams = {
+  pagination: BackendPaginationParams;
+  queryOptions?: UseQueryOptions<MoneyMarketBorrowers | undefined, Error>;
+};
 
 /**
  * Hook for fetching all money market borrowers from the backend API.
@@ -42,20 +48,32 @@ import { useSodaxContext } from '../shared/useSodaxContext';
  * - Returns borrowers across all money market assets
  */
 export const useBackendAllMoneyMarketBorrowers = (
-  params: { offset: string; limit: string } | undefined,
+  params: UseBackendAllMoneyMarketBorrowersParams | undefined,
 ): UseQueryResult<MoneyMarketBorrowers | undefined> => {
   const { sodax } = useSodaxContext();
 
+  const defaultQueryOptions = {
+    queryKey: ['api', 'mm', 'borrowers', 'all', params],
+    enabled: !!params && !!params.pagination.offset && !!params.pagination.limit,
+    retry: 3,
+  };
+
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions,
+  };
+
   return useQuery({
-    queryKey: ['backend', 'moneymarket', 'borrowers', 'all', params],
+    ...queryOptions,
     queryFn: async (): Promise<MoneyMarketBorrowers | undefined> => {
-      if (!params || !params.offset || !params.limit) {
+      if (!params || !params.pagination.offset || !params.pagination.limit) {
         return undefined;
       }
 
-      return sodax.backendApi.getAllMoneyMarketBorrowers(params);
+      return sodax.backendApi.getAllMoneyMarketBorrowers({
+        offset: params.pagination.offset,
+        limit: params.pagination.limit,
+      });
     },
-    enabled: !!params && !!params.offset && !!params.limit,
-    retry: 3,
   });
 };

package/src/hooks/backend/useBackendIntentByHash.ts

@@ -1,53 +1,63 @@
-// packages/dapp-kit/src/hooks/backend/useIntentByHash.ts
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import type { IntentResponse } from '@sodax/sdk';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
+export type UseBackendIntentByHashParams = {
+  params: {
+    intentHash: string | undefined;
+  };
+  queryOptions?: UseQueryOptions<IntentResponse | undefined, Error>;
+};
+
 /**
- * Hook for fetching intent details by intent hash from the backend API.
- *
- * This hook provides access to intent data using the intent hash directly,
- * including intent details, events, and transaction information. The data is automatically
- * fetched and cached using React Query.
+ * React hook to fetch intent details from the backend API using an intent hash.
  *
- * @param {string | undefined} intentHash - The intent hash to fetch intent for. If undefined, the query will be disabled.
+ * @param {UseBackendIntentByHashParams | undefined} params - Parameters for the query:
+ *   - params: { intentHash: string | undefined }
+ *     - `intentHash`: The hash identifying the intent to fetch (disables query if undefined or empty).
+ *   - queryOptions (optional): Options to customize React Query (e.g., staleTime, enabled).
  *
- * @returns {UseQueryResult<IntentResponse | undefined>} A query result object containing:
- *   - data: The intent 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<IntentResponse | undefined, Error>} React Query result containing intent response data, loading, error, and refetch states.
  *
  * @example
- * ```typescript
- * const { data: intent, isLoading, error } = useIntentByHash('0xabc...');
+ * const { data: intent, isLoading, error } = useBackendIntentByHash({
+ *   params: { intentHash: '0xabc...' },
+ * });
  *
  * if (isLoading) return <div>Loading intent...</div>;
  * if (error) return <div>Error: {error.message}</div>;
  * if (intent) {
  *   console.log('Intent found:', intent.intentHash);
- *   console.log('Open status:', intent.open);
  * }
- * ```
  *
  * @remarks
- * - The query is disabled when intentHash is undefined or empty
- * - Uses React Query for efficient caching and state management
- * - Automatically handles error states and loading indicators
+ * - Returns `undefined` data if no intentHash is provided or query is disabled.
+ * - Query is cached and managed using React Query.
+ * - Use `queryOptions` to customize caching, retry and fetch behavior.
  */
-export const useBackendIntentByHash = (intentHash: string | undefined): UseQueryResult<IntentResponse | undefined> => {
+export const useBackendIntentByHash = (
+  params: UseBackendIntentByHashParams | undefined,
+): UseQueryResult<IntentResponse | undefined, Error> => {
   const { sodax } = useSodaxContext();
 
+  const defaultQueryOptions = {
+    queryKey: ['api', 'intent', 'hash', params?.params?.intentHash],
+    enabled: !!params?.params?.intentHash && params?.params?.intentHash.length > 0,
+    retry: 3,
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions,
+  };
+
   return useQuery({
-    queryKey: ['backend', 'intent', 'hash', intentHash],
+    ...queryOptions,
     queryFn: async (): Promise<IntentResponse | undefined> => {
-      if (!intentHash) {
+      if (!params?.params?.intentHash) {
         return undefined;
       }
 
-      return sodax.backendApi.getIntentByHash(intentHash);
+      return sodax.backendApi.getIntentByHash(params.params.intentHash);
     },
-    enabled: !!intentHash && intentHash.length > 0,
-    retry: 3,
   });
 };

package/src/hooks/backend/useBackendIntentByTxHash.ts

@@ -1,57 +1,69 @@
 // packages/dapp-kit/src/hooks/backend/useIntentByTxHash.ts
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import type { IntentResponse } from '@sodax/sdk';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
+export type UseBackendIntentByTxHashParams = {
+  params: {
+    txHash: string | undefined;
+  };
+  queryOptions?: UseQueryOptions<IntentResponse | undefined, Error>;
+};
+
 /**
- * Hook for fetching intent details by intent created transaction hash from the backend API.
+ * React hook for fetching intent details from the backend API using a transaction hash.
  *
- * This hook provides access to intent data associated with the transaction hash from when
- * the intent was created on the hub chain, including intent details, events, and transaction
- * information. The data is automatically fetched and cached using React Query.
+ * @param {UseBackendIntentByTxHashParams | undefined} params - Parameters for the query:
+ *   - params: { txHash: string | undefined }
+ *       - `txHash`: Transaction hash used to retrieve the associated intent; query is disabled if undefined or empty.
+ *   - queryOptions (optional): React Query options to customize request behavior (e.g., caching, retry, refetchInterval, etc.).
  *
- * @param {string | undefined} txHash - The intent created transaction hash from the hub chain to fetch intent for. If undefined, the query will be disabled.
- *
- * @returns {UseQueryResult<IntentResponse | undefined>} A query result object containing:
- *   - data: The intent 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<IntentResponse | undefined, Error>} React Query result object, including:
+ *   - `data`: The intent response or undefined if unavailable,
+ *   - `isLoading`: Loading state,
+ *   - `error`: Error (if request failed),
+ *   - `refetch`: Function to refetch the data.
  *
  * @example
- * ```typescript
- * const { data: intent, isLoading, error } = useIntentByTxHash('0x123...');
+ * const { data: intent, isLoading, error } = useBackendIntentByTxHash({
+ *   params: { txHash: '0x123...' },
+ * });
  *
  * if (isLoading) return <div>Loading intent...</div>;
  * if (error) return <div>Error: {error.message}</div>;
  * if (intent) {
  *   console.log('Intent found:', intent.intentHash);
  * }
- * ```
  *
  * @remarks
- * - Intents are only created on the hub chain, so the transaction hash must be from the hub chain
- * - The query is disabled when txHash is undefined or empty
- * - Uses React Query for efficient caching and state management
- * - Automatically handles error states and loading indicators
+ * - Intents are only created on the hub chain, so `txHash` must originate from there.
+ * - Query is disabled if `params` is undefined, or if `params.params.txHash` is undefined or an empty string.
+ * - Default refetch interval is 1 second. Uses React Query for state management, caching, and retries.
  */
 export const useBackendIntentByTxHash = (
-  txHash: string | undefined,
-  refetchInterval = 1000,
-): UseQueryResult<IntentResponse | undefined> => {
+  params: UseBackendIntentByTxHashParams | undefined,
+): UseQueryResult<IntentResponse | undefined, Error> => {
   const { sodax } = useSodaxContext();
 
+  const defaultQueryOptions = {
+    queryKey: ['api', 'intent', 'txHash', params?.params?.txHash],
+    enabled: !!params?.params?.txHash && params?.params?.txHash.length > 0,
+    retry: 3,
+    refetchInterval: 1000,
+  };
+
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions,
+  };
+
   return useQuery({
-    queryKey: ['backend', 'intent', 'txHash', txHash],
+    ...queryOptions,
     queryFn: async (): Promise<IntentResponse | undefined> => {
-      if (!txHash) {
+      if (!params?.params?.txHash) {
         return undefined;
       }
-
-      return sodax.backendApi.getIntentByTxHash(txHash);
+      return sodax.backendApi.getIntentByTxHash(params.params.txHash);
     },
-    refetchInterval,
-    enabled: !!txHash && txHash.length > 0,
-    retry: 3,
   });
 };