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

package/src/hooks/partner/useApproveToken.ts

@@ -0,0 +1,42 @@
+// packages/dapp-kit/src/hooks/partner/useApproveToken.ts
+import type { FeeTokenApproveAction, HubChainKey, 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 UseApproveTokenVars = Omit<FeeTokenApproveAction<HubChainKey, false>, 'raw'>;
+
+type ApproveTokenData = TxReturnType<HubChainKey, false>;
+
+/**
+ * React hook to approve a token to the protocol-intents contract on Sonic with max allowance.
+ *
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped tx return value on success.
+ */
+export function useApproveToken({
+  mutationOptions,
+}: MutationHookParams<ApproveTokenData, UseApproveTokenVars> = {}): SafeUseMutationResult<
+  ApproveTokenData,
+  Error,
+  UseApproveTokenVars
+> {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  return useSafeMutation<ApproveTokenData, Error, UseApproveTokenVars>({
+    mutationKey: ['partner', 'approveToken'],
+    ...mutationOptions,
+    mutationFn: async vars =>
+      unwrapResult(await sodax.partners.feeClaim.approveToken<false>({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({
+        queryKey: ['partner', 'feeClaim', 'isTokenApproved', params.srcChainKey, params.srcAddress, params.token],
+      });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    },
+  });
+}

package/src/hooks/partner/useFeeClaimSwap.ts

@@ -0,0 +1,38 @@
+// packages/dapp-kit/src/hooks/partner/useFeeClaimSwap.ts
+import type { HubChainKey, IntentAutoSwapResult, PartnerFeeClaimSwapAction } 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 UseFeeClaimSwapVars = Omit<PartnerFeeClaimSwapAction<HubChainKey, false>, 'raw'>;
+
+/**
+ * React hook to create a partner-fee auto-swap intent and wait for the solver execution.
+ *
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped `IntentAutoSwapResult` on success.
+ */
+export function useFeeClaimSwap({
+  mutationOptions,
+}: MutationHookParams<IntentAutoSwapResult, UseFeeClaimSwapVars> = {}): SafeUseMutationResult<
+  IntentAutoSwapResult,
+  Error,
+  UseFeeClaimSwapVars
+> {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  return useSafeMutation<IntentAutoSwapResult, Error, UseFeeClaimSwapVars>({
+    mutationKey: ['partner', 'feeClaimSwap'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.partners.feeClaim.swap({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({
+        queryKey: ['partner', 'feeClaim', 'assetsBalances', vars.params.srcAddress],
+      });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    },
+  });
+}

package/src/hooks/partner/useFetchAssetsBalances.ts

@@ -0,0 +1,37 @@
+import type { PartnerFeeClaimAssetBalance } 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 UseFetchAssetsBalancesParams = ReadHookParams<
+  Map<string, PartnerFeeClaimAssetBalance>,
+  {
+    queryAddress: string | undefined;
+  }
+>;
+
+/**
+ * React hook to fetch hub-asset balances on Sonic for a given EVM address. Disabled when
+ * `queryAddress` is missing. Throws on `!ok`.
+ */
+export function useFetchAssetsBalances({
+  params,
+  queryOptions,
+}: UseFetchAssetsBalancesParams = {}): UseQueryResult<Map<string, PartnerFeeClaimAssetBalance>, Error> {
+  const { sodax } = useSodaxContext();
+  const queryAddress = params?.queryAddress;
+
+  return useQuery<Map<string, PartnerFeeClaimAssetBalance>, Error>({
+    queryKey: ['partner', 'feeClaim', 'assetsBalances', queryAddress],
+    queryFn: async () => {
+      if (!queryAddress) {
+        throw new Error('queryAddress is required');
+      }
+      const result = await sodax.partners.feeClaim.fetchAssetsBalances(queryAddress);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!queryAddress,
+    ...queryOptions,
+  });
+}

package/src/hooks/partner/useGetAutoSwapPreferences.ts

@@ -0,0 +1,37 @@
+import type { AutoSwapPreferences } 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 UseGetAutoSwapPreferencesParams = ReadHookParams<
+  AutoSwapPreferences,
+  {
+    queryAddress: string | undefined;
+  }
+>;
+
+/**
+ * React hook to fetch the auto-swap preferences (output token, destination chain, destination
+ * address) for a given EVM address. Disabled when `queryAddress` is missing. Throws on `!ok`.
+ */
+export function useGetAutoSwapPreferences({
+  params,
+  queryOptions,
+}: UseGetAutoSwapPreferencesParams = {}): UseQueryResult<AutoSwapPreferences, Error> {
+  const { sodax } = useSodaxContext();
+  const queryAddress = params?.queryAddress;
+
+  return useQuery<AutoSwapPreferences, Error>({
+    queryKey: ['partner', 'feeClaim', 'autoSwapPreferences', queryAddress],
+    queryFn: async () => {
+      if (!queryAddress) {
+        throw new Error('queryAddress is required');
+      }
+      const result = await sodax.partners.feeClaim.getAutoSwapPreferences(queryAddress);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!queryAddress,
+    ...queryOptions,
+  });
+}

package/src/hooks/partner/useIsTokenApproved.ts

@@ -0,0 +1,39 @@
+import type { FeeTokenApproveParams } 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 UseIsTokenApprovedParams = ReadHookParams<
+  boolean,
+  {
+    payload: FeeTokenApproveParams | undefined;
+  }
+>;
+
+/**
+ * React hook to check whether a token is approved to the protocol-intents contract on Sonic for
+ * a given owner. Read-only; throws on `!ok`.
+ */
+export function useIsTokenApproved({
+  params,
+  queryOptions,
+}: UseIsTokenApprovedParams = {}): UseQueryResult<boolean, Error> {
+  const { sodax } = useSodaxContext();
+  const payload = params?.payload;
+
+  return useQuery<boolean, Error>({
+    queryKey: ['partner', 'feeClaim', 'isTokenApproved', payload?.srcChainKey, payload?.srcAddress, payload?.token],
+    queryFn: async () => {
+      if (!payload) {
+        throw new Error('params are required');
+      }
+      const result = await sodax.partners.feeClaim.isTokenApproved(payload);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!payload,
+    refetchInterval: 5_000,
+    gcTime: 0,
+    ...queryOptions,
+  });
+}

package/src/hooks/partner/useSetSwapPreference.ts

@@ -0,0 +1,50 @@
+// packages/dapp-kit/src/hooks/partner/useSetSwapPreference.ts
+import type { HubChainKey, SetSwapPreferenceAction, 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';
+
+/**
+ * Mutation variables for {@link useSetSwapPreference}. Generic over `K extends SpokeChainKey`
+ * for compatibility with the SDK signature; at runtime the SDK enforces hub-only
+ * (`isHubChainKeyType(srcChainKey)`).
+ */
+export type UseSetSwapPreferenceVars<K extends SpokeChainKey = SpokeChainKey> = Omit<
+  SetSwapPreferenceAction<K, false>,
+  'raw'
+>;
+
+/**
+ * React hook to set the partner's auto-swap preferences (output token + destination chain +
+ * destination address) on the protocol-intents contract.
+ *
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped tx return value on success.
+ */
+export function useSetSwapPreference<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxReturnType<K, false>, UseSetSwapPreferenceVars<K>> = {}): SafeUseMutationResult<
+  TxReturnType<K, false>,
+  Error,
+  UseSetSwapPreferenceVars<K>
+> {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  return useSafeMutation<TxReturnType<K, false>, Error, UseSetSwapPreferenceVars<K>>({
+    mutationKey: ['partner', 'setSwapPreference'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.partners.feeClaim.setSwapPreference({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({
+        queryKey: ['partner', 'feeClaim', 'autoSwapPreferences', (vars.params as { srcAddress: string }).srcAddress],
+      });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    },
+  });
+}
+
+// Helper alias for the common Sonic-only call shape.
+export type UseSetSwapPreferenceVarsHub = UseSetSwapPreferenceVars<HubChainKey>;

package/src/hooks/provider/index.ts

@@ -1,2 +1 @@
-export * from './useHubProvider';
-export * from './useSpokeProvider';
+export * from './useHubProvider.js';

package/src/hooks/provider/useHubProvider.ts

@@ -1,5 +1,5 @@
 import type { EvmHubProvider } from '@sodax/sdk';
-import { useSodaxContext } from '../shared/useSodaxContext';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
 
 export function useHubProvider(): EvmHubProvider {
   const { sodax } = useSodaxContext();

package/src/hooks/recovery/index.ts

@@ -0,0 +1,2 @@
+export * from './useHubAssetBalances.js';
+export * from './useWithdrawHubAsset.js';

package/src/hooks/recovery/useHubAssetBalances.ts

@@ -0,0 +1,43 @@
+import type { HubAssetBalance } 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 UseHubAssetBalancesParams = ReadHookParams<
+  HubAssetBalance[],
+  {
+    chainKey: SpokeChainKey | undefined;
+    /** The user's address on the spoke chain. The SDK derives the hub wallet abstraction internally. */
+    srcAddress: string | undefined;
+  }
+>;
+
+/**
+ * React hook to fetch the hub-side balances of every supported token on the given spoke chain
+ * for the user's hub wallet (derived internally from `srcAddress` + `chainKey`). Disabled when
+ * either input is missing. Throws on `!ok`.
+ */
+export function useHubAssetBalances({
+  params,
+  queryOptions,
+}: UseHubAssetBalancesParams = {}): UseQueryResult<HubAssetBalance[], Error> {
+  const { sodax } = useSodaxContext();
+  const chainKey = params?.chainKey;
+  const srcAddress = params?.srcAddress;
+
+  return useQuery<HubAssetBalance[], Error>({
+    queryKey: ['recovery', 'hubAssetBalances', chainKey, srcAddress],
+    queryFn: async () => {
+      if (!chainKey || !srcAddress) {
+        throw new Error('chainKey and srcAddress are required');
+      }
+      const result = await sodax.recovery.fetchHubAssetBalances({ chainKey, srcAddress });
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!chainKey && !!srcAddress,
+    staleTime: 10_000,
+    ...queryOptions,
+  });
+}

package/src/hooks/recovery/useWithdrawHubAsset.ts

@@ -0,0 +1,48 @@
+// packages/dapp-kit/src/hooks/recovery/useWithdrawHubAsset.ts
+import type { SpokeChainKey, TxReturnType, WithdrawHubAssetAction } 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';
+
+/**
+ * Mutation variables for {@link useWithdrawHubAsset}. 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 UseWithdrawHubAssetVars<K extends SpokeChainKey = SpokeChainKey> = Omit<
+  WithdrawHubAssetAction<K, false>,
+  'raw'
+>;
+
+/**
+ * React hook for withdrawing a hub-side asset back to the user's spoke chain wallet.
+ *
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped tx return value on success.
+ */
+export function useWithdrawHubAsset<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxReturnType<K, false>, UseWithdrawHubAssetVars<K>> = {}): SafeUseMutationResult<
+  TxReturnType<K, false>,
+  Error,
+  UseWithdrawHubAssetVars<K>
+> {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  return useSafeMutation<TxReturnType<K, false>, Error, UseWithdrawHubAssetVars<K>>({
+    mutationKey: ['recovery', 'withdrawHubAsset'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.recovery.withdrawHubAsset<K, false>({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({
+        queryKey: ['recovery', 'hubAssetBalances', params.srcChainKey, params.srcAddress],
+      });
+      queryClient.invalidateQueries({ queryKey: ['shared', 'xBalances', params.srcChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    },
+  });
+}

package/src/hooks/shared/index.ts

@@ -1,6 +1,10 @@
-export * from './useSodaxContext';
-export * from './useEstimateGas';
-export * from './useDeriveUserWalletAddress';
-export * from './useStellarTrustlineCheck';
-export * from './useRequestTrustline';
-export * from './useGetUserHubWalletAddress';
+export * from './types.js';
+export * from './unwrapResult.js';
+export * from './useSafeMutation.js';
+export * from './useSodaxContext.js';
+export * from './useEstimateGas.js';
+export * from './useDeriveUserWalletAddress.js';
+export * from './useStellarTrustlineCheck.js';
+export * from './useRequestTrustline.js';
+export * from './useGetUserHubWalletAddress.js';
+export * from './useXBalances.js';

package/src/hooks/shared/types.ts

@@ -0,0 +1,77 @@
+// packages/dapp-kit/src/hooks/shared/types.ts
+import type { UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
+
+/**
+ * Subset of `UseQueryOptions` consumers may override on dapp-kit read hooks.
+ *
+ * `queryKey`, `queryFn`, and `enabled` are owned by the hook (the latter is derived
+ * from required-input presence) and are intentionally stripped here.
+ */
+export type ReadQueryOptions<TData, TError = Error> = Omit<
+  UseQueryOptions<TData, TError>,
+  'queryKey' | 'queryFn' | 'enabled'
+>;
+
+/**
+ * Canonical params shape for read-only `useQuery`-backed hooks in dapp-kit.
+ *
+ * Two top-level keys, always:
+ * - `params`: SDK-feature-domain inputs (the "what" being fetched)
+ * - `queryOptions`: React Query behavior knobs (the "how" the query behaves)
+ *
+ * For hooks with no required inputs, leave `TParams` at its default and accept the
+ * whole params object as optional at the call site.
+ */
+export type ReadHookParams<TData, TParams = Record<string, never>, TError = Error> = {
+  params?: TParams;
+  queryOptions?: ReadQueryOptions<TData, TError>;
+};
+
+/**
+ * Subset of `UseMutationOptions` consumers may override on dapp-kit mutation hooks.
+ *
+ * `mutationFn` is owned by the hook (it's the SDK integration point) and is
+ * intentionally stripped here. Everything else — `mutationKey`, `retry`, `gcTime`,
+ * `networkMode`, `onMutate`, `onSuccess`, `onError`, `onSettled`, `meta`, etc. —
+ * is consumer-overridable.
+ *
+ * Conventions enforced by every dapp-kit mutation hook:
+ *
+ * 1. **`mutationFn` throws on SDK failure.** The SDK returns `Result<T>`; the hook
+ *    unwraps `result.value` on `ok` and throws `result.error` on `!ok`. So `TData`
+ *    here is the unwrapped success type, not `Result<T>`. React Query's native
+ *    error model — `isError`, `error`, `onError`, `retry`, `throwOnError`, devtools —
+ *    works exactly as documented.
+ *
+ * 2. **`onSuccess` is composed.** Hook-owned invalidations always run first; then
+ *    the hook awaits `mutationOptions?.onSuccess?.(data, vars, ctx)`. Per-call
+ *    `mutate(vars, { onSuccess })` runs after both, per TanStack Query's native
+ *    ordering. Because invalidations now live inside `onSuccess` (not `onSettled`),
+ *    they only fire on confirmed success — failed mutations never trigger them.
+ *
+ * 3. **A default `mutationKey` is set per hook** (e.g. `['mm', 'supply']`,
+ *    `['swap']`) so consumers can use `useIsMutating(['mm'])` and
+ *    `useMutationState` without guessing the key shape. The default is set
+ *    *before* `...mutationOptions` is spread, so consumers can override it.
+ */
+export type MutationHookOptions<TData, TVars, TError = Error, TContext = unknown> = Omit<
+  UseMutationOptions<TData, TError, TVars, TContext>,
+  'mutationFn'
+>;
+
+/**
+ * Canonical params shape for `useMutation`-backed hooks in dapp-kit.
+ *
+ * One top-level key:
+ * - `mutationOptions`: React Query behavior knobs (the "how" the mutation behaves)
+ *
+ * Domain inputs (params, walletProvider, etc.) are NOT here — they belong in
+ * `TVars` and flow through `mutate(vars)` so the call site can vary them per
+ * invocation without re-rendering the hook.
+ *
+ * Always accept the whole params object as optional at the call site:
+ * `useFoo({ mutationOptions } = {})`.
+ */
+export type MutationHookParams<TData, TVars, TError = Error, TContext = unknown> = {
+  mutationOptions?: MutationHookOptions<TData, TVars, TError, TContext>;
+};

package/src/hooks/shared/unwrapResult.ts

@@ -0,0 +1,19 @@
+import type { Result } from '@sodax/sdk';
+
+/**
+ * Translates the SDK's `Result<T>` contract into the React Query contract: returns `value` on
+ * success, throws `error` on failure. Non-`Error` throwables are wrapped so consumers always get
+ * an `Error` in `mutation.error` / catch blocks.
+ *
+ * Used by every dapp-kit mutation hook so the React Query error model (`isError`, `error`,
+ * `onError`, `retry`, `throwOnError`, devtools) engages uniformly.
+ */
+export function unwrapResult<T>(result: Result<T>): T {
+  if (!result.ok) {
+    if (result.error instanceof Error) throw result.error;
+    const e = result.error as { message?: string; detail?: { code?: string; message?: string } };
+    const msg = e?.detail?.code ?? e?.detail?.message ?? e?.message ?? 'SDK call failed';
+    throw new Error(msg, { cause: result.error });
+  }
+  return result.value;
+}

package/src/hooks/shared/useDeriveUserWalletAddress.ts

@@ -1,53 +1,35 @@
-import { deriveUserWalletAddress, type SpokeProvider, type SpokeChainId } from '@sodax/sdk';
+import type { SpokeChainKey } from '@sodax/sdk';
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
-import { useSodaxContext } from './useSodaxContext';
+import { useSodaxContext } from './useSodaxContext.js';
 import type { Address } from 'viem';
+import type { ReadHookParams } from './types.js';
 
-/**
- * Hook for deriving user wallet address for hub abstraction.
- *
- * This hook derives the user's abstracted wallet address for the hub chain based on the spoke chain ID and address.
- * If the spoke chain is the same as the hub chain, it returns the encoded spoke address.
- * Otherwise, it derives and returns the abstracted wallet address for cross-chain operations.
- *
- * The query is automatically enabled when both `spokeChainId` and `spokeAddress` are provided.
- * This is a deterministic operation, so the result is cached and not refetched automatically.
- *
- * @param spokeChainId - Optional spoke chain ID. If not provided, the query will be disabled.
- * @param spokeAddress - Optional user wallet address on the spoke chain. If not provided, the query will be disabled.
- * @returns A React Query result object containing:
- *   - data: The derived user wallet address (Address) when available
- *   - isLoading: Loading state indicator
- *   - error: Any error that occurred during derivation (Error)
- *
- * @example
- * ```typescript
- * const { data: derivedAddress, isLoading, error } = useDeriveUserWalletAddress(spokeChainId, userAddress);
- *
- * if (isLoading) return <div>Deriving address...</div>;
- * if (error) return <div>Error: {error.message}</div>;
- * if (derivedAddress) return <div>Derived Address: {derivedAddress}</div>;
- * ```
- */
-export function useDeriveUserWalletAddress(
-  spokeChainId?: SpokeChainId | SpokeProvider | undefined,
-  spokeAddress?: string | undefined,
-): UseQueryResult<Address, Error> {
+export type UseDeriveUserWalletAddressParams = ReadHookParams<
+  Address,
+  {
+    spokeChainId?: SpokeChainKey;
+    spokeAddress?: string;
+  }
+>;
+
+export function useDeriveUserWalletAddress({
+  params,
+  queryOptions,
+}: UseDeriveUserWalletAddressParams = {}): UseQueryResult<Address, Error> {
   const { sodax } = useSodaxContext();
+  const spokeChainId = params?.spokeChainId;
+  const spokeAddress = params?.spokeAddress;
 
-  return useQuery({
-    queryKey: ['deriveUserWalletAddress', spokeChainId, spokeAddress],
+  return useQuery<Address, Error>({
+    queryKey: ['shared', 'deriveUserWalletAddress', spokeChainId, spokeAddress],
     queryFn: async (): Promise<Address> => {
       if (!spokeChainId || !spokeAddress) {
         throw new Error('Spoke chain id and address are required');
       }
-
-      // Determine if spokeChainId is a SpokeProvider object or SpokeChainId value
-      spokeChainId = typeof spokeChainId === 'object' ? spokeChainId.chainConfig.chain.id : spokeChainId;
-
-      return await deriveUserWalletAddress(sodax.hubProvider, spokeChainId, spokeAddress);
+      return await sodax.hubProvider.getUserHubWalletAddress(spokeAddress, spokeChainId);
     },
     enabled: !!spokeChainId && !!spokeAddress,
-    refetchInterval: false, // This is a deterministic operation, no need to refetch
+    refetchInterval: false,
+    ...queryOptions,
   });
 }

package/src/hooks/shared/useEstimateGas.ts

@@ -1,18 +1,21 @@
-import { type GetEstimateGasReturnType, type SpokeProvider, SpokeService, type TxReturnType } from '@sodax/sdk';
-import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+// packages/dapp-kit/src/hooks/shared/useEstimateGas.ts
+import type { EstimateGasParams, GetEstimateGasReturnType, SpokeChainKey } from '@sodax/sdk';
+import { useSodaxContext } from './useSodaxContext.js';
+import type { MutationHookParams } from './types.js';
+import { useSafeMutation, type SafeUseMutationResult } from './useSafeMutation.js';
+import { unwrapResult } from './unwrapResult.js';
 
-export function useEstimateGas<T extends SpokeProvider = SpokeProvider>(
-  spokeProvider: T | undefined,
-): UseMutationResult<GetEstimateGasReturnType<T>, Error, TxReturnType<T, true>> {
-  return useMutation<GetEstimateGasReturnType<T>, Error, TxReturnType<T, true>>({
-    mutationFn: async (rawTx: TxReturnType<T, true>) => {
-      if (!spokeProvider) {
-        throw new Error('spokeProvider is not found');
-      }
-
-      const response = await SpokeService.estimateGas(rawTx, spokeProvider);
-
-      return response;
-    },
+export function useEstimateGas<C extends SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<GetEstimateGasReturnType<C>, EstimateGasParams<C>> = {}): SafeUseMutationResult<
+  GetEstimateGasReturnType<C>,
+  Error,
+  EstimateGasParams<C>
+> {
+  const { sodax } = useSodaxContext();
+  return useSafeMutation<GetEstimateGasReturnType<C>, Error, EstimateGasParams<C>>({
+    mutationKey: ['shared', 'estimateGas'],
+    ...mutationOptions,
+    mutationFn: async params => unwrapResult(await sodax.spoke.estimateGas<C>(params)),
   });
 }