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

package/src/hooks/mm/useReservesHumanized.ts

@@ -1,42 +1,23 @@
 import type { ReservesDataHumanized } from '@sodax/sdk';
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { ReadHookParams } from '../shared/types.js';
 
-export type UseReservesHumanizedParams = {
-  queryOptions?: UseQueryOptions<ReservesDataHumanized, Error>;
-};
+export type UseReservesHumanizedParams = ReadHookParams<ReservesDataHumanized>;
 
 /**
- * Hook for fetching humanized reserves data from the Sodax money market.
- *
- * This hook provides access to the current state of all reserves (humanized format) in the money market protocol,
- * including liquidity, interest rates, and other key metrics. The data is automatically
- * fetched and cached using React Query.
- *
- * @example
- * ```typescript
- * const { data: reservesHumanized, isLoading, error } = useReservesHumanized();
- * ```
- *
- * @returns A React Query result object containing:
- *   - data: The reserves humanized data when available
- *   - isLoading: Loading state indicator
- *   - error: Any error that occurred during data fetching
+ * React hook for fetching the human-readable (decimal-normalized, string-formatted) reserves
+ * snapshot from the Sodax money market.
  */
-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
-  };
+export function useReservesHumanized({
+  queryOptions,
+}: UseReservesHumanizedParams = {}): UseQueryResult<ReservesDataHumanized, Error> {
   const { sodax } = useSodaxContext();
 
   return useQuery({
+    queryKey: ['mm', 'reservesHumanized'],
+    queryFn: async () => sodax.moneyMarket.data.getReservesHumanized(),
+    refetchInterval: 5000,
     ...queryOptions,
-    queryFn: async () => {
-      return await sodax.moneyMarket.data.getReservesHumanized();
-    },
   });
 }

package/src/hooks/mm/useReservesList.ts

@@ -1,42 +1,22 @@
-import { useQuery, type UseQueryResult, type UseQueryOptions } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
 import type { Address } 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 UseReservesListParams = {
-  queryOptions?: UseQueryOptions<readonly Address[], Error>;
-};
+export type UseReservesListParams = ReadHookParams<readonly Address[]>;
 
 /**
- * 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.
- *
- * @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
- * const { data: reservesList, isLoading, error } = useReservesList();
- * const { data } = useReservesList({ queryOptions: { queryKey: ['custom', 'reservesList'] } });
+ * React hook for fetching the list of reserve asset addresses currently registered in the
+ * Sodax money market.
  */
-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
-  };
+export function useReservesList({
+  queryOptions,
+}: UseReservesListParams = {}): UseQueryResult<readonly Address[], Error> {
   const { sodax } = useSodaxContext();
 
   return useQuery<readonly Address[], Error>({
+    queryKey: ['mm', 'reservesList'],
+    queryFn: async () => sodax.moneyMarket.data.getReservesList(),
     ...queryOptions,
-    queryFn: async (): Promise<readonly Address[]> => {
-      return await sodax.moneyMarket.data.getReservesList();
-    },
   });
 }

package/src/hooks/mm/useReservesUsdFormat.ts

@@ -1,47 +1,27 @@
-import type { FormatReserveUSDResponse, ReserveData } from '@sodax/sdk';
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
+import type { FormatReserveUSDResponse, ReserveDataHumanized } 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 UseReservesUsdFormatParams = {
-  queryOptions?: UseQueryOptions<
-    (ReserveData & { priceInMarketReferenceCurrency: string } & FormatReserveUSDResponse)[],
-    Error
-  >;
-};
+export type ReserveUsdFormat = ReserveDataHumanized & FormatReserveUSDResponse;
+
+export type UseReservesUsdFormatParams = ReadHookParams<ReserveUsdFormat[]>;
 
 /**
- * Hook for fetching reserves data formatted with USD values in the Sodax money market.
- *
- * This hook returns an array of reserve objects, each extended with its price in the market reference
- * currency and formatted USD values. Data is automatically fetched and cached using React Query.
- *
- * @param params (optional) - Object including:
- *   - queryOptions: Custom React Query options such as `queryKey`, cache behavior, or refetching policy.
- *
- * @returns {UseQueryResult<(ReserveData & { priceInMarketReferenceCurrency: string } & FormatReserveUSDResponse)[], Error>} React Query result object containing:
- *   - data: Array of reserves with USD-formatted values, or undefined if loading
- *   - isLoading: Boolean loading state
- *   - isError: Boolean error state
- *   - error: Error object, if present
- *
- * @example
- * const { data: reservesUSD, isLoading, error } = useReservesUsdFormat();
+ * React hook returning reserves with USD-formatted values for the Sodax money market.
+ * Chains `getReservesHumanized` → `buildReserveDataWithPrice` → `formatReservesUSD`.
  */
-export function useReservesUsdFormat(
-  params?: UseReservesUsdFormatParams,
-): UseQueryResult<(ReserveData & { priceInMarketReferenceCurrency: string } & FormatReserveUSDResponse)[], Error> {
+export function useReservesUsdFormat({
+  queryOptions,
+}: UseReservesUsdFormatParams = {}): UseQueryResult<ReserveUsdFormat[], Error> {
   const { sodax } = useSodaxContext();
-  const defaultQueryOptions = { queryKey: ['mm', 'reservesUsdFormat'] };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions, // override default query options if provided
-  };
 
-  return useQuery({
-    ...queryOptions,
+  return useQuery<ReserveUsdFormat[], Error>({
+    queryKey: ['mm', 'reservesUsdFormat'],
     queryFn: async () => {
       const reserves = await sodax.moneyMarket.data.getReservesHumanized();
       return sodax.moneyMarket.data.formatReservesUSD(sodax.moneyMarket.data.buildReserveDataWithPrice(reserves));
     },
+    ...queryOptions,
   });
 }

package/src/hooks/mm/useSupply.ts

@@ -1,65 +1,59 @@
-import type { MoneyMarketError, MoneyMarketSupplyParams, RelayErrorCode, SpokeProvider } from '@sodax/sdk';
-import { useMutation, type UseMutationResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
+// packages/dapp-kit/src/hooks/mm/useSupply.ts
+import type { MoneyMarketSupplyActionParams, 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 SupplyResponse {
-  ok: true;
-  value: [string, string];
-}
-
-export type UseSupplyParams = {
-  params: MoneyMarketSupplyParams;
-  spokeProvider: SpokeProvider;
-};
+/**
+ * Mutation variables for {@link useSupply}. 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 UseSupplyVars<K extends SpokeChainKey = SpokeChainKey> = Omit<
+  MoneyMarketSupplyActionParams<K, false>,
+  'raw'
+>;
 
 /**
  * React hook for supplying tokens to the Sodax money market protocol.
  *
- * Provides a mutation for performing the supply operation using React Query. Useful
- * for UI components needing to manage the full state (pending, error, etc.) of a supply
- * transaction. It handles transaction creation, cross-chain logic, and errors.
- *
- * @returns {UseMutationResult<SupplyResponse, MoneyMarketError<'CREATE_SUPPLY_INTENT_FAILED' | 'SUPPLY_UNKNOWN_ERROR' | RelayErrorCode>, UseSupplyParams>}
- *   Mutation result object from React Query, where:
- *   - mutateAsync(params: UseSupplyParams): Promise<SupplyResponse>
- *     Initiates a supply transaction using the given MoneyMarketSupplyParams and SpokeProvider.
- *   - isPending: boolean indicating if a transaction is in progress.
- *   - error: MoneyMarketError if an error occurred while supplying, otherwise undefined.
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped `TxHashPair` on success.
  *
  * @example
- * ```typescript
- * const { mutateAsync: supply, isPending, error } = useSupply();
- * await supply({ params: supplyParams, spokeProvider });
+ * ```tsx
+ * const walletProvider = useWalletProvider({ xChainId: chainKey });
+ * const { mutateAsync: supply, isError, error } = useSupply();
+ * if (!walletProvider) return;
+ * try {
+ *   const { spokeTxHash, hubTxHash } = await supply({ params: supplyParams, walletProvider });
+ * } catch (e) {
+ *   // surfaced via mutation.error / onError
+ * }
  * ```
- *
- * @throws {Error|MoneyMarketError<...>} When:
- *   - `spokeProvider` is not provided or invalid.
- *   - The underlying supply transaction fails.
  */
-export function useSupply(): UseMutationResult<
-  SupplyResponse,
-  MoneyMarketError<'CREATE_SUPPLY_INTENT_FAILED' | 'SUPPLY_UNKNOWN_ERROR' | RelayErrorCode>,
-  UseSupplyParams
-> {
+export function useSupply<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxHashPair, UseSupplyVars<K>> = {}): SafeUseMutationResult<TxHashPair, Error, UseSupplyVars<K>> {
   const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
 
-  return useMutation<
-    SupplyResponse,
-    MoneyMarketError<'CREATE_SUPPLY_INTENT_FAILED' | 'SUPPLY_UNKNOWN_ERROR' | RelayErrorCode>,
-    UseSupplyParams
-  >({
-    mutationFn: async ({ params, spokeProvider }: UseSupplyParams) => {
-      if (!spokeProvider) {
-        throw new Error('spokeProvider is not found');
-      }
-
-      const response = await sodax.moneyMarket.supply(params, spokeProvider);
-
-      if (!response.ok) {
-        throw response.error;
-      }
-
-      return response;
+  return useSafeMutation<TxHashPair, Error, UseSupplyVars<K>>({
+    mutationKey: ['mm', 'supply'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.moneyMarket.supply({ ...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/useUserFormattedSummary.ts

@@ -1,105 +1,53 @@
-import type { SpokeChainId } from '@sodax/types';
-import type { FormatUserSummaryResponse, FormatReserveUSDResponse, SpokeProvider } from '@sodax/sdk';
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
-
-type BaseQueryOptions = {
-  queryOptions?: UseQueryOptions<FormatUserSummaryResponse<FormatReserveUSDResponse>, Error>;
-};
-
-type NewParams = BaseQueryOptions & {
-  /** Spoke chain id (e.g. '0xa86a.avax') */
-  spokeChainId: SpokeChainId | undefined;
-  /** User wallet address on the spoke chain */
-  userAddress: string | undefined;
-};
-
-/** @deprecated Use `{ spokeChainId, userAddress }` instead */
-type LegacyParams = BaseQueryOptions & {
-  /** @deprecated Use `spokeChainId` instead */
-  spokeProvider: SpokeProvider | undefined;
-  /** @deprecated Use `userAddress` instead */
-  address: string | undefined;
-};
-
-export type UseUserFormattedSummaryParams = NewParams | LegacyParams;
-
-function isLegacyParams(params: UseUserFormattedSummaryParams): params is LegacyParams {
-  return 'spokeProvider' in params || 'address' in params;
-}
-
-function resolveParams(params: UseUserFormattedSummaryParams): {
-  spokeChainId: SpokeChainId | undefined;
-  userAddress: string | undefined;
-} {
-  if (isLegacyParams(params)) {
-    return {
-      spokeChainId: params.spokeProvider?.chainConfig.chain.id as SpokeChainId | undefined,
-      userAddress: params.address,
-    };
+import type { FormatReserveUSDResponse, FormatUserSummaryResponse } 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 UseUserFormattedSummaryParams = ReadHookParams<
+  FormatUserSummaryResponse<FormatReserveUSDResponse>,
+  {
+    spokeChainKey: SpokeChainKey | undefined;
+    userAddress: string | undefined;
   }
-  return { spokeChainId: params.spokeChainId, userAddress: params.userAddress };
-}
+>;
 
 /**
- * React hook to fetch a formatted summary of a user's Sodax money market portfolio.
- *
- * @param params (optional) - Object including:
- *   - spokeChainId: The spoke chain id whose data will be fetched. If not provided, data fetching is disabled.
- *   - userAddress: The user's address (string) whose summary will be fetched. If not provided, data fetching is disabled.
- *   - queryOptions: (optional) Custom React Query options such as `queryKey`, `enabled`, or cache policy.
+ * React hook returning the user's formatted money market portfolio summary (collateral, borrows,
+ * health factor, available borrow power, etc.) for the given spoke chain.
  *
- * @returns {UseQueryResult<FormatUserSummaryResponse<FormatReserveUSDResponse>, Error>}
- *   A result object from React Query including:
- *     - data: The user's formatted portfolio summary (or undefined if not loaded)
- *     - isLoading: Boolean loading state
- *     - isError: Boolean error state
- *     - error: Error if thrown in fetching
- *
- * @example
- * const { data, isLoading, error } = useUserFormattedSummary({ spokeChainId, userAddress });
+ * Internally chains `getReservesHumanized` → `formatReservesUSD` → `getUserReservesHumanized`
+ * → `formatUserSummary`.
  */
-export function useUserFormattedSummary(
-  params?: UseUserFormattedSummaryParams,
-): UseQueryResult<FormatUserSummaryResponse<FormatReserveUSDResponse>, Error> {
+export function useUserFormattedSummary({
+  params,
+  queryOptions,
+}: UseUserFormattedSummaryParams = {}): UseQueryResult<FormatUserSummaryResponse<FormatReserveUSDResponse>, Error> {
   const { sodax } = useSodaxContext();
-  const resolved = params ? resolveParams(params) : { spokeChainId: undefined, userAddress: undefined };
-  const defaultQueryOptions = {
-    queryKey: ['mm', 'userFormattedSummary', resolved.spokeChainId, resolved.userAddress],
-    enabled: !!resolved.spokeChainId && !!resolved.userAddress,
-    refetchInterval: 5000,
-  };
-
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions, // override default query options if provided
-  };
+  const spokeChainKey = params?.spokeChainKey;
+  const userAddress = params?.userAddress;
 
   return useQuery({
-    ...queryOptions,
+    queryKey: ['mm', 'userFormattedSummary', spokeChainKey, userAddress],
     queryFn: async () => {
-      if (!resolved.spokeChainId || !resolved.userAddress) {
-        throw new Error('spokeChainId or userAddress is not defined');
+      if (!spokeChainKey || !userAddress) {
+        throw new Error('spokeChainKey and userAddress are required');
       }
 
-      // fetch reserves and hub wallet address
-      const reserves = await sodax.moneyMarket.data.getReservesHumanized();
-
-      // format reserves
+      const [reserves, userReserves] = await Promise.all([
+        sodax.moneyMarket.data.getReservesHumanized(),
+        sodax.moneyMarket.data.getUserReservesHumanized(spokeChainKey, userAddress),
+      ]);
       const formattedReserves = sodax.moneyMarket.data.formatReservesUSD(
         sodax.moneyMarket.data.buildReserveDataWithPrice(reserves),
       );
 
-      // fetch user reserves
-      const userReserves = await sodax.moneyMarket.data.getUserReservesHumanized(
-        resolved.spokeChainId,
-        resolved.userAddress,
-      );
-
-      // format user summary
       return sodax.moneyMarket.data.formatUserSummary(
         sodax.moneyMarket.data.buildUserSummaryRequest(reserves, formattedReserves, userReserves),
       );
     },
+    enabled: !!spokeChainKey && !!userAddress,
+    refetchInterval: 5000,
+    ...queryOptions,
   });
 }

package/src/hooks/mm/useUserReservesData.ts

@@ -1,89 +1,39 @@
-import type { SpokeChainId } from '@sodax/types';
-import type { SpokeProvider, UserReserveData } from '@sodax/sdk';
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
-
-type BaseQueryOptions = {
-  queryOptions?: UseQueryOptions<readonly [readonly UserReserveData[], number], Error>;
-};
-
-type NewParams = BaseQueryOptions & {
-  /** Spoke chain id (e.g. '0xa86a.avax') */
-  spokeChainId: SpokeChainId | undefined;
-  /** User wallet address on the spoke chain */
-  userAddress: string | undefined;
-};
-
-/** @deprecated Use `{ spokeChainId, userAddress }` instead */
-type LegacyParams = BaseQueryOptions & {
-  /** @deprecated Use `spokeChainId` instead */
-  spokeProvider: SpokeProvider | undefined;
-  /** @deprecated Use `userAddress` instead */
-  address: string | undefined;
-};
-
-export type UseUserReservesDataParams = NewParams | LegacyParams;
-
-function isLegacyParams(params: UseUserReservesDataParams): params is LegacyParams {
-  return 'spokeProvider' in params || 'address' in params;
-}
-
-function resolveParams(params: UseUserReservesDataParams): {
-  spokeChainId: SpokeChainId | undefined;
-  userAddress: string | undefined;
-} {
-  if (isLegacyParams(params)) {
-    return {
-      spokeChainId: params.spokeProvider?.chainConfig.chain.id as SpokeChainId | undefined,
-      userAddress: params.address,
-    };
+import type { UserReserveData } 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 UseUserReservesDataParams = ReadHookParams<
+  readonly [readonly UserReserveData[], number],
+  {
+    spokeChainKey: SpokeChainKey | undefined;
+    userAddress: string | undefined;
   }
-  return { spokeChainId: params.spokeChainId, userAddress: params.userAddress };
-}
+>;
 
 /**
- * Hook for fetching user reserves data from the Sodax money market.
- *
- * @param params (optional) - Object including:
- *   - spokeChainId: The spoke chain id whose reserves data will be fetched. If not provided, data fetching is disabled.
- *   - userAddress: The user's address (string) whose reserves data will be fetched. If not provided, data fetching is disabled.
- *   - queryOptions: (optional) Custom React Query options such as `queryKey`, `enabled`, or cache policy.
- *
- * @returns {UseQueryResult<readonly [readonly UserReserveData[], number], Error>} React Query result object containing:
- *   - data: A tuple with array of UserReserveData and associated number, or undefined if loading
- *   - isLoading: Boolean loading state
- *   - isError: Boolean error state
- *   - error: Error object, if present
- *
- * @example
- * const { data: userReservesData, isLoading, error } = useUserReservesData({
- *   spokeChainId,
- *   userAddress,
- * });
+ * React hook for fetching the raw user reserves data (positions on the hub) for a given spoke
+ * chain and user address.
  */
-export function useUserReservesData(
-  params?: UseUserReservesDataParams,
-): UseQueryResult<readonly [readonly UserReserveData[], number], Error> {
+export function useUserReservesData({
+  params,
+  queryOptions,
+}: UseUserReservesDataParams = {}): UseQueryResult<readonly [readonly UserReserveData[], number], Error> {
   const { sodax } = useSodaxContext();
-  const resolved = params ? resolveParams(params) : { spokeChainId: undefined, userAddress: undefined };
-  const defaultQueryOptions = {
-    queryKey: ['mm', 'userReservesData', resolved.spokeChainId, resolved.userAddress],
-    enabled: !!resolved.spokeChainId && !!resolved.userAddress,
-    refetchInterval: 5000,
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions, // override default query options if provided
-  };
+  const spokeChainKey = params?.spokeChainKey;
+  const userAddress = params?.userAddress;
 
   return useQuery({
-    ...queryOptions,
+    queryKey: ['mm', 'userReservesData', spokeChainKey, userAddress],
     queryFn: async () => {
-      if (!resolved.spokeChainId || !resolved.userAddress) {
-        throw new Error('spokeChainId or userAddress is not defined');
+      if (!spokeChainKey || !userAddress) {
+        throw new Error('spokeChainKey and userAddress are required');
       }
-
-      return await sodax.moneyMarket.data.getUserReservesData(resolved.spokeChainId, resolved.userAddress);
+      return sodax.moneyMarket.data.getUserReservesData(spokeChainKey, userAddress);
     },
+    enabled: !!spokeChainKey && !!userAddress,
+    refetchInterval: 5000,
+    ...queryOptions,
   });
 }

package/src/hooks/mm/useWithdraw.ts

@@ -1,65 +1,49 @@
-import type { MoneyMarketError, MoneyMarketWithdrawParams, RelayErrorCode, SpokeProvider } from '@sodax/sdk';
-import { useMutation, type UseMutationResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
+// packages/dapp-kit/src/hooks/mm/useWithdraw.ts
+import type { MoneyMarketWithdrawActionParams, 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';
 
-export type UseWithdrawParams = {
-  params: MoneyMarketWithdrawParams;
-  spokeProvider: SpokeProvider;
-};
-
-interface WithdrawResponse {
-  ok: true;
-  value: [string, string];
-}
+/**
+ * Mutation variables for {@link useWithdraw}. 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 UseWithdrawVars<K extends SpokeChainKey = SpokeChainKey> = Omit<
+  MoneyMarketWithdrawActionParams<K, false>,
+  'raw'
+>;
 
 /**
- * Hook for performing withdrawals from the Sodax money market.
- *
- * This hook exposes a mutation that executes the complete withdrawal logic, including transaction
- * creation and handling cross-chain communication. It leverages React Query's mutation API for
- * easy asynchronous handling and status tracking within UI components.
- *
- * @returns {UseMutationResult<WithdrawResponse, MoneyMarketError<'CREATE_WITHDRAW_INTENT_FAILED' | 'WITHDRAW_UNKNOWN_ERROR' | RelayErrorCode>, UseWithdrawParams>}
- *   Mutation result object, with:
- *   - mutateAsync: (params: UseWithdrawParams) => Promise<WithdrawResponse>
- *       Initiates the withdrawal using the provided params.
- *   - isPending: boolean indicating if a transaction is in progress.
- *   - error: MoneyMarketError if an error occurred while withdrawing, otherwise undefined.
+ * React hook for withdrawing supplied tokens from the Sodax money market protocol.
  *
- * @example
- * ```typescript
- * const { mutateAsync: withdraw, isPending, error } = useWithdraw();
- * await withdraw({ params: withdrawParams, spokeProvider });
- * ```
- *
- * @throws {Error} When:
- *   - spokeProvider is not provided or invalid.
- *   - Underlying withdrawal logic 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 useWithdraw(): UseMutationResult<
-  WithdrawResponse,
-  MoneyMarketError<'CREATE_WITHDRAW_INTENT_FAILED' | 'WITHDRAW_UNKNOWN_ERROR' | RelayErrorCode>,
-  UseWithdrawParams
-> {
+export function useWithdraw<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxHashPair, UseWithdrawVars<K>> = {}): SafeUseMutationResult<TxHashPair, Error, UseWithdrawVars<K>> {
   const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
 
-  return useMutation<
-    WithdrawResponse,
-    MoneyMarketError<'CREATE_WITHDRAW_INTENT_FAILED' | 'WITHDRAW_UNKNOWN_ERROR' | RelayErrorCode>,
-    UseWithdrawParams
-  >({
-    mutationFn: async ({ params, spokeProvider }) => {
-      if (!spokeProvider) {
-        throw new Error('spokeProvider is not found');
+  return useSafeMutation<TxHashPair, Error, UseWithdrawVars<K>>({
+    mutationKey: ['mm', 'withdraw'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.moneyMarket.withdraw({ ...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.withdraw(params, spokeProvider);
-
-      if (!response.ok) {
-        throw response.error;
-      }
-
-      return response;
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     },
   });
 }

package/src/hooks/partner/index.ts

@@ -0,0 +1,6 @@
+export * from './useFetchAssetsBalances.js';
+export * from './useGetAutoSwapPreferences.js';
+export * from './useIsTokenApproved.js';
+export * from './useApproveToken.js';
+export * from './useSetSwapPreference.js';
+export * from './useFeeClaimSwap.js';