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

package/src/hooks/backend/useBackendMoneyMarketAsset.ts

@@ -1,70 +1,37 @@
-// packages/dapp-kit/src/hooks/backend/useMoneyMarketAsset.ts
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import type { MoneyMarketAsset } from '@sodax/sdk';
-import { useSodaxContext } from '../shared/useSodaxContext';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from './unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
 
-export type UseBackendMoneyMarketAssetParams = {
-  params: {
+export type UseBackendMoneyMarketAssetParams = ReadHookParams<
+  MoneyMarketAsset | undefined,
+  {
     reserveAddress: string | undefined;
-  };
-  queryOptions?: UseQueryOptions<MoneyMarketAsset | undefined, Error>;
-};
+  }
+>;
 
 /**
  * React hook to fetch a specific money market asset from the backend API.
  *
- * @param params - The hook input parameter object (may be undefined):
- *   - `params`: An object containing:
- *       - `reserveAddress` (string | undefined): Reserve contract address to fetch asset details. Disables query if undefined or empty.
- *   - `queryOptions` (optional): React Query options for advanced configuration (e.g. caching, staleTime, retry, etc.).
- *
- * @returns A React Query result object: {@link UseQueryResult} for {@link MoneyMarketAsset} or `undefined` on error or if disabled,
- *   including:
- *   - `data`: The money market asset (when available) or `undefined`.
- *   - `isLoading`: Whether the query is running.
- *   - `error`: An error encountered by the query (if any).
- *   - `refetch`: Function to manually refetch the asset.
- *
  * @example
- * const { data: asset, isLoading, error } = useBackendMoneyMarketAsset({
- *   params: { reserveAddress: '0xabc...' },
- * });
- * if (isLoading) return <div>Loading asset...</div>;
- * if (error) return <div>Error: {error.message}</div>;
- * if (asset) {
- *   console.log('Asset symbol:', asset.symbol);
- *   console.log('Liquidity rate:', asset.liquidityRate);
- *   console.log('Variable borrow rate:', asset.variableBorrowRate);
- * }
- *
- * @remarks
- * - Query is disabled if `params`, `params.params`, or `params.params.reserveAddress` is missing or empty.
- * - Uses React Query for caching and background-state management.
- * - Loading and error handling are managed automatically.
+ * const { data: asset } = useBackendMoneyMarketAsset({ params: { reserveAddress: '0xabc...' } });
  */
-export const useBackendMoneyMarketAsset = (
-  params: UseBackendMoneyMarketAssetParams | undefined,
-): UseQueryResult<MoneyMarketAsset | undefined, Error> => {
+export const useBackendMoneyMarketAsset = ({
+  params,
+  queryOptions,
+}: UseBackendMoneyMarketAssetParams = {}): UseQueryResult<MoneyMarketAsset | undefined, Error> => {
   const { sodax } = useSodaxContext();
-
-  const defaultQueryOptions = {
-    queryKey: ['api', 'mm', 'asset', params?.params?.reserveAddress],
-    enabled: !!params?.params?.reserveAddress && params?.params?.reserveAddress.length > 0,
-    retry: 3,
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions,
-  };
+  const reserveAddress = params?.reserveAddress;
 
   return useQuery({
-    ...queryOptions,
+    queryKey: ['backend', 'mm', 'asset', reserveAddress],
     queryFn: async (): Promise<MoneyMarketAsset | undefined> => {
-      if (!params?.params?.reserveAddress) {
-        return undefined;
-      }
-
-      return sodax.backendApi.getMoneyMarketAsset(params.params.reserveAddress);
+      if (!reserveAddress) return undefined;
+      return unwrapResult(await sodax.backendApi.getMoneyMarketAsset(reserveAddress));
     },
+    enabled: !!reserveAddress && reserveAddress.length > 0,
+    retry: 3,
+    ...queryOptions,
   });
 };

package/src/hooks/backend/useBackendMoneyMarketAssetBorrowers.ts

@@ -1,76 +1,49 @@
-// packages/dapp-kit/src/hooks/backend/useMoneyMarketAssetBorrowers.ts
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import type { MoneyMarketAssetBorrowers } from '@sodax/sdk';
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type { BackendPaginationParams } from './types';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from './unwrapResult.js';
+import type { BackendPaginationParams } from './types.js';
+import type { ReadHookParams } from '../shared/types.js';
 
-export type UseBackendMoneyMarketAssetBorrowersParams = {
-  params: {
+export type UseBackendMoneyMarketAssetBorrowersParams = ReadHookParams<
+  MoneyMarketAssetBorrowers | undefined,
+  {
     reserveAddress: string | undefined;
-  };
-  pagination: BackendPaginationParams;
-  queryOptions?: UseQueryOptions<MoneyMarketAssetBorrowers | undefined, Error>;
-};
+    pagination: BackendPaginationParams;
+  }
+>;
 
 /**
  * React hook for fetching borrowers for a specific money market asset from the backend API with pagination.
  *
- * @param {UseBackendMoneyMarketAssetBorrowersParams | undefined} params - Query parameters:
- *   - `params`: Object containing:
- *       - `reserveAddress`: Reserve contract address for which to fetch borrowers, or `undefined` to disable query.
- *   - `pagination`: Pagination controls with `offset` and `limit` (both required as strings).
- *   - `queryOptions` (optional): React Query options to override defaults (e.g. `staleTime`, `enabled`, etc.).
- *
- * @returns {UseQueryResult<MoneyMarketAssetBorrowers | undefined, Error>} React Query result object including:
- *   - `data`: The money market asset borrowers data, or `undefined` if not available.
- *   - `isLoading`: Boolean indicating whether the query is loading.
- *   - `error`: An Error instance if the request failed.
- *   - `refetch`: Function to manually trigger a data refresh.
- *
  * @example
- * const { data: borrowers, isLoading, error } = useBackendMoneyMarketAssetBorrowers({
- *   params: { reserveAddress: '0xabc...' },
- *   pagination: { offset: '0', limit: '20' }
+ * const { data: borrowers } = useBackendMoneyMarketAssetBorrowers({
+ *   params: { reserveAddress: '0xabc...', pagination: { offset: '0', limit: '20' } },
  * });
- *
- * if (isLoading) return <div>Loading borrowers...</div>;
- * if (error) return <div>Error: {error.message}</div>;
- * if (borrowers) {
- *   console.log('Total borrowers:', borrowers.total);
- *   console.log('Borrowers:', borrowers.borrowers);
- * }
- *
- * @remarks
- * - The query is disabled if `reserveAddress`, `offset`, or `limit` are not provided.
- * - Uses React Query for caching, retries, and auto error/loading management.
- * - Pagination is handled via `pagination.offset` and `pagination.limit`.
  */
-export const useBackendMoneyMarketAssetBorrowers = (
-  params: UseBackendMoneyMarketAssetBorrowersParams | undefined,
-): UseQueryResult<MoneyMarketAssetBorrowers | undefined, Error> => {
+export const useBackendMoneyMarketAssetBorrowers = ({
+  params,
+  queryOptions,
+}: UseBackendMoneyMarketAssetBorrowersParams = {}): UseQueryResult<MoneyMarketAssetBorrowers | undefined, Error> => {
   const { sodax } = useSodaxContext();
-
-  const defaultQueryOptions = {
-    queryKey: ['api', 'mm', 'asset', 'borrowers', params],
-    enabled: !!params?.params?.reserveAddress && !!params.pagination.offset && !!params.pagination.limit,
-    retry: 3,
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions,
-  };
+  const reserveAddress = params?.reserveAddress;
+  const pagination = params?.pagination;
 
   return useQuery({
-    ...queryOptions,
+    queryKey: ['backend', 'mm', 'asset', 'borrowers', reserveAddress, pagination],
     queryFn: async (): Promise<MoneyMarketAssetBorrowers | undefined> => {
-      if (!params?.params?.reserveAddress || !params.pagination.offset || !params.pagination.limit) {
+      if (!reserveAddress || !pagination?.offset || !pagination?.limit) {
         return undefined;
       }
-
-      return sodax.backendApi.getMoneyMarketAssetBorrowers(params.params.reserveAddress, {
-        offset: params.pagination.offset,
-        limit: params.pagination.limit,
-      });
+      return unwrapResult(
+        await sodax.backendApi.getMoneyMarketAssetBorrowers(reserveAddress, {
+          offset: pagination.offset,
+          limit: pagination.limit,
+        }),
+      );
     },
+    enabled: !!reserveAddress && !!pagination?.offset && !!pagination?.limit,
+    retry: 3,
+    ...queryOptions,
   });
 };

package/src/hooks/backend/useBackendMoneyMarketAssetSuppliers.ts

@@ -1,76 +1,49 @@
-// packages/dapp-kit/src/hooks/backend/useMoneyMarketAssetSuppliers.ts
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import type { MoneyMarketAssetSuppliers } from '@sodax/sdk';
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type { BackendPaginationParams } from './types';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from './unwrapResult.js';
+import type { BackendPaginationParams } from './types.js';
+import type { ReadHookParams } from '../shared/types.js';
 
-export type UseBackendMoneyMarketAssetSuppliersParams = {
-  params: {
+export type UseBackendMoneyMarketAssetSuppliersParams = ReadHookParams<
+  MoneyMarketAssetSuppliers | undefined,
+  {
     reserveAddress: string | undefined;
-  };
-  pagination: BackendPaginationParams;
-  queryOptions?: UseQueryOptions<MoneyMarketAssetSuppliers | undefined, Error>;
-};
+    pagination: BackendPaginationParams;
+  }
+>;
 
 /**
- * React hook for fetching suppliers for a specific money market asset from the backend API, with pagination support.
- *
- * @param {UseBackendMoneyMarketAssetSuppliersParams | undefined} params - Hook parameters:
- *   - `params`: Object containing:
- *       - `reserveAddress`: The reserve contract address to query, or undefined to disable the query.
- *   - `pagination`: Backend pagination controls (`offset` and `limit` as strings).
- *   - `queryOptions` (optional): React Query options to override defaults.
- *
- * @returns {UseQueryResult<MoneyMarketAssetSuppliers | undefined, Error>} - Query result object with:
- *   - `data`: The asset suppliers data when available.
- *   - `isLoading`: Indicates if the request is in progress.
- *   - `error`: Error object if the request failed.
- *   - `refetch`: Function to trigger a manual data refresh.
+ * React hook for fetching suppliers for a specific money market asset from the backend API.
  *
  * @example
- * const { data: suppliers, isLoading, error } = useBackendMoneyMarketAssetSuppliers({
- *   params: { reserveAddress: '0xabc...' },
- *   pagination: { offset: '0', limit: '20' }
+ * const { data: suppliers } = useBackendMoneyMarketAssetSuppliers({
+ *   params: { reserveAddress: '0xabc...', pagination: { offset: '0', limit: '20' } },
  * });
- *
- * if (isLoading) return <div>Loading suppliers...</div>;
- * if (error) return <div>Error: {error.message}</div>;
- * if (suppliers) {
- *   console.log('Total suppliers:', suppliers.total);
- *   console.log('Suppliers:', suppliers.suppliers);
- * }
- *
- * @remarks
- * - The query is disabled if `reserveAddress`, `offset`, or `limit` are not provided.
- * - Uses React Query for efficient caching, automatic retries, and error/loading handling.
- * - Pagination is handled via `pagination.offset` and `pagination.limit`.
  */
-export const useBackendMoneyMarketAssetSuppliers = (
-  params: UseBackendMoneyMarketAssetSuppliersParams | undefined,
-): UseQueryResult<MoneyMarketAssetSuppliers | undefined, Error> => {
+export const useBackendMoneyMarketAssetSuppliers = ({
+  params,
+  queryOptions,
+}: UseBackendMoneyMarketAssetSuppliersParams = {}): UseQueryResult<MoneyMarketAssetSuppliers | undefined, Error> => {
   const { sodax } = useSodaxContext();
-
-  const defaultQueryOptions = {
-    queryKey: ['api', 'mm', 'asset', 'suppliers', params],
-    enabled: !!params?.params?.reserveAddress && !!params.pagination.offset && !!params.pagination.limit,
-    retry: 3,
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions,
-  };
+  const reserveAddress = params?.reserveAddress;
+  const pagination = params?.pagination;
 
   return useQuery({
-    ...queryOptions,
+    queryKey: ['backend', 'mm', 'asset', 'suppliers', reserveAddress, pagination],
     queryFn: async (): Promise<MoneyMarketAssetSuppliers | undefined> => {
-      if (!params?.params?.reserveAddress || !params.pagination.offset || !params.pagination.limit) {
+      if (!reserveAddress || !pagination?.offset || !pagination?.limit) {
         return undefined;
       }
-
-      return sodax.backendApi.getMoneyMarketAssetSuppliers(params.params.reserveAddress, {
-        offset: params.pagination.offset,
-        limit: params.pagination.limit,
-      });
+      return unwrapResult(
+        await sodax.backendApi.getMoneyMarketAssetSuppliers(reserveAddress, {
+          offset: pagination.offset,
+          limit: pagination.limit,
+        }),
+      );
     },
+    enabled: !!reserveAddress && !!pagination?.offset && !!pagination?.limit,
+    retry: 3,
+    ...queryOptions,
   });
 };

package/src/hooks/backend/useBackendMoneyMarketPosition.ts

@@ -1,53 +1,37 @@
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import type { MoneyMarketPosition } from '@sodax/sdk';
-import { useSodaxContext } from '../shared/useSodaxContext';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from './unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
 
-export type UseBackendMoneyMarketPositionParams = {
-  userAddress: string | undefined;
-  queryOptions?: UseQueryOptions<MoneyMarketPosition | undefined, Error>;
-};
+export type UseBackendMoneyMarketPositionParams = ReadHookParams<
+  MoneyMarketPosition | undefined,
+  {
+    userAddress: string | undefined;
+  }
+>;
 
 /**
  * React hook for fetching a user's money market position from the backend API.
  *
- * @param {UseBackendMoneyMarketPositionParams | undefined} params - Parameters object:
- *   - userAddress: The user's wallet address to fetch positions for. If undefined or empty, the query is disabled.
- *   - queryOptions: (Optional) React Query options to customize behavior (e.g., staleTime, enabled).
- *
- * @returns {UseQueryResult<MoneyMarketPosition | undefined, Error>} - React Query result object with:
- *   - data: The user's money market position data, or undefined if not available.
- *   - isLoading: Loading state.
- *   - error: An Error instance if fetching failed.
- *   - refetch: Function to manually trigger a refetch.
- *
  * @example
- * const { data, isLoading, error } = useBackendMoneyMarketPosition({
- *   userAddress: '0xabc...',
- *   queryOptions: { staleTime: 60000 },
- * });
+ * const { data } = useBackendMoneyMarketPosition({ params: { userAddress: '0xabc...' } });
  */
-export const useBackendMoneyMarketPosition = (
-  params: UseBackendMoneyMarketPositionParams | undefined,
-): UseQueryResult<MoneyMarketPosition | undefined, Error> => {
+export const useBackendMoneyMarketPosition = ({
+  params,
+  queryOptions,
+}: UseBackendMoneyMarketPositionParams = {}): UseQueryResult<MoneyMarketPosition | undefined, Error> => {
   const { sodax } = useSodaxContext();
-
-  const defaultQueryOptions = {
-    queryKey: ['api', 'mm', 'position', params?.userAddress],
-    enabled: !!params?.userAddress && params?.userAddress.length > 0,
-    retry: 3,
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions,
-  };
+  const userAddress = params?.userAddress;
 
   return useQuery({
-    ...queryOptions,
+    queryKey: ['backend', 'mm', 'position', userAddress],
     queryFn: async (): Promise<MoneyMarketPosition | undefined> => {
-      if (!params?.userAddress) {
-        return undefined;
-      }
-      return sodax.backendApi.getMoneyMarketPosition(params.userAddress);
+      if (!userAddress) return undefined;
+      return unwrapResult(await sodax.backendApi.getMoneyMarketPosition(userAddress));
     },
+    enabled: !!userAddress && userAddress.length > 0,
+    retry: 3,
+    ...queryOptions,
   });
 };

package/src/hooks/backend/useBackendOrderbook.ts

@@ -1,63 +1,41 @@
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import type { OrderbookResponse } from '@sodax/sdk';
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type { BackendPaginationParams } from './types';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from './unwrapResult.js';
+import type { BackendPaginationParams } from './types.js';
+import type { ReadHookParams } from '../shared/types.js';
 
-export type UseBackendOrderbookParams = {
-  queryOptions?: UseQueryOptions<OrderbookResponse | undefined, Error>;
-  pagination?: BackendPaginationParams;
-};
+export type UseBackendOrderbookParams = ReadHookParams<
+  OrderbookResponse,
+  {
+    pagination: BackendPaginationParams;
+  }
+>;
 
 /**
  * Hook for fetching the solver orderbook from the backend API.
  *
- * @param {UseBackendOrderbookParams | undefined} params - Optional parameters:
- *   - `pagination`: Pagination configuration (see `BackendPaginationParams`), including
- *      `offset` and `limit` (both required for fetch to be enabled).
- *   - `queryOptions`: Optional React Query options to override default behavior.
- *
- * @returns {UseQueryResult<OrderbookResponse | undefined, Error>} React Query result object:
- *   - `data`: The orderbook response, or undefined if unavailable.
- *   - `isLoading`: Loading state.
- *   - `error`: Error instance if the query failed.
- *   - `refetch`: Function to re-trigger the query.
- *
  * @example
- * const { data, isLoading, error } = useBackendOrderbook({
- *   pagination: { offset: '0', limit: '10' },
- *   queryOptions: { staleTime: 60000 },
- * });
- *
- * @remarks
- * - Query is disabled if `params?.pagination`, `offset`, or `limit` are missing/empty.
- * - Caches and manages server state using React Query.
- * - Default `staleTime` is 30 seconds to support near-real-time updates.
+ * const { data } = useBackendOrderbook({ params: { pagination: { offset: '0', limit: '10' } } });
  */
-export const useBackendOrderbook = (
-  params: UseBackendOrderbookParams | undefined,
-): UseQueryResult<OrderbookResponse | undefined> => {
+export const useBackendOrderbook = ({
+  params,
+  queryOptions,
+}: UseBackendOrderbookParams = {}): UseQueryResult<OrderbookResponse> => {
   const { sodax } = useSodaxContext();
+  const pagination = params?.pagination;
 
-  const defaultQueryOptions = {
-    queryKey: ['api', 'solver', 'orderbook', params?.pagination?.offset, params?.pagination?.limit],
-    enabled: !!params?.pagination && !!params?.pagination.offset && !!params?.pagination.limit,
-    staleTime: 30 * 1000, // 30 seconds for real-time data
-    retry: 3,
-  };
-
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions, // override default query options if provided
-  };
-
-  return useQuery({
-    ...queryOptions,
-    queryFn: async (): Promise<OrderbookResponse | undefined> => {
-      if (!params?.pagination || !params?.pagination.offset || !params?.pagination.limit) {
-        return undefined;
+  return useQuery<OrderbookResponse, Error>({
+    queryKey: ['backend', 'orderbook', pagination?.offset, pagination?.limit],
+    queryFn: async (): Promise<OrderbookResponse> => {
+      if (!pagination?.offset || !pagination?.limit) {
+        throw new Error('Pagination offset and limit are required');
       }
-
-      return sodax.backendApi.getOrderbook(params.pagination);
+      return unwrapResult(await sodax.backendApi.getOrderbook(pagination));
     },
+    enabled: !!pagination?.offset && !!pagination?.limit,
+    staleTime: 30 * 1000,
+    retry: 3,
+    ...queryOptions,
   });
 };

package/src/hooks/backend/useBackendSubmitSwapTx.ts

@@ -1,55 +1,49 @@
-import { useMutation, type UseMutationOptions, type UseMutationResult } from '@tanstack/react-query';
-import type { SubmitSwapTxRequest, SubmitSwapTxResponse } from '@sodax/types';
-import type { RequestOverrideConfig } from '@sodax/sdk';
-import { useSodaxContext } from '../shared/useSodaxContext';
+// packages/dapp-kit/src/hooks/backend/useBackendSubmitSwapTx.ts
+import type { RequestOverrideConfig, SubmitSwapTxRequest, SubmitSwapTxResponse } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from './unwrapResult.js';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
 
-export type UseBackendSubmitSwapTxParams = {
+/**
+ * Mutation variables for {@link useBackendSubmitSwapTx}. The per-request `apiConfig` override
+ * (e.g. base URL) belongs here rather than at the hook level — different submissions in the same
+ * component can target different endpoints without re-rendering.
+ */
+export type UseBackendSubmitSwapTxVars = {
+  request: SubmitSwapTxRequest;
   apiConfig?: RequestOverrideConfig;
-  mutationOptions?: UseMutationOptions<SubmitSwapTxResponse, Error, SubmitSwapTxRequest>;
 };
 
 /**
- * React hook for submitting a swap transaction to be processed by the backend
- * (relay, post execution to solver, etc.).
- *
- * @param {UseBackendSubmitSwapTxParams | undefined} params - Optional parameters:
- *   - `mutationOptions`: React Query mutation options to customize behavior (e.g., onSuccess, onError, retry).
+ * React hook for submitting a swap transaction to be processed by the backend (relay, post
+ * execution to solver, etc.).
  *
- * @returns {UseMutationResult<SubmitSwapTxResponse, Error, SubmitSwapTxRequest>} React Query mutation result:
- *   - `mutate` / `mutateAsync`: Functions to trigger the submission.
- *   - `data`: The submit response on success.
- *   - `isPending`: Loading state.
- *   - `error`: Error instance if the mutation failed.
+ * Pure mutation: pass `{ request, apiConfig? }` to `mutate({...})`. Default `retry: 3` is applied
+ * at the hook level — consumers can override via `mutationOptions.retry`.
  *
  * @example
  * const { mutateAsync: submitSwapTx, isPending, error } = useBackendSubmitSwapTx();
  *
  * const result = await submitSwapTx({
- *   txHash: '0x123...',
- *   srcChainId: '1',
- *   walletAddress: '0xabc...',
- *   intent: { ... },
- *   relayData: '0x...',
+ *   request: { txHash: '0x123...', srcChainKey: 'sonic', walletAddress: '0xabc...', intent: { ... }, relayData: '0x...' },
+ *   apiConfig: { baseURL: 'https://...' },
  * });
  */
-export const useBackendSubmitSwapTx = (
-  params?: UseBackendSubmitSwapTxParams,
-): UseMutationResult<SubmitSwapTxResponse, Error, SubmitSwapTxRequest> => {
+export const useBackendSubmitSwapTx = ({
+  mutationOptions,
+}: MutationHookParams<SubmitSwapTxResponse, UseBackendSubmitSwapTxVars> = {}): SafeUseMutationResult<
+  SubmitSwapTxResponse,
+  Error,
+  UseBackendSubmitSwapTxVars
+> => {
   const { sodax } = useSodaxContext();
 
-  const defaultMutationOptions = {
+  return useSafeMutation<SubmitSwapTxResponse, Error, UseBackendSubmitSwapTxVars>({
+    mutationKey: ['backend', 'submitSwapTx'],
     retry: 3,
-  };
-
-  const mutationOptions = {
-    ...defaultMutationOptions,
-    ...params?.mutationOptions,
-  };
-
-  return useMutation({
     ...mutationOptions,
-    mutationFn: async (request: SubmitSwapTxRequest): Promise<SubmitSwapTxResponse> => {
-      return sodax.backendApi.submitSwapTx(request, params?.apiConfig);
-    },
+    mutationFn: async ({ request, apiConfig }): Promise<SubmitSwapTxResponse> =>
+      unwrapResult(await sodax.backendApi.submitSwapTx(request, apiConfig)),
   });
 };