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

package/src/hooks/mm/useAToken.ts

@@ -1,45 +1,62 @@
-import type { Address, XToken } from '@sodax/sdk';
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { isAddress } from 'viem';
+import type { XToken } from '@sodax/sdk';
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
+export type UseATokenParams = {
+  aToken: string;
+  queryOptions?: UseQueryOptions<XToken, Error>;
+};
+
 /**
- * React hook for fetching an AToken's ERC20 metadata from the Sodax money market.
+ * React hook to fetch and cache metadata for a given aToken address.
+ *
+ * Accepts an aToken address and React Query options to control query behavior.
+ * Returns the aToken's ERC20-style metadata from the Sodax money market, with querying/caching
+ * powered by React Query.
  *
- * Fetches and caches the metadata (name, symbol, decimals, address) for a given aToken address and chain using React Query.
- * This metadata is typically required for rendering balances and labels in UI components.
+ * @param {UseATokenParams} params - Required params object:
+ *   @property {Address} aToken - The aToken contract address to query.
+ *   @property {UseQueryOptions<XToken, Error>} queryOptions - React Query options to control query (e.g., staleTime, refetch, etc.).
  *
- * @param {Address | undefined} aToken - The aToken contract address to look up. Should be an EVM address.
- * @param {ChainId | undefined} chainId - The EVM chain ID for the aToken.
+ * @returns {UseQueryResult<XToken, Error>} React Query result object:
+ *   - data: XToken metadata, if available
+ *   - isLoading: Boolean loading state
+ *   - error: Error, if API call fails
  *
  * @example
- * ```typescript
- * const { data: aToken, isLoading, error } = useAToken(aTokenAddress, chainId);
- * if (aToken) {
- *   console.log(aToken.symbol); // 'aETH'
+ * const { data: xToken, isLoading, error } = useAToken({ aToken: aTokenAddress, queryOptions: {} });
+ * if (xToken) {
+ *   console.log(xToken.symbol);
  * }
- * ```
- *
- * @returns {UseQueryResult<Erc20Token, Error>} A React Query result object containing:
- *   - data: The aToken ERC20 metadata when available.
- *   - isLoading: Loading state indicator.
- *   - error: Any error that occurred during data fetching.
  */
-export function useAToken(aToken: Address | undefined): UseQueryResult<XToken, Error> {
+export function useAToken({ aToken, queryOptions }: UseATokenParams): UseQueryResult<XToken, Error> {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ['mm', 'aToken', aToken],
+    enabled: !!aToken,
+  };
+  queryOptions = {
+    ...defaultQueryOptions,
+    ...queryOptions, // override default query options if provided
+  };
 
   return useQuery({
-    queryKey: ['aToken', sodax.hubProvider.chainConfig.chain.id, aToken],
+    ...queryOptions,
     queryFn: async () => {
       if (!aToken) {
         throw new Error('aToken address or hub provider is not defined');
       }
 
+      if (!isAddress(aToken)) {
+        throw new Error('aToken address is not a valid address');
+      }
+
       const aTokenData = await sodax.moneyMarket.data.getATokenData(aToken);
       return {
         ...aTokenData,
         xChainId: sodax.hubProvider.chainConfig.chain.id,
       };
     },
-    enabled: !!aToken,
   });
 }

package/src/hooks/mm/useBorrow.ts

@@ -1,66 +1,66 @@
-import type { SpokeChainId, XToken } from '@sodax/types';
 import { useMutation, type UseMutationResult } from '@tanstack/react-query';
-import { parseUnits } from 'viem';
 import { useSodaxContext } from '../shared/useSodaxContext';
-import type { SpokeProvider } from '@sodax/sdk';
+import type { MoneyMarketBorrowParams, MoneyMarketError, RelayErrorCode, SpokeProvider } from '@sodax/sdk';
+
 interface BorrowResponse {
   ok: true;
   value: [string, string];
 }
 
+export type UseBorrowParams = {
+  params: MoneyMarketBorrowParams;
+  spokeProvider: SpokeProvider;
+};
+
 /**
- * Hook for borrowing tokens from the Sodax money market.
- *
- * This hook provides functionality to borrow tokens from the money market protocol,
- * handling the entire borrow process including transaction creation, submission,
- * and cross-chain communication.
+ * React hook for borrowing tokens in the Sodax money market protocol.
  *
- * @param {XToken} spokeToken - The token to borrow from the spoke chain. Must be an XToken with valid address and chain information.
- * @param {SpokeProvider} spokeProvider - The spoke provider to use for the borrow transaction. Must be a valid SpokeProvider instance.
+ * Encapsulates the async process to initiate a borrow transaction via the money market,
+ * handling transaction creation, submission, and cross-chain logic.
  *
- * @returns {UseMutationResult<BorrowResponse, Error, string>} A mutation result object with the following properties:
- *   - mutateAsync: Function to execute the borrow transaction
- *   - isPending: Boolean indicating if a transaction is in progress
- *   - error: Error object if the last transaction failed, null otherwise
+ * @returns {UseMutationResult<
+ *   BorrowResponse,
+ *   MoneyMarketError<'CREATE_BORROW_INTENT_FAILED' | 'BORROW_UNKNOWN_ERROR' | RelayErrorCode>,
+ *   UseBorrowParams
+ * >} A React Query mutation result object containing:
+ *   - mutateAsync: (params: UseBorrowParams) => Promise<BorrowResponse>
+ *     Triggers the borrow action. Expects an object with valid borrow params and a `SpokeProvider`.
+ *   - isPending: `boolean` if a borrow transaction is in progress.
+ *   - error: `MoneyMarketError` if the transaction fails, or `null`.
  *
  * @example
  * ```typescript
- * const { mutateAsync: borrow, isPending, error } = useBorrow(spokeToken);
- * await borrow('100');
+ * const { mutateAsync: borrow, isPending, error } = useBorrow();
+ * await borrow({ params: borrowParams, spokeProvider });
  * ```
  *
  * @throws {Error} When:
- *   - spokeProvider is not available
- *   - Transaction execution fails
+ *   - `spokeProvider` is missing or invalid.
+ *   - The underlying borrow transaction fails.
  */
-export function useBorrow(
-  spokeToken: XToken,
-  spokeProvider: SpokeProvider | undefined,
-): UseMutationResult<BorrowResponse, Error, string> {
+export function useBorrow(): UseMutationResult<
+  BorrowResponse,
+  MoneyMarketError<'CREATE_BORROW_INTENT_FAILED' | 'BORROW_UNKNOWN_ERROR' | RelayErrorCode>,
+  UseBorrowParams
+> {
   const { sodax } = useSodaxContext();
 
-  return useMutation<BorrowResponse, Error, string>({
-    mutationFn: async (amount: string, toChainId?: SpokeChainId, toAddress?: string) => {
+  return useMutation<
+    BorrowResponse,
+    MoneyMarketError<'CREATE_BORROW_INTENT_FAILED' | 'BORROW_UNKNOWN_ERROR' | RelayErrorCode>,
+    UseBorrowParams
+  >({
+    mutationFn: async ({ params, spokeProvider }: UseBorrowParams) => {
       if (!spokeProvider) {
         throw new Error('spokeProvider is not found');
       }
 
-      const response = await sodax.moneyMarket.borrow(
-        {
-          token: spokeToken.address,
-          amount: parseUnits(amount, 18),
-          action: 'borrow',
-          toChainId: toChainId,
-          toAddress: toAddress,
-        },
-        spokeProvider,
-      );
+      const response = await sodax.moneyMarket.borrow(params, spokeProvider);
 
       if (!response.ok) {
-        throw new Error('Failed to borrow tokens');
+        throw response.error;
       }
 
-      console.log('Borrow transaction submitted:', response);
       return response;
     },
   });

package/src/hooks/mm/useMMAllowance.ts

@@ -1,8 +1,12 @@
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
-import type { XToken } from '@sodax/types';
+import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext';
-import { parseUnits } from 'viem';
-import type { MoneyMarketAction, SpokeProvider } from '@sodax/sdk';
+import type { MoneyMarketParams, SpokeProvider } from '@sodax/sdk';
+
+export type UseMMAllowanceParams = {
+  params: MoneyMarketParams | undefined;
+  spokeProvider: SpokeProvider | undefined;
+  queryOptions?: UseQueryOptions<boolean, Error>;
+};
 
 /**
  * Hook for checking token allowance for money market operations.
@@ -25,32 +29,37 @@ import type { MoneyMarketAction, SpokeProvider } from '@sodax/sdk';
  * const { data: hasAllowed, isLoading } = useMMAllowance(token, "100", "repay", provider);
  * ```
  */
-export function useMMAllowance(
-  token: XToken,
-  amount: string,
-  action: MoneyMarketAction,
-  spokeProvider: SpokeProvider | undefined,
-): UseQueryResult<boolean, Error> {
+export function useMMAllowance({
+  params,
+  spokeProvider,
+  queryOptions,
+}: UseMMAllowanceParams): UseQueryResult<boolean, Error> {
   const { sodax } = useSodaxContext();
 
+  const defaultQueryOptions = {
+    queryKey: ['mm', 'allowance', params?.token, params?.action],
+    enabled: !!spokeProvider,
+    refetchInterval: 5000,
+  };
+
+  queryOptions = {
+    ...defaultQueryOptions,
+    ...queryOptions, // override default query options if provided
+  }
+
   return useQuery({
-    queryKey: ['allowance', token.address, amount, action],
+    ...queryOptions,
     queryFn: async () => {
       if (!spokeProvider) throw new Error('Spoke provider is required');
-      const actionBasedDecimals = action === 'withdraw' || action === 'borrow' ? 18 : token.decimals; // withdraw and borrow actions are in aToken decimals
-      const allowance = await sodax.moneyMarket.isAllowanceValid(
-        {
-          token: token.address,
-          amount: parseUnits(amount, actionBasedDecimals),
-          action,
-        },
-        spokeProvider,
-      );
-      if (allowance.ok) {
-        return allowance.value;
+      if (!params) throw new Error('Params are required');
+
+      const allowance = await sodax.moneyMarket.isAllowanceValid(params, spokeProvider);
+
+      if (!allowance.ok) {
+        throw allowance.error;
       }
-      return false;
+
+      return allowance.value;
     },
-    enabled: !!spokeProvider,
   });
 }

package/src/hooks/mm/useMMApprove.ts

@@ -1,68 +1,63 @@
 import { useSodaxContext } from '../shared/useSodaxContext';
-import type { XToken } from '@sodax/types';
-import { parseUnits } from 'viem';
-import { useMutation, useQueryClient } from '@tanstack/react-query';
-import type { MoneyMarketAction, SpokeProvider } from '@sodax/sdk';
+import { useMutation, type UseMutationResult, useQueryClient } from '@tanstack/react-query';
+import type { MoneyMarketParams, SpokeProvider } from '@sodax/sdk';
 
-interface UseApproveReturn {
-  approve: ({ amount, action }: { amount: string; action: MoneyMarketAction }) => Promise<boolean>;
-  isLoading: boolean;
-  error: Error | null;
-  resetError: () => void;
-}
+export type UseMMApproveParams = {
+  params: MoneyMarketParams;
+  spokeProvider: SpokeProvider | undefined;
+};
 
 /**
- * Hook for approving token spending for money market actions
- * @param token The token 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
+ * Hook for approving ERC20 token spending for Sodax money market actions.
+ *
+ * This hook manages the approval transaction, allowing the user
+ * to grant the protocol permission to spend their tokens for specific money market actions
+ * (such as supply, borrow, or repay). Upon successful approval, it also invalidates and
+ * refetches the associated allowance status so the UI remains up-to-date.
+ *
+ * @returns {UseMutationResult<string, Error, UseMMApproveParams>} A React Query mutation result containing:
+ *   - mutateAsync: Function to trigger the approval (see below)
+ *   - isPending: Boolean indicating if approval transaction is in progress
+ *   - error: Error object if the last approval failed, null otherwise
+ *
  * @example
  * ```tsx
- * const { approve, isLoading, error } = useMMApprove(token, spokeProvider);
- *
- * // Approve tokens for supply action
- * await approve({ amount: "100", action: "supply" });
+ * const { mutateAsync: approve, isPending, error } = useMMApprove();
+ * await approve({ params: { token, amount: "100", action: "supply", ... }, spokeProvider });
  * ```
+ *
+ * @throws {Error} When:
+ *   - spokeProvider is undefined or invalid
+ *   - Approval transaction fails for any reason
  */
-
-export function useMMApprove(token: XToken, spokeProvider: SpokeProvider | undefined): UseApproveReturn {
+export function useMMApprove(): UseMutationResult<string, Error, UseMMApproveParams> {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
 
-  const {
-    mutateAsync: approve,
-    isPending,
-    error,
-    reset: resetError,
-  } = useMutation({
-    mutationFn: async ({ amount, action }: { amount: string; action: MoneyMarketAction }) => {
+  return useMutation({
+    mutationFn: async ({ params, spokeProvider }: UseMMApproveParams) => {
       if (!spokeProvider) {
         throw new Error('Spoke provider not found');
       }
-      const actionBasedDecimals = action === 'withdraw' || action === 'borrow' ? 18 : token.decimals; // withdraw and borrow actions are in aToken decimals
-      const allowance = await sodax.moneyMarket.approve(
-        {
-          token: token.address,
-          amount: parseUnits(amount, actionBasedDecimals),
-          action,
-        },
-        spokeProvider,
-      );
+      const allowance = await sodax.moneyMarket.approve(params, spokeProvider, false);
       if (!allowance.ok) {
-        throw new Error('Failed to approve tokens');
+        throw allowance.error;
       }
-      return allowance.ok;
+
+      return allowance.value;
     },
-    onSuccess: () => {
-      // Invalidate allowance query to refetch the new allowance
-      queryClient.invalidateQueries({ queryKey: ['allowance', token.address] });
+    onSuccess: (_, { params, spokeProvider }: UseMMApproveParams) => {
+      console.log('onSuccess invoked with queryKey:', [
+        'mm',
+        'allowance',
+        spokeProvider?.chainConfig.chain.id,
+        params.token,
+        params.action,
+      ]);
+      // Invalidate allowance query to refetch updated approval status
+      queryClient.invalidateQueries({
+        queryKey: ['mm', 'allowance', spokeProvider?.chainConfig.chain.id, params.token, params.action],
+      });
     },
   });
-
-  return {
-    approve,
-    isLoading: isPending,
-    error: error,
-    resetError,
-  };
 }

package/src/hooks/mm/useRepay.ts

@@ -1,7 +1,5 @@
-import type { SpokeProvider } from '@sodax/sdk';
-import type { SpokeChainId, XToken } from '@sodax/types';
+import type { MoneyMarketError, MoneyMarketRepayParams, RelayErrorCode, SpokeProvider } from '@sodax/sdk';
 import { useMutation, type UseMutationResult } from '@tanstack/react-query';
-import { parseUnits } from 'viem';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
 interface RepayResponse {
@@ -9,59 +7,57 @@ interface RepayResponse {
   value: [string, string];
 }
 
+export type UseRepayParams = {
+  params: MoneyMarketRepayParams;
+  spokeProvider: SpokeProvider;
+};
+
 /**
- * Hook for repaying borrowed tokens to the Sodax money market.
- *
- * This hook provides functionality to repay borrowed tokens back to the money market protocol,
- * handling the entire repayment process including transaction creation, submission,
- * and cross-chain communication.
+ * React hook for repaying a borrow in the Sodax money market protocol.
  *
- * @param {XToken} spokeToken - The token to repay on the spoke chain. Must be an XToken with valid address and chain information.
- * @param {SpokeProvider} spokeProvider - The spoke provider to use for the repay transaction. Must be a valid SpokeProvider instance.
+ * This hook encapsulates the process of sending a repay transaction to the money market.
+ * It manages the asynchronous operation for repayment, including sending the transaction
+ * and error handling.
  *
- * @returns {UseMutationResult<RepayResponse, Error, string>} A mutation result object with the following properties:
- *   - mutateAsync: Function to execute the repay transaction
- *   - isPending: Boolean indicating if a transaction is in progress
- *   - error: Error object if the last transaction failed, null otherwise
+ * @returns {UseMutationResult<RepayResponse, MoneyMarketError<'CREATE_REPAY_INTENT_FAILED' | 'REPAY_UNKNOWN_ERROR' | RelayErrorCode>, UseRepayParams>} React Query mutation result object containing:
+ *   - mutateAsync: (params: UseRepayParams) => Promise<RepayResponse>
+ *     Initiates a repay transaction using the given MoneyMarketRepayParams and SpokeProvider.
+ *   - isPending: boolean indicating if a transaction is in progress.
+ *   - error: MoneyMarketError if an error occurred while repaying, otherwise undefined.
  *
  * @example
  * ```typescript
- * const { mutateAsync: repay, isPending, error } = useRepay(spokeToken);
- * await repay('100');
+ * const { mutateAsync: repay, isPending, error } = useRepay();
+ * await repay({ params: repayParams, spokeProvider });
  * ```
  *
  * @throws {Error} When:
- *   - spokeProvider is not available
- *   - Transaction execution fails
+ *   - `spokeProvider` is missing or invalid.
+ *   - The underlying repay transaction fails.
  */
-export function useRepay(
-  spokeToken: XToken,
-  spokeProvider: SpokeProvider | undefined,
-): UseMutationResult<RepayResponse, Error, string> {
+export function useRepay(): UseMutationResult<
+  RepayResponse,
+  MoneyMarketError<'CREATE_REPAY_INTENT_FAILED' | 'REPAY_UNKNOWN_ERROR' | RelayErrorCode>,
+  UseRepayParams
+> {
   const { sodax } = useSodaxContext();
 
-  return useMutation<RepayResponse, Error, string>({
-    mutationFn: async (amount: string, toChainId?: SpokeChainId, toAddress?: string) => {
+  return useMutation<
+    RepayResponse,
+    MoneyMarketError<'CREATE_REPAY_INTENT_FAILED' | 'REPAY_UNKNOWN_ERROR' | RelayErrorCode>,
+    UseRepayParams
+  >({
+    mutationFn: async ({ params, spokeProvider }: UseRepayParams) => {
       if (!spokeProvider) {
         throw new Error('spokeProvider is not found');
       }
 
-      const response = await sodax.moneyMarket.repay(
-        {
-          token: spokeToken.address,
-          amount: parseUnits(amount, spokeToken.decimals),
-          action: 'repay',
-          toChainId: toChainId,
-          toAddress: toAddress,
-        },
-        spokeProvider,
-      );
+      const response = await sodax.moneyMarket.repay(params, spokeProvider);
 
       if (!response.ok) {
-        throw new Error('Failed to repay tokens');
+        throw response.error;
       }
 
-      console.log('Repay transaction submitted:', response);
       return response;
     },
   });

package/src/hooks/mm/useReservesData.ts

@@ -1,29 +1,48 @@
-import { useQuery } from '@tanstack/react-query';
+import { useQuery, type UseQueryResult, type UseQueryOptions } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext';
+import type { AggregatedReserveData, BaseCurrencyInfo } from '@sodax/sdk';
+
+export type UseReservesDataParams = {
+  queryOptions?: UseQueryOptions<readonly [readonly AggregatedReserveData[], BaseCurrencyInfo], Error>;
+};
+
 /**
- * Hook for fetching reserves data from the Sodax money market.
+ * React hook for fetching the latest reserves data from the Sodax money market.
  *
- * This hook provides access to the current state of all reserves in the money market protocol,
- * including liquidity, interest rates, and other key metrics. The data is automatically
- * fetched and cached using React Query.
+ * Provides the full set of aggregated reserves and base currency information.
+ * Optionally accepts React Query options for customizing the query key, cache time, and related behaviors.
  *
- * @example
- * ```typescript
- * const { data: reservesData, isLoading, error } = useReservesData();
- * ```
+ * @param params (optional) - Object including:
+ *   - queryOptions: Custom React Query options
  *
- * @returns A React Query result object containing:
- *   - data: The reserves data when available
- *   - isLoading: Loading state indicator
- *   - error: Any error that occurred during data fetching
+ * @returns {UseQueryResult<readonly [readonly AggregatedReserveData[], BaseCurrencyInfo], Error>}
+ *   React Query result object containing:
+ *     - data: [aggregated reserves[], base currency info], or undefined if not loaded
+ *     - isLoading: True if the request is loading
+ *     - isError: True if the request failed
+ *     - error: Error object, if present
+ *
+ * @example
+ * const { data, isLoading, error } = useReservesData();
+ * const { data } = useReservesData({ queryOptions: { queryKey: ['custom', 'reservesData'] } });
  */
+export function useReservesData(
+  params?: UseReservesDataParams,
+): UseQueryResult<readonly [readonly AggregatedReserveData[], BaseCurrencyInfo], Error> {
+  const defaultQueryOptions = {
+    queryKey: ['mm', 'reservesData'],
+    refetchInterval: 5000,
+  };
 
-export function useReservesData() {
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions, // override default query options if provided
+  }
   const { sodax } = useSodaxContext();
 
   return useQuery({
-    queryKey: ['reservesData'],
-    queryFn: async () => {
+    ...queryOptions,
+    queryFn: async (): Promise<readonly [readonly AggregatedReserveData[], BaseCurrencyInfo]> => {
       return await sodax.moneyMarket.data.getReservesData();
     },
   });

package/src/hooks/mm/useReservesHumanized.ts

@@ -1,6 +1,11 @@
 import type { ReservesDataHumanized } 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 UseReservesHumanizedParams = {
+  queryOptions?: UseQueryOptions<ReservesDataHumanized, Error>;
+};
+
 /**
  * Hook for fetching humanized reserves data from the Sodax money market.
  *
@@ -18,11 +23,18 @@ import { useSodaxContext } from '../shared/useSodaxContext';
  *   - isLoading: Loading state indicator
  *   - error: Any error that occurred during data fetching
  */
-export function useReservesHumanized(): UseQueryResult<ReservesDataHumanized, Error> {
+export function useReservesHumanized(
+  params?: UseReservesHumanizedParams,
+): UseQueryResult<ReservesDataHumanized, Error> {
+  const defaultQueryOptions = { queryKey: ['mm', 'reservesHumanized'], refetchInterval: 5000 };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions, // override default query options if provided
+  };
   const { sodax } = useSodaxContext();
 
   return useQuery({
-    queryKey: ['reservesHumanized'],
+    ...queryOptions,
     queryFn: async () => {
       return await sodax.moneyMarket.data.getReservesHumanized();
     },

package/src/hooks/mm/useReservesList.ts

@@ -1,28 +1,41 @@
-import { useQuery } from '@tanstack/react-query';
+import { useQuery, type UseQueryResult, type UseQueryOptions } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext';
+import type { Address } from '@sodax/sdk';
+
+export type UseReservesListParams = {
+  queryOptions?: UseQueryOptions<readonly Address[], Error>;
+};
 
 /**
- * Hook for fetching list of reserves from the Sodax money market.
+ * React hook for fetching the list of reserve addresses from the Sodax money market.
+ *
+ * This hook returns a React Query result object containing the array of all reserve `Address`
+ * values currently available in the protocol. Optionally, custom React Query options can be provided.
  *
- * This hook provides access to the list of addresses of all reserves in the money market protocol.
- * The data is automatically fetched and cached using React Query.
+ * @param params (optional) - Object including:
+ *   - queryOptions: Custom React Query options such as `queryKey`, cache behavior, or refetching policy
+ *
+ * @returns {UseQueryResult<readonly Address[], Error>} React Query result object containing:
+ *   - data: Array of reserve addresses, or undefined if loading
+ *   - isLoading: Boolean loading state
+ *   - isError: Boolean error state
+ *   - error: Error object, if present
  *
  * @example
- * ```typescript
  * const { data: reservesList, isLoading, error } = useReservesList();
- * ```
- *
- * @returns A React Query result object containing:
- *   - data: The reserves list when available
- *   - isLoading: Loading state indicator
- *   - error: Any error that occurred during data fetching
+ * const { data } = useReservesList({ queryOptions: { queryKey: ['custom', 'reservesList'] } });
  */
-export function useReservesList() {
+export function useReservesList(params?: UseReservesListParams): UseQueryResult<readonly Address[], Error> {
+  const defaultQueryOptions = { queryKey: ['mm', 'reservesList'] };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions, // override default query options if provided
+  };
   const { sodax } = useSodaxContext();
 
-  return useQuery({
-    queryKey: ['reservesList'],
-    queryFn: async () => {
+  return useQuery<readonly Address[], Error>({
+    ...queryOptions,
+    queryFn: async (): Promise<readonly Address[]> => {
       return await sodax.moneyMarket.data.getReservesList();
     },
   });