@sodax/dapp-kit 1.5.6-beta → 2.0.0-rc.1

package/src/hooks/mm/useATokensBalances.ts

@@ -1,82 +1,51 @@
-// packages/dapp-kit/src/hooks/mm/useATokens.ts
-import { isAddress, type Address } from 'viem';
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type { SpokeProvider } from '@sodax/sdk';
-import { HubService } from '@sodax/sdk';
+import type { SpokeChainKey } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { type Address, isAddress } from 'viem';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { ReadHookParams } from '../shared/types.js';
 
-export type UseATokensBalancesParams = {
-  aTokens: readonly Address[];
-  spokeProvider?: SpokeProvider;
-  userAddress?: string;
-  queryOptions?: UseQueryOptions<Map<Address, bigint>, Error>;
-};
+export type UseATokensBalancesParams = ReadHookParams<
+  Map<Address, bigint>,
+  {
+    aTokens: readonly Address[];
+    spokeChainKey: SpokeChainKey | undefined;
+    userAddress: string | undefined;
+  }
+>;
 
 /**
- * React hook to fetch and cache aToken balances for multiple aToken addresses in a single multicall.
- *
- * Accepts an array of aToken addresses, a spoke provider, and user address. The hook derives the user's
- * hub wallet address and then fetches balanceOf for each aToken in a single multicall. Returns a Map
- * of aToken address to balance, with querying/caching powered by React Query. This hook uses viem's
- * multicall to batch all requests into a single RPC call for better performance.
- *
- * @param {UseATokensBalancesParams} params - Required params object:
- *   @property {readonly Address[]} aTokens - Array of aToken contract addresses to query balances for.
- *   @property {SpokeProvider} spokeProvider - The spoke provider to derive hub wallet address from.
- *   @property {string} userAddress - User's wallet address on the spoke chain.
- *   @property {UseQueryOptions<Map<Address, bigint>, Error>} queryOptions - React Query options to control query (e.g., staleTime, refetch, etc.).
- *
- * @returns {UseQueryResult<Map<Address, bigint>, Error>} React Query result object:
- *   - data: Map of aToken address to balance, if available
- *   - isLoading: Boolean loading state
- *   - error: Error, if API call fails
- *
- * @example
- * const { data: aTokenBalances, isLoading, error } = useATokensBalances({
- *   aTokens: [aToken1, aToken2, aToken3],
- *   spokeProvider,
- *   userAddress: '0x...',
- *   queryOptions: {}
- * });
- * const aToken1Balance = aTokenBalances?.get(aToken1);
+ * React hook to fetch aToken balances for a list of addresses in a single multicall.
+ * Derives the user's hub wallet via `EvmHubProvider.getUserHubWalletAddress` from the
+ * spoke `chainKey` + spoke wallet `userAddress`.
  */
 export function useATokensBalances({
-  aTokens,
-  spokeProvider,
-  userAddress,
+  params,
   queryOptions,
-}: UseATokensBalancesParams): UseQueryResult<Map<Address, bigint>, Error> {
+}: UseATokensBalancesParams = {}): UseQueryResult<Map<Address, bigint>, Error> {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = {
-    queryKey: ['mm', 'aTokensBalances', aTokens, spokeProvider?.chainConfig.chain.id, userAddress],
-    enabled: aTokens.length > 0 && aTokens.every(token => isAddress(token)) && !!spokeProvider && !!userAddress,
-  };
-  queryOptions = {
-    ...defaultQueryOptions,
-    ...queryOptions, // override default query options if provided
-  };
+  const aTokens = params?.aTokens ?? [];
+  const spokeChainKey = params?.spokeChainKey;
+  const userAddress = params?.userAddress;
 
   return useQuery({
-    ...queryOptions,
+    queryKey: ['mm', 'aTokensBalances', aTokens, spokeChainKey, userAddress],
     queryFn: async () => {
       if (aTokens.length === 0) {
-        return new Map();
+        return new Map<Address, bigint>();
       }
-
-      if (!spokeProvider || !userAddress) {
-        throw new Error('Spoke provider and user address are required');
+      if (!spokeChainKey || !userAddress) {
+        throw new Error('spokeChainKey and userAddress are required');
       }
-
-      // Validate all addresses
       for (const aToken of aTokens) {
         if (!isAddress(aToken)) {
           throw new Error(`Invalid aToken address: ${aToken}`);
         }
       }
 
-      const hubWalletAddress = await HubService.getUserHubWalletAddress(userAddress, spokeProvider.chainConfig.chain.id, sodax.hubProvider);
-
-      return await sodax.moneyMarket.data.getATokensBalances(aTokens, hubWalletAddress);
+      const hubWalletAddress = await sodax.hubProvider.getUserHubWalletAddress(userAddress, spokeChainKey);
+      return sodax.moneyMarket.data.getATokensBalances(aTokens, hubWalletAddress);
     },
+    enabled: aTokens.length > 0 && !!spokeChainKey && !!userAddress,
+    ...queryOptions,
   });
 }

package/src/hooks/mm/useBorrow.ts

@@ -1,67 +1,49 @@
-import { useMutation, type UseMutationResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type { MoneyMarketBorrowParams, MoneyMarketError, RelayErrorCode, SpokeProvider } from '@sodax/sdk';
+// packages/dapp-kit/src/hooks/mm/useBorrow.ts
+import type { MoneyMarketBorrowActionParams, SpokeChainKey, TxHashPair } from '@sodax/sdk';
+import { useQueryClient } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
 
-interface BorrowResponse {
-  ok: true;
-  value: [string, string];
-}
-
-export type UseBorrowParams = {
-  params: MoneyMarketBorrowParams;
-  spokeProvider: SpokeProvider;
-};
+/**
+ * Mutation variables for {@link useBorrow}. Generic over `K extends SpokeChainKey` (defaults to
+ * the full union). Sophisticated callers can lock K at the hook call site to narrow the
+ * `walletProvider` and `params.srcChainKey` types.
+ */
+export type UseBorrowVars<K extends SpokeChainKey = SpokeChainKey> = Omit<
+  MoneyMarketBorrowActionParams<K, false>,
+  'raw'
+>;
 
 /**
- * React hook for borrowing tokens in the Sodax money market protocol.
- *
- * Encapsulates the async process to initiate a borrow transaction via the money market,
- * handling transaction creation, submission, and cross-chain logic.
- *
- * @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`.
+ * React hook for borrowing tokens from the Sodax money market protocol.
  *
- * @example
- * ```typescript
- * const { mutateAsync: borrow, isPending, error } = useBorrow();
- * await borrow({ params: borrowParams, spokeProvider });
- * ```
- *
- * @throws {Error} When:
- *   - `spokeProvider` is missing or invalid.
- *   - The underlying borrow transaction fails.
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped `TxHashPair` on success.
  */
-export function useBorrow(): UseMutationResult<
-  BorrowResponse,
-  MoneyMarketError<'CREATE_BORROW_INTENT_FAILED' | 'BORROW_UNKNOWN_ERROR' | RelayErrorCode>,
-  UseBorrowParams
-> {
+export function useBorrow<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxHashPair, UseBorrowVars<K>> = {}): SafeUseMutationResult<TxHashPair, Error, UseBorrowVars<K>> {
   const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
 
-  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');
+  return useSafeMutation<TxHashPair, Error, UseBorrowVars<K>>({
+    mutationKey: ['mm', 'borrow'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.moneyMarket.borrow({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ['mm', 'userReservesData', params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({
+        queryKey: ['mm', 'userFormattedSummary', params.srcChainKey, params.srcAddress],
+      });
+      queryClient.invalidateQueries({ queryKey: ['mm', 'aTokensBalances'] });
+      const balanceChains = new Set([params.srcChainKey, params.dstChainKey ?? params.srcChainKey]);
+      for (const chainKey of balanceChains) {
+        queryClient.invalidateQueries({ queryKey: ['shared', 'xBalances', chainKey] });
       }
-
-      const response = await sodax.moneyMarket.borrow(params, spokeProvider);
-
-      if (!response.ok) {
-        throw response.error;
-      }
-
-      return response;
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     },
   });
 }

package/src/hooks/mm/useMMAllowance.ts

@@ -1,93 +1,57 @@
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type { MoneyMarketParams, SpokeProvider } from '@sodax/sdk';
-
-export type UseMMAllowanceParams = {
-  params: MoneyMarketParams | undefined;
-  spokeProvider: SpokeProvider | undefined;
-  queryOptions?: UseQueryOptions<boolean, Error>;
-};
+import type { MoneyMarketParams } from '@sodax/sdk';
+import type { SpokeChainKey } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseMMAllowanceParams<K extends SpokeChainKey> = ReadHookParams<
+  boolean,
+  {
+    payload: MoneyMarketParams<K> | undefined;
+  }
+>;
 
 /**
- * Hook for checking token allowance for money market operations.
- *
- * This hook verifies if the user has approved enough tokens for a specific money market action
- * (borrow/repay). It automatically queries and tracks the allowance status.
+ * Hook for checking token allowance / trustline sufficiency for money market operations.
  *
- * @param {XToken} token - The token to check allowance for. Must be an XToken with valid address and chain information.
- * @param {string} amount - The amount to check allowance for, as a decimal string
- * @param {MoneyMarketAction} action - The money market action to check allowance for ('borrow' or 'repay')
- * @param {SpokeProvider} spokeProvider - The spoke provider to use for allowance checks
+ * Skips the on-chain check entirely for `borrow` and `withdraw` actions — those don't require
+ * approval, and the SDK already short-circuits to `true` for them. The early `enabled: false`
+ * here additionally avoids a render flash with `isLoading: true`.
  *
- * @returns {UseQueryResult<boolean, Error>} A React Query result containing:
- *   - data: Boolean indicating if allowance is sufficient
- *   - isLoading: Loading state indicator
- *   - error: Any error that occurred during the check
+ * The query key matches the invalidation keys emitted by `useMMApprove` and the four mutation
+ * hooks: `['mm', 'allowance', srcChainKey, token, action]`.
  *
  * @example
- * ```typescript
- * const { data: hasAllowed, isLoading } = useMMAllowance(token, "100", "repay", provider);
+ * ```tsx
+ * const { data: hasAllowance } = useMMAllowance({ params: { payload: supplyParams } });
  * ```
  */
-export function useMMAllowance({
+export function useMMAllowance<K extends SpokeChainKey>({
   params,
-  spokeProvider,
   queryOptions,
-}: UseMMAllowanceParams): UseQueryResult<boolean, Error> {
+}: UseMMAllowanceParams<K> = {}): UseQueryResult<boolean, Error> {
   const { sodax } = useSodaxContext();
+  const payload = params?.payload;
 
-  const defaultQueryOptions = {
-    queryKey: ['mm', 'allowance', params?.token, params?.action],
-    /**
-     * IMPORTANT: Skip allowance checks for 'borrow' and 'withdraw' actions.
-     *
-     * Reason: According to the SDK's MoneyMarketService.isAllowanceValid() implementation,
-     * borrow and withdraw actions do NOT require ERC-20 token approval. The SDK's
-     * isAllowanceValid() method always returns `true` for these actions without making
-     * any on-chain allowance checks.
-     *
-     * This optimization prevents unnecessary RPC calls and avoids showing confusing states for actions that don't actually need approval.
-     *
-     * Only 'supply' and 'repay' actions require token approval and should trigger allowance checks.
-     */
-    enabled: !!spokeProvider && !!params && params.action !== 'borrow' && params.action !== 'withdraw',
-    refetchInterval: 5000,
-    gcTime: 0, // Don't cache failed queries
-  };
-
-  queryOptions = {
-    ...defaultQueryOptions,
-    ...queryOptions, // override default query options if provided
-  };
-
-  return useQuery({
-    ...queryOptions,
+  return useQuery<boolean, Error>({
+    queryKey: ['mm', 'allowance', payload?.srcChainKey, payload?.token, payload?.action],
     queryFn: async () => {
-      if (!spokeProvider) throw new Error('Spoke provider is required');
-      if (!params) throw new Error('Params are required');
-
-      /**
-       * Early return for borrow/withdraw actions: these actions do NOT require ERC-20 token approval.
-       *
-       * The SDK's MoneyMarketService.isAllowanceValid() always returns `true` for borrow/withdraw
-       * without checking on-chain allowance. This is because:
-       * - Borrow: User receives tokens (no approval needed)
-       * - Withdraw: User withdraws their own supplied tokens (no approval needed)
-       *
-       * By returning `true` here, we avoid unnecessary RPC calls and ensure consistent behavior
-       * with the SDK's implementation.
-       */
-      if (params.action === 'borrow' || params.action === 'withdraw') {
-        return true;
+      if (!payload) {
+        throw new Error('Params are required');
       }
 
-      const allowance = await sodax.moneyMarket.isAllowanceValid(params, spokeProvider);
-
-      if (!allowance.ok) {
-        throw allowance.error;
+      // Borrow and withdraw don't require approval; SDK returns true instantly anyway.
+      if (payload.action === 'borrow' || payload.action === 'withdraw') {
+        return true;
       }
 
-      return allowance.value;
+      const result = await sodax.moneyMarket.isAllowanceValid({ params: payload });
+      if (!result.ok) throw result.error;
+      return result.value;
     },
+    enabled: !!payload && payload.action !== 'borrow' && payload.action !== 'withdraw',
+    refetchInterval: 5000,
+    gcTime: 0,
+    ...queryOptions,
   });
 }

package/src/hooks/mm/useMMApprove.ts

@@ -1,56 +1,49 @@
-import { useSodaxContext } from '../shared/useSodaxContext';
-import { useMutation, type UseMutationResult, useQueryClient } from '@tanstack/react-query';
-import type { MoneyMarketParams, SpokeProvider } from '@sodax/sdk';
+// packages/dapp-kit/src/hooks/mm/useMMApprove.ts
+import type { MoneyMarketApproveActionParams, SpokeChainKey, TxReturnType } from '@sodax/sdk';
+import { useQueryClient } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
 
-export type UseMMApproveParams = {
-  params: MoneyMarketParams;
-  spokeProvider: SpokeProvider | undefined;
-};
+/**
+ * Mutation variables for {@link useMMApprove}. Generic over `K extends SpokeChainKey` (defaults
+ * to the full union). Sophisticated callers can lock K at the hook call site to narrow the
+ * `walletProvider` and `params.srcChainKey` types.
+ */
+export type UseMMApproveVars<K extends SpokeChainKey = SpokeChainKey> = Omit<
+  MoneyMarketApproveActionParams<K, false>,
+  'raw'
+>;
 
 /**
- * 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
+ * React hook for approving ERC-20 token spending (or trustline establishment) for a Sodax money
+ * market action.
  *
- * @example
- * ```tsx
- * 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
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped tx return value on success. Invalidates the matching
+ * `['mm', 'allowance', srcChainKey, token, action]` query on confirmed success.
  */
-export function useMMApprove(): UseMutationResult<string, Error, UseMMApproveParams> {
+export function useMMApprove<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxReturnType<K, false>, UseMMApproveVars<K>> = {}): SafeUseMutationResult<
+  TxReturnType<K, false>,
+  Error,
+  UseMMApproveVars<K>
+> {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
 
-  return useMutation({
-    mutationFn: async ({ params, spokeProvider }: UseMMApproveParams) => {
-      if (!spokeProvider) {
-        throw new Error('Spoke provider not found');
-      }
-      const allowance = await sodax.moneyMarket.approve(params, spokeProvider, false);
-      if (!allowance.ok) {
-        throw allowance.error;
-      }
-
-      return allowance.value;
-    },
-    onSuccess: (_, { params, spokeProvider }: UseMMApproveParams) => {
-      // Invalidate allowance query to refetch updated approval status
+  return useSafeMutation<TxReturnType<K, false>, Error, UseMMApproveVars<K>>({
+    mutationKey: ['mm', 'approve'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.moneyMarket.approve({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
       queryClient.invalidateQueries({
-        queryKey: ['mm', 'allowance', spokeProvider?.chainConfig.chain.id, params.token, params.action],
+        queryKey: ['mm', 'allowance', params.srcChainKey, params.token, params.action],
       });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     },
   });
 }

package/src/hooks/mm/useRepay.ts

@@ -1,64 +1,44 @@
-import type { MoneyMarketError, MoneyMarketRepayParams, RelayErrorCode, SpokeProvider } from '@sodax/sdk';
-import { useMutation, type UseMutationResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
+// packages/dapp-kit/src/hooks/mm/useRepay.ts
+import type { MoneyMarketRepayActionParams, SpokeChainKey, TxHashPair } from '@sodax/sdk';
+import { useQueryClient } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
 
-interface RepayResponse {
-  ok: true;
-  value: [string, string];
-}
-
-export type UseRepayParams = {
-  params: MoneyMarketRepayParams;
-  spokeProvider: SpokeProvider;
-};
+/**
+ * Mutation variables for {@link useRepay}. Generic over `K extends SpokeChainKey` (defaults to
+ * the full union). Sophisticated callers can lock K at the hook call site to narrow the
+ * `walletProvider` and `params.srcChainKey` types.
+ */
+export type UseRepayVars<K extends SpokeChainKey = SpokeChainKey> = Omit<MoneyMarketRepayActionParams<K, false>, 'raw'>;
 
 /**
  * React hook for repaying a borrow in the Sodax money market protocol.
  *
- * 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, 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();
- * await repay({ params: repayParams, spokeProvider });
- * ```
- *
- * @throws {Error} When:
- *   - `spokeProvider` is missing or invalid.
- *   - The underlying repay transaction fails.
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped `TxHashPair` on success.
  */
-export function useRepay(): UseMutationResult<
-  RepayResponse,
-  MoneyMarketError<'CREATE_REPAY_INTENT_FAILED' | 'REPAY_UNKNOWN_ERROR' | RelayErrorCode>,
-  UseRepayParams
-> {
+export function useRepay<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxHashPair, UseRepayVars<K>> = {}): SafeUseMutationResult<TxHashPair, Error, UseRepayVars<K>> {
   const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
 
-  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(params, spokeProvider);
-
-      if (!response.ok) {
-        throw response.error;
-      }
-
-      return response;
+  return useSafeMutation<TxHashPair, Error, UseRepayVars<K>>({
+    mutationKey: ['mm', 'repay'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.moneyMarket.repay({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ['mm', 'userReservesData', params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({
+        queryKey: ['mm', 'userFormattedSummary', params.srcChainKey, params.srcAddress],
+      });
+      queryClient.invalidateQueries({ queryKey: ['mm', 'aTokensBalances'] });
+      queryClient.invalidateQueries({ queryKey: ['mm', 'allowance', params.srcChainKey, params.token, params.action] });
+      queryClient.invalidateQueries({ queryKey: ['shared', 'xBalances', params.srcChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     },
   });
 }

package/src/hooks/mm/useReservesData.ts

@@ -1,49 +1,23 @@
-import { useQuery, type UseQueryResult, type UseQueryOptions } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
 import type { AggregatedReserveData, BaseCurrencyInfo } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { ReadHookParams } from '../shared/types.js';
 
-export type UseReservesDataParams = {
-  queryOptions?: UseQueryOptions<readonly [readonly AggregatedReserveData[], BaseCurrencyInfo], Error>;
-};
+export type UseReservesDataParams = ReadHookParams<readonly [readonly AggregatedReserveData[], BaseCurrencyInfo]>;
 
 /**
- * React hook for fetching the latest reserves data from the Sodax money market.
- *
- * 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.
- *
- * @param params (optional) - Object including:
- *   - queryOptions: Custom React Query options
- *
- * @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'] } });
+ * React hook for fetching the latest aggregated reserves data and base-currency info from the
+ * Sodax money market.
  */
-export function useReservesData(
-  params?: UseReservesDataParams,
-): UseQueryResult<readonly [readonly AggregatedReserveData[], BaseCurrencyInfo], Error> {
-  const defaultQueryOptions = {
-    queryKey: ['mm', 'reservesData'],
-    refetchInterval: 5000,
-  };
-
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions, // override default query options if provided
-  }
+export function useReservesData({
+  queryOptions,
+}: UseReservesDataParams = {}): UseQueryResult<readonly [readonly AggregatedReserveData[], BaseCurrencyInfo], Error> {
   const { sodax } = useSodaxContext();
 
   return useQuery({
+    queryKey: ['mm', 'reservesData'],
+    queryFn: async () => sodax.moneyMarket.data.getReservesData(),
+    refetchInterval: 5000,
     ...queryOptions,
-    queryFn: async (): Promise<readonly [readonly AggregatedReserveData[], BaseCurrencyInfo]> => {
-      return await sodax.moneyMarket.data.getReservesData();
-    },
   });
 }