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

package/src/hooks/staking/useCancelUnstake.ts

@@ -1,52 +1,41 @@
 // packages/dapp-kit/src/hooks/staking/useCancelUnstake.ts
-import { useMutation, useQueryClient, type UseMutationResult } from '@tanstack/react-query';
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type { CancelUnstakeParams, SpokeProvider, SpokeTxHash, HubTxHash } from '@sodax/sdk';
+import type { CancelUnstakeAction, 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 UseCancelUnstakeVars<K extends SpokeChainKey = SpokeChainKey> = Omit<CancelUnstakeAction<K, false>, 'raw'>;
 
 /**
- * Hook for executing cancel unstake transactions to cancel pending unstake requests.
- * Uses React Query's useMutation for better state management and caching.
- *
- * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the cancel unstake
- * @returns {UseMutationResult<[SpokeTxHash, HubTxHash], Error, Omit<CancelUnstakeParams, 'action'>>} Mutation result object containing mutation function and state
- *
- * @example
- * ```typescript
- * const { mutateAsync: cancelUnstake, isPending } = useCancelUnstake(spokeProvider);
- *
- * const handleCancelUnstake = async () => {
- *   const result = await cancelUnstake({
- *     requestId: 1n
- *   });
+ * React hook for cancelling a pending unstake request.
  *
- *   console.log('Cancel unstake successful:', result);
- * };
- * ```
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped `TxHashPair` on success.
  */
-export function useCancelUnstake(
-  spokeProvider: SpokeProvider | undefined,
-): UseMutationResult<[SpokeTxHash, HubTxHash], Error, Omit<CancelUnstakeParams, 'action'>> {
+export function useCancelUnstake<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxHashPair, UseCancelUnstakeVars<K>> = {}): SafeUseMutationResult<
+  TxHashPair,
+  Error,
+  UseCancelUnstakeVars<K>
+> {
   const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
 
-  return useMutation({
-    mutationFn: async (params: Omit<CancelUnstakeParams, 'action'>) => {
-      if (!spokeProvider) {
-        throw new Error('Spoke provider not available');
-      }
-
-      const result = await sodax.staking.cancelUnstake({ ...params, action: 'cancelUnstake' }, spokeProvider);
-      if (!result.ok) {
-        throw new Error(`Cancel unstake failed: ${result.error.code}`);
-      }
-
-      return result.value;
-    },
-    onSuccess: () => {
-      // Invalidate relevant queries to refresh data
-      queryClient.invalidateQueries({ queryKey: ['stakingInfo'] });
-      queryClient.invalidateQueries({ queryKey: ['unstakingInfo'] });
-      queryClient.invalidateQueries({ queryKey: ['unstakingInfoWithPenalty'] });
+  return useSafeMutation<TxHashPair, Error, UseCancelUnstakeVars<K>>({
+    mutationKey: ['staking', 'cancelUnstake'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.staking.cancelUnstake({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ['staking', 'unstakingInfo', params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({
+        queryKey: ['staking', 'unstakingInfoWithPenalty', params.srcChainKey, params.srcAddress],
+      });
+      queryClient.invalidateQueries({ queryKey: ['staking', 'info', params.srcChainKey, params.srcAddress] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     },
   });
 }

package/src/hooks/staking/useClaim.ts

@@ -1,46 +1,37 @@
 // packages/dapp-kit/src/hooks/staking/useClaim.ts
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type { ClaimParams, SpokeTxHash, HubTxHash, SpokeProvider } from '@sodax/sdk';
-import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+import type { ClaimAction, 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 UseClaimVars<K extends SpokeChainKey = SpokeChainKey> = Omit<ClaimAction<K, false>, 'raw'>;
 
 /**
- * Hook for executing claim transactions to claim unstaked SODA tokens after the unstaking period.
- * Uses React Query's useMutation for better state management and caching.
- *
- * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the claim
- * @returns {UseMutationResult<[SpokeTxHash, HubTxHash], Error, Omit<ClaimParams, 'action'>>} Mutation result object containing mutation function and state
- *
- * @example
- * ```typescript
- * const { mutateAsync: claim, isPending } = useClaim(spokeProvider);
- *
- * const handleClaim = async () => {
- *   const result = await claim({
- *     requestId: 1n
- *   });
+ * React hook for claiming an unstaked SODA request that has reached the end of its waiting period.
  *
- *   console.log('Claim successful:', result);
- * };
- * ```
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped `TxHashPair` on success.
  */
-export function useClaim(
-  spokeProvider: SpokeProvider | undefined,
-): UseMutationResult<[SpokeTxHash, HubTxHash], Error, Omit<ClaimParams, 'action'>> {
+export function useClaim<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxHashPair, UseClaimVars<K>> = {}): SafeUseMutationResult<TxHashPair, Error, UseClaimVars<K>> {
   const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
 
-  return useMutation<[SpokeTxHash, HubTxHash], Error, Omit<ClaimParams, 'action'>>({
-    mutationFn: async (params: Omit<ClaimParams, 'action'>) => {
-      if (!spokeProvider) {
-        throw new Error('Spoke provider not found');
-      }
-
-      const result = await sodax.staking.claim({ ...params, action: 'claim' }, spokeProvider);
-
-      if (!result.ok) {
-        throw new Error(`Claim failed: ${result.error.code}`);
-      }
-
-      return result.value;
+  return useSafeMutation<TxHashPair, Error, UseClaimVars<K>>({
+    mutationKey: ['staking', 'claim'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.staking.claim({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ['staking', 'unstakingInfo', params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({
+        queryKey: ['staking', 'unstakingInfoWithPenalty', params.srcChainKey, params.srcAddress],
+      });
+      queryClient.invalidateQueries({ queryKey: ['shared', 'xBalances', params.srcChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     },
   });
 }

package/src/hooks/staking/useConvertedAssets.ts

@@ -1,47 +1,37 @@
-// packages/dapp-kit/src/hooks/staking/useConvertedAssets.ts
-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 UseConvertedAssetsParams = ReadHookParams<
+  bigint,
+  {
+    amount: bigint | undefined;
+  }
+>;
 
 /**
- * Hook for fetching converted assets amount for xSODA shares.
- * Uses React Query for efficient caching and state management.
- *
- * @param {bigint | undefined} amount - The amount of xSODA shares to convert
- * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 10000)
- * @returns {UseQueryResult<bigint, Error>} Query result object containing converted assets amount and state
- *
- * @example
- * ```typescript
- * const { data: convertedAssets, isLoading, error } = useConvertedAssets(1000000000000000000n); // 1 xSODA
- *
- * if (isLoading) return <div>Loading converted assets...</div>;
- * if (convertedAssets) {
- *   console.log('Converted assets:', convertedAssets);
- * }
- * ```
+ * React hook to convert an xSODA share amount to its underlying SODA value via the vault's
+ * exchange rate. Hub-only read. Throws on `!ok`.
  */
-export function useConvertedAssets(amount: bigint | undefined, refetchInterval = 10000): UseQueryResult<bigint, Error> {
+export function useConvertedAssets({
+  params,
+  queryOptions,
+}: UseConvertedAssetsParams = {}): UseQueryResult<bigint, Error> {
   const { sodax } = useSodaxContext();
+  const amount = params?.amount;
 
-  // console.log('useConvertedAssets hook called with:', { amount: amount?.toString(), sodax: !!sodax });
-
-  return useQuery({
-    queryKey: ['soda', 'convertedAssets', amount?.toString()],
+  return useQuery<bigint, Error>({
+    queryKey: ['staking', 'convertedAssets', amount?.toString()],
     queryFn: async () => {
-      // console.log('useConvertedAssets queryFn called with amount:', amount?.toString());
-      if (!amount || amount <= 0n) {
-        throw new Error('Amount must be greater than 0');
+      if (amount === undefined) {
+        throw new Error('amount is required');
       }
-
       const result = await sodax.staking.getConvertedAssets(amount);
-
-      if (!result.ok) {
-        throw new Error(`Failed to fetch converted assets: ${result.error.code}`);
-      }
-
+      if (!result.ok) throw result.error;
       return result.value;
     },
-    enabled: !!amount && amount > 0n && !!sodax?.staking,
-    refetchInterval,
+    enabled: amount !== undefined,
+    refetchInterval: 10_000,
+    ...queryOptions,
   });
 }

package/src/hooks/staking/useInstantUnstake.ts

@@ -1,50 +1,43 @@
 // packages/dapp-kit/src/hooks/staking/useInstantUnstake.ts
-import { useSodaxContext } from '../shared/useSodaxContext';
-import { useMutation, type UseMutationResult } from '@tanstack/react-query';
-import type { SpokeProvider, InstantUnstakeParams } from '@sodax/sdk';
+import type { InstantUnstakeAction, 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 UseInstantUnstakeVars<K extends SpokeChainKey = SpokeChainKey> = Omit<
+  InstantUnstakeAction<K, false>,
+  'raw'
+>;
 
 /**
- * Hook for executing instant unstake operations.
- * Uses React Query for efficient state management and error handling.
- *
- * @param {SpokeProvider | undefined} spokeProvider - The spoke provider for the transaction
- * @returns {UseMutationResult<[string, string], Error, Omit<InstantUnstakeParams, 'action'>>} Mutation result object containing instant unstake state and methods
+ * React hook for instant-unstaking SODA (bypassing the waiting period at a slippage cost).
  *
- * @example
- * ```typescript
- * const { mutateAsync: instantUnstake, isPending } = useInstantUnstake(spokeProvider);
- *
- * const handleInstantUnstake = async () => {
- *   const result = await instantUnstake({
- *     amount: 1000000000000000000n,
- *     minAmount: 950000000000000000n,
- *     account: '0x...'
- *   });
- *   console.log('Instant unstake successful:', result);
- * };
- * ```
+ * Throws on SDK failure so React Query's native error model engages (`isError`, `error`,
+ * `onError`, `retry`). Returns the unwrapped `TxHashPair` on success.
  */
-export function useInstantUnstake(
-  spokeProvider: SpokeProvider | undefined,
-): UseMutationResult<[string, string], Error, Omit<InstantUnstakeParams, 'action'>> {
+export function useInstantUnstake<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxHashPair, UseInstantUnstakeVars<K>> = {}): SafeUseMutationResult<
+  TxHashPair,
+  Error,
+  UseInstantUnstakeVars<K>
+> {
   const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
 
-  return useMutation({
-    mutationFn: async (params: Omit<InstantUnstakeParams, 'action'>) => {
-      if (!spokeProvider) {
-        throw new Error('spokeProvider is not found');
-      }
-
-      const result = await sodax.staking.instantUnstake({ ...params, action: 'instantUnstake' }, spokeProvider);
-
-      if (!result.ok) {
-        throw new Error(`Instant unstake failed: ${result.error.code}`);
-      }
-
-      return result.value;
-    },
-    onError: error => {
-      console.error('Instant unstake error:', error);
+  return useSafeMutation<TxHashPair, Error, UseInstantUnstakeVars<K>>({
+    mutationKey: ['staking', 'instantUnstake'],
+    ...mutationOptions,
+    mutationFn: async vars => unwrapResult(await sodax.staking.instantUnstake({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      const { params } = vars;
+      queryClient.invalidateQueries({ queryKey: ['staking', 'info', params.srcChainKey, params.srcAddress] });
+      queryClient.invalidateQueries({ queryKey: ['staking', 'instantUnstakeRatio'] });
+      queryClient.invalidateQueries({ queryKey: ['staking', 'allowance', params.srcChainKey, 'instantUnstake'] });
+      queryClient.invalidateQueries({ queryKey: ['shared', 'xBalances', params.srcChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     },
   });
 }

package/src/hooks/staking/useInstantUnstakeAllowance.ts

@@ -1,59 +1,51 @@
-// packages/dapp-kit/src/hooks/staking/useStakeAllowance.ts
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type { SpokeProvider, InstantUnstakeParams } from '@sodax/sdk';
+import type { InstantUnstakeParams } 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 UseInstantUnstakeAllowanceParams<K extends SpokeChainKey = SpokeChainKey> = ReadHookParams<
+  boolean,
+  {
+    payload: Omit<InstantUnstakeParams<K>, 'action'> | undefined;
+  }
+>;
 
 /**
- * Hook for checking xSODA token allowance for instant unstaking operations.
- * Uses React Query for efficient caching and state management.
- *
- * @param {Omit<InstantUnstakeParams, 'action'> | undefined} params - The instant unstaking parameters. If undefined, the query will be disabled.
- * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the allowance check
- * @returns {UseQueryResult<boolean, Error>} Query result object containing allowance data and state
- *
- * @example
- * ```typescript
- * const { data: hasAllowed, isLoading } = useInstantUnstakeAllowance(
- *   {
- *     amount: 1000000000000000000n, // 1 xSODA
- *     minAmount: 950000000000000000n, // 0.95 SODA
- *     account: '0x...'
- *   },
- *   spokeProvider
- * );
- *
- * if (isLoading) return <div>Checking allowance...</div>;
- * if (hasAllowed) {
- *   console.log('Sufficient allowance for instant unstaking');
- * }
- * ```
+ * React hook to check whether the user has approved sufficient xSODA spending for the
+ * instant-unstake action. Read-only — calls `staking.isAllowanceValid` with `raw: true` so no
+ * `walletProvider` is required.
  */
-export function useInstantUnstakeAllowance(
-  params: Omit<InstantUnstakeParams, 'action'> | undefined,
-  spokeProvider: SpokeProvider | undefined,
-): UseQueryResult<boolean, Error> {
+export function useInstantUnstakeAllowance<K extends SpokeChainKey = SpokeChainKey>({
+  params,
+  queryOptions,
+}: UseInstantUnstakeAllowanceParams<K> = {}): UseQueryResult<boolean, Error> {
   const { sodax } = useSodaxContext();
+  const payload = params?.payload;
 
-  return useQuery({
-    queryKey: ['soda', 'instantUnstakeAllowance', params, spokeProvider?.chainConfig.chain.id],
+  return useQuery<boolean, Error>({
+    queryKey: [
+      'staking',
+      'allowance',
+      payload?.srcChainKey,
+      'instantUnstake',
+      payload?.srcAddress,
+      payload?.amount?.toString(),
+    ],
     queryFn: async () => {
-      if (!params || !spokeProvider) {
-        return false;
+      if (!payload) {
+        throw new Error('Params are required');
       }
-
       const result = await sodax.staking.isAllowanceValid({
-        params: { ...params, action: 'instantUnstake' },
-        spokeProvider,
+        params: { ...payload, action: 'instantUnstake' },
+        raw: true,
       });
-
-      if (!result.ok) {
-        console.error(`Unstake allowance check failed: ${result.error.code}, error: ${result.error.error}`);
-        throw new Error(`Unstake allowance check failed: ${result.error.code}`);
-      }
-
+      if (!result.ok) throw result.error;
       return result.value;
     },
-    enabled: !!params && !!spokeProvider,
-    refetchInterval: 5000, // Refetch every 5 seconds
+    enabled: !!payload,
+    refetchInterval: 5_000,
+    gcTime: 0,
+    ...queryOptions,
   });
 }

package/src/hooks/staking/useInstantUnstakeApprove.ts

@@ -1,52 +1,52 @@
-// packages/dapp-kit/src/hooks/staking/useStakeApprove.ts
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type { InstantUnstakeParams, TxReturnType, SpokeProvider } from '@sodax/sdk';
-import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+// packages/dapp-kit/src/hooks/staking/useInstantUnstakeApprove.ts
+import type { GetWalletProviderType, InstantUnstakeParams, 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';
 
 /**
- * Hook for approving xSODA token spending for instant unstaking operations.
- * Uses React Query's useMutation for better state management and caching.
- *
- * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the approval
- * @returns {UseMutationResult<TxReturnType<SpokeProvider, false>, Error, Omit<InstantUnstakeParams, 'action'>>} Mutation result object containing mutation function and state
- *
- * @example
- * ```typescript
- * const { mutateAsync: approve, isPending } = useInstantUnstakeApprove(spokeProvider);
- *
- * const handleApprove = async () => {
- *   const result = await approve({
- *     amount: 1000000000000000000n, // 1 xSODA
- *     minAmount: 950000000000000000n, // 0.95 SODA
- *     account: '0x...'
- *   });
+ * Mutation variables for {@link useInstantUnstakeApprove}. The `action` literal is injected by
+ * the hook.
+ */
+export type UseInstantUnstakeApproveVars<K extends SpokeChainKey = SpokeChainKey> = {
+  params: Omit<InstantUnstakeParams<K>, 'action'>;
+  walletProvider: GetWalletProviderType<K>;
+};
+
+/**
+ * React hook for approving xSODA spending on the instant-unstake action.
  *
- *   console.log('Approval successful:', result);
- * };
- * ```
+ * 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 useInstantUnstakeApprove(
-  spokeProvider: SpokeProvider | undefined,
-): UseMutationResult<TxReturnType<SpokeProvider, false>, Error, Omit<InstantUnstakeParams, 'action'>> {
+export function useInstantUnstakeApprove<K extends SpokeChainKey = SpokeChainKey>({
+  mutationOptions,
+}: MutationHookParams<TxReturnType<K, false>, UseInstantUnstakeApproveVars<K>> = {}): SafeUseMutationResult<
+  TxReturnType<K, false>,
+  Error,
+  UseInstantUnstakeApproveVars<K>
+> {
   const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
 
-  return useMutation<TxReturnType<SpokeProvider, false>, Error, Omit<InstantUnstakeParams, 'action'>>({
-    mutationFn: async (params: Omit<InstantUnstakeParams, 'action'>) => {
-      console.log('useInstantUnstakeApprove called with params:', params);
-      if (!spokeProvider) {
-        throw new Error('Spoke provider not found');
-      }
-
-      const result = await sodax.staking.approve({
-        params: { ...params, action: 'instantUnstake' },
-        spokeProvider,
+  return useSafeMutation<TxReturnType<K, false>, Error, UseInstantUnstakeApproveVars<K>>({
+    mutationKey: ['staking', 'approve', 'instantUnstake'],
+    ...mutationOptions,
+    mutationFn: async ({ params, walletProvider }) =>
+      unwrapResult(
+        await sodax.staking.approve({
+          params: { ...params, action: 'instantUnstake' },
+          raw: false,
+          walletProvider,
+        }),
+      ),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({
+        queryKey: ['staking', 'allowance', vars.params.srcChainKey, 'instantUnstake'],
       });
-
-      if (!result.ok) {
-        throw new Error(`Instant unstake approval failed: ${result.error.code}`);
-      }
-
-      return result.value;
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
     },
   });
 }

package/src/hooks/staking/useInstantUnstakeRatio.ts

@@ -1,54 +1,37 @@
-// packages/dapp-kit/src/hooks/staking/useInstantUnstakeRatio.ts
-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 UseInstantUnstakeRatioParams = ReadHookParams<
+  bigint,
+  {
+    amount: bigint | undefined;
+  }
+>;
 
 /**
- * Hook for fetching instant unstake ratio estimates.
- * Uses React Query for efficient caching and state management.
- *
- * @param {bigint | undefined} amount - The amount of xSoda to estimate instant unstake for
- * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 10000)
- * @returns {UseQueryResult<bigint, Error>} Query result object containing instant unstake ratio and state
- *
- * @example
- * ```typescript
- * const { data: instantUnstakeRatio, isLoading, error } = useInstantUnstakeRatio(1000000000000000000n); // 1 xSoda
- *
- * if (isLoading) return <div>Loading instant unstake ratio...</div>;
- * if (instantUnstakeRatio) {
- *   console.log('Instant unstake ratio:', instantUnstakeRatio);
- * }
- * ```
+ * React hook to estimate the SODA amount received from instant-unstaking a given xSODA amount
+ * (after slippage). Hub-only read. Throws on `!ok`.
  */
-export function useInstantUnstakeRatio(
-  amount: bigint | undefined,
-  refetchInterval = 10000,
-): UseQueryResult<bigint, Error> {
+export function useInstantUnstakeRatio({
+  params,
+  queryOptions,
+}: UseInstantUnstakeRatioParams = {}): UseQueryResult<bigint, Error> {
   const { sodax } = useSodaxContext();
+  const amount = params?.amount;
 
-  console.log('useInstantUnstakeRatio hook called with:', { amount: amount?.toString(), sodax: !!sodax });
-
-  return useQuery({
-    queryKey: ['soda', 'instantUnstakeRatio', amount?.toString()],
+  return useQuery<bigint, Error>({
+    queryKey: ['staking', 'instantUnstakeRatio', amount?.toString()],
     queryFn: async () => {
-      console.log('useInstantUnstakeRatio queryFn called with amount:', amount?.toString());
-      if (!amount || amount <= 0n) {
-        throw new Error('Amount must be greater than 0');
-      }
-
-      if (!sodax?.staking) {
-        throw new Error('Staking service not available');
+      if (amount === undefined) {
+        throw new Error('amount is required');
       }
-
       const result = await sodax.staking.getInstantUnstakeRatio(amount);
-
-      if (!result.ok) {
-        throw new Error(`Failed to fetch instant unstake ratio: ${result.error.code}`);
-      }
-
+      if (!result.ok) throw result.error;
       return result.value;
     },
-    enabled: !!amount && amount > 0n && !!sodax?.staking,
-    refetchInterval,
+    enabled: amount !== undefined,
+    refetchInterval: 10_000,
+    ...queryOptions,
   });
 }