@sodax/dapp-kit 0.0.1-rc.8 → 1.0.0-beta

package/src/hooks/staking/useInstantUnstakeApprove.ts

@@ -0,0 +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';
+
+/**
+ * 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...'
+ *   });
+ *
+ *   console.log('Approval successful:', result);
+ * };
+ * ```
+ */
+export function useInstantUnstakeApprove(
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<TxReturnType<SpokeProvider, false>, Error, Omit<InstantUnstakeParams, 'action'>> {
+  const { sodax } = useSodaxContext();
+
+  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,
+      });
+
+      if (!result.ok) {
+        throw new Error(`Instant unstake approval failed: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+  });
+}

package/src/hooks/staking/useInstantUnstakeRatio.ts

@@ -0,0 +1,54 @@
+// packages/dapp-kit/src/hooks/staking/useInstantUnstakeRatio.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * 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);
+ * }
+ * ```
+ */
+export function useInstantUnstakeRatio(
+  amount: bigint | undefined,
+  refetchInterval = 10000,
+): UseQueryResult<bigint, Error> {
+  const { sodax } = useSodaxContext();
+
+  console.log('useInstantUnstakeRatio hook called with:', { amount: amount?.toString(), sodax: !!sodax });
+
+  return useQuery({
+    queryKey: ['soda', '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');
+      }
+
+      const result = await sodax.staking.getInstantUnstakeRatio(amount);
+
+      if (!result.ok) {
+        throw new Error(`Failed to fetch instant unstake ratio: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    enabled: !!amount && amount > 0n && !!sodax?.staking,
+    refetchInterval,
+  });
+}

package/src/hooks/staking/useStake.ts

@@ -0,0 +1,47 @@
+// packages/dapp-kit/src/hooks/staking/useStake.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { StakeParams, SpokeTxHash, HubTxHash, SpokeProvider } from '@sodax/sdk';
+import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+
+/**
+ * Hook for executing stake transactions to stake SODA tokens and receive xSODA shares.
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the stake
+ * @returns {UseMutationResult<[SpokeTxHash, HubTxHash], Error, StakeParams>} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: stake, isPending } = useStake(spokeProvider);
+ *
+ * const handleStake = async () => {
+ *   const result = await stake({
+ *     amount: 1000000000000000000n, // 1 SODA
+ *     account: '0x...'
+ *   });
+ *
+ *   console.log('Stake successful:', result);
+ * };
+ * ```
+ */
+export function useStake(
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<[SpokeTxHash, HubTxHash], Error, StakeParams> {
+  const { sodax } = useSodaxContext();
+
+  return useMutation<[SpokeTxHash, HubTxHash], Error, StakeParams>({
+    mutationFn: async (params: StakeParams) => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      const result = await sodax.staking.stake(params, spokeProvider);
+
+      if (!result.ok) {
+        throw new Error(`Stake failed: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+  });
+}

package/src/hooks/staking/useStakeAllowance.ts

@@ -0,0 +1,57 @@
+// packages/dapp-kit/src/hooks/staking/useStakeAllowance.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { StakeParams, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for checking SODA token allowance for staking operations.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {Omit<StakeParams, 'action'> | undefined} params - The staking 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 } = useStakeAllowance(
+ *   {
+ *     amount: 1000000000000000000n, // 1 SODA
+ *     account: '0x...'
+ *   },
+ *   spokeProvider
+ * );
+ *
+ * if (isLoading) return <div>Checking allowance...</div>;
+ * if (hasAllowed) {
+ *   console.log('Sufficient allowance for staking');
+ * }
+ * ```
+ */
+export function useStakeAllowance(
+  params: Omit<StakeParams, 'action'> | undefined,
+  spokeProvider: SpokeProvider | undefined,
+): UseQueryResult<boolean, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'stakeAllowance', params, spokeProvider?.chainConfig.chain.id],
+    queryFn: async () => {
+      if (!params || !spokeProvider) {
+        return false;
+      }
+
+      const result = await sodax.staking.isAllowanceValid({
+        params: { ...params, action: 'stake' },
+        spokeProvider,
+      });
+
+      if (!result.ok) {
+        throw new Error(`Allowance check failed: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    enabled: !!params && !!spokeProvider,
+    refetchInterval: 5000, // Refetch every 5 seconds
+  });
+}

package/src/hooks/staking/useStakeApprove.ts

@@ -0,0 +1,50 @@
+// packages/dapp-kit/src/hooks/staking/useStakeApprove.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { StakeParams, TxReturnType, SpokeProvider } from '@sodax/sdk';
+import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+
+/**
+ * Hook for approving SODA token spending for staking 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<StakeParams, 'action'>>} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: approve, isPending } = useStakeApprove(spokeProvider);
+ *
+ * const handleApprove = async () => {
+ *   const result = await approve({
+ *     amount: 1000000000000000000n, // 1 SODA
+ *     account: '0x...'
+ *   });
+ *
+ *   console.log('Approval successful:', result);
+ * };
+ * ```
+ */
+export function useStakeApprove(
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<TxReturnType<SpokeProvider, false>, Error, Omit<StakeParams, 'action'>> {
+  const { sodax } = useSodaxContext();
+
+  return useMutation<TxReturnType<SpokeProvider, false>, Error, Omit<StakeParams, 'action'>>({
+    mutationFn: async (params: Omit<StakeParams, 'action'>) => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      const result = await sodax.staking.approve({
+        params: { ...params, action: 'stake' },
+        spokeProvider,
+      });
+
+      if (!result.ok) {
+        throw new Error(`Stake approval failed: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+  });
+}

package/src/hooks/staking/useStakeRatio.ts

@@ -0,0 +1,53 @@
+// packages/dapp-kit/src/hooks/staking/useStakeRatio.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for fetching stake ratio estimates (xSoda amount and preview deposit).
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {bigint | undefined} amount - The amount of SODA to estimate stake for
+ * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 10000)
+ * @returns {UseQueryResult<[bigint, bigint], Error>} Query result object containing stake ratio estimates and state
+ *
+ * @example
+ * ```typescript
+ * const { data: stakeRatio, isLoading, error } = useStakeRatio(1000000000000000000n); // 1 SODA
+ *
+ * if (isLoading) return <div>Loading stake ratio...</div>;
+ * if (stakeRatio) {
+ *   const [xSodaAmount, previewDepositAmount] = stakeRatio;
+ *   console.log('xSoda amount:', xSodaAmount);
+ *   console.log('Preview deposit:', previewDepositAmount);
+ * }
+ * ```
+ */
+export function useStakeRatio(
+  amount: bigint | undefined,
+  refetchInterval = 10000,
+): UseQueryResult<[bigint, bigint], Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'stakeRatio', amount?.toString()],
+    queryFn: async () => {
+      if (!amount || amount <= 0n) {
+        throw new Error('Amount must be greater than 0');
+      }
+
+      if (!sodax?.staking) {
+        throw new Error('Staking service not available');
+      }
+
+      const result = await sodax.staking.getStakeRatio(amount);
+
+      if (!result.ok) {
+        throw new Error(`Failed to fetch stake ratio: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    enabled: !!amount && amount > 0n && !!sodax?.staking,
+    refetchInterval,
+  });
+}

package/src/hooks/staking/useStakingConfig.ts

@@ -0,0 +1,40 @@
+// packages/dapp-kit/src/hooks/staking/useStakingConfig.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { StakingConfig } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for fetching staking configuration from the stakedSoda contract.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 30000)
+ * @returns {UseQueryResult<StakingConfig, Error>} Query result object containing staking config and state
+ *
+ * @example
+ * ```typescript
+ * const { data: stakingConfig, isLoading, error } = useStakingConfig();
+ *
+ * if (isLoading) return <div>Loading staking config...</div>;
+ * if (stakingConfig) {
+ *   console.log('Unstaking period (days):', stakingConfig.unstakingPeriod / 86400n);
+ *   console.log('Max penalty (%):', stakingConfig.maxPenalty);
+ * }
+ * ```
+ */
+export function useStakingConfig(refetchInterval = 30000): UseQueryResult<StakingConfig, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'stakingConfig'],
+    queryFn: async () => {
+      const result = await sodax.staking.getStakingConfig();
+
+      if (!result.ok) {
+        throw new Error(`Failed to fetch staking config: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    refetchInterval,
+  });
+}

package/src/hooks/staking/useStakingInfo.ts

@@ -0,0 +1,50 @@
+// packages/dapp-kit/src/hooks/staking/useStakingInfo.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { StakingInfo, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for fetching comprehensive staking information for a user.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the query
+ * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 5000)
+ * @returns {UseQueryResult<StakingInfo, Error>} Query result object containing staking info and state
+ *
+ * @example
+ * ```typescript
+ * const { data: stakingInfo, isLoading, error } = useStakingInfo(spokeProvider);
+ *
+ * if (isLoading) return <div>Loading staking info...</div>;
+ * if (stakingInfo) {
+ *   console.log('Total staked:', stakingInfo.totalStaked);
+ *   console.log('User staked:', stakingInfo.userStaked);
+ *   console.log('xSODA balance:', stakingInfo.userXSodaBalance);
+ * }
+ * ```
+ */
+export function useStakingInfo(
+  spokeProvider: SpokeProvider | undefined,
+  refetchInterval = 5000,
+): UseQueryResult<StakingInfo, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'stakingInfo', spokeProvider?.chainConfig.chain.id],
+    queryFn: async () => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      const result = await sodax.staking.getStakingInfoFromSpoke(spokeProvider);
+
+      if (!result.ok) {
+        throw new Error(`Failed to fetch staking info: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    enabled: !!spokeProvider,
+    refetchInterval,
+  });
+}

package/src/hooks/staking/useUnstake.ts

@@ -0,0 +1,54 @@
+// packages/dapp-kit/src/hooks/staking/useUnstake.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { UnstakeParams, SpokeTxHash, HubTxHash, SpokeProvider } from '@sodax/sdk';
+import { useMutation, useQueryClient, type UseMutationResult } from '@tanstack/react-query';
+
+/**
+ * Hook for executing unstake transactions to unstake xSODA shares.
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the unstake
+ * @returns {UseMutationResult<[SpokeTxHash, HubTxHash], Error, Omit<UnstakeParams, 'action'>>} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: unstake, isPending } = useUnstake(spokeProvider);
+ *
+ * const handleUnstake = async () => {
+ *   const result = await unstake({
+ *     amount: 1000000000000000000n, // 1 xSODA
+ *     account: '0x...'
+ *   });
+ *
+ *   console.log('Unstake successful:', result);
+ * };
+ * ```
+ */
+export function useUnstake(
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<[SpokeTxHash, HubTxHash], Error, Omit<UnstakeParams, 'action'>> {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  return useMutation<[SpokeTxHash, HubTxHash], Error, Omit<UnstakeParams, 'action'>>({
+    mutationFn: async (params: Omit<UnstakeParams, 'action'>) => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      const result = await sodax.staking.unstake({ ...params, action: 'unstake' }, spokeProvider);
+
+      if (!result.ok) {
+        throw new Error(`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'] });
+    },
+  });
+}

package/src/hooks/staking/useUnstakeAllowance.ts

@@ -0,0 +1,58 @@
+// packages/dapp-kit/src/hooks/staking/useStakeAllowance.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { UnstakeParams, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for checking xSODA token allowance for unstaking operations.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {Omit<UnstakeParams, 'action'> | undefined} params - The 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 } = useUnstakeAllowance(
+ *   {
+ *     amount: 1000000000000000000n, // 1 xSODA
+ *     account: '0x...'
+ *   },
+ *   spokeProvider
+ * );
+ *
+ * if (isLoading) return <div>Checking allowance...</div>;
+ * if (hasAllowed) {
+ *   console.log('Sufficient allowance for unstaking');
+ * }
+ * ```
+ */
+export function useUnstakeAllowance(
+  params: Omit<UnstakeParams, 'action'> | undefined,
+  spokeProvider: SpokeProvider | undefined,
+): UseQueryResult<boolean, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'unstakeAllowance', params, spokeProvider?.chainConfig.chain.id],
+    queryFn: async () => {
+      if (!params || !spokeProvider) {
+        return false;
+      }
+
+      const result = await sodax.staking.isAllowanceValid({
+        params: { ...params, action: 'unstake' },
+        spokeProvider,
+      });
+
+      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}`);
+      }
+
+      return result.value;
+    },
+    enabled: !!params && !!spokeProvider,
+    refetchInterval: 5000, // Refetch every 5 seconds
+  });
+}

package/src/hooks/staking/useUnstakeApprove.ts

@@ -0,0 +1,52 @@
+// packages/dapp-kit/src/hooks/staking/useStakeApprove.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { TxReturnType, UnstakeParams } from '@sodax/sdk';
+import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+import type { SpokeProvider } from '@sodax/sdk';
+
+/**
+ * Hook for approving xSODA token spending for 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<UnstakeParams, 'action'>>} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: approve, isPending } = useUnstakeApprove(spokeProvider);
+ *
+ * const handleApprove = async () => {
+ *   const result = await approve({
+ *     amount: 1000000000000000000n, // 1 xSODA
+ *     account: '0x...'
+ *   });
+ *
+ *   console.log('Approval successful:', result);
+ * };
+ * ```
+ */
+export function useUnstakeApprove(
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<TxReturnType<SpokeProvider, false>, Error, Omit<UnstakeParams, 'action'>> {
+  const { sodax } = useSodaxContext();
+
+  return useMutation<TxReturnType<SpokeProvider, false>, Error, Omit<UnstakeParams, 'action'>>({
+    mutationFn: async (params: Omit<UnstakeParams, 'action'>) => {
+      console.log('useUnstakeApprove called with params:', params);
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      const result = await sodax.staking.approve({
+        params: { ...params, action: 'unstake' },
+        spokeProvider,
+      });
+
+      if (!result.ok) {
+        throw new Error(`Unstake approval failed: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+  });
+}

package/src/hooks/staking/useUnstakingInfo.ts

@@ -0,0 +1,53 @@
+// packages/dapp-kit/src/hooks/staking/useUnstakingInfoWithPenalty.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { UnstakingInfo, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for fetching unstaking information from the stakedSoda contract.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {string | undefined} userAddress - The user address to fetch unstaking info for
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider instance
+ * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 5000)
+ * @returns {UseQueryResult<UnstakingInfo, Error>} Query result object containing unstaking info and state
+ *
+ * @example
+ * ```typescript
+ * const { data: unstakingInfo, isLoading, error } = useUnstakingInfo(userAddress, spokeProvider);
+ *
+ * if (isLoading) return <div>Loading unstaking info...</div>;
+ * if (unstakingInfo) {
+ *   console.log('Total unstaking:', unstakingInfo.totalUnstaking);
+ *   unstakingInfo.userUnstakeSodaRequests.forEach(request => {
+ *     console.log('Request amount:', request.request.amount);
+ *   });
+ * }
+ * ```
+ */
+export function useUnstakingInfo(
+  userAddress: string | undefined,
+  spokeProvider: SpokeProvider | undefined,
+  refetchInterval = 5000,
+): UseQueryResult<UnstakingInfo, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'unstakingInfoWithPenalty', spokeProvider?.chainConfig.chain.id, userAddress],
+    queryFn: async () => {
+      if (!spokeProvider || !userAddress) {
+        throw new Error('Spoke provider or user address not found');
+      }
+
+      const result = await sodax.staking.getUnstakingInfo(spokeProvider);
+
+      if (!result.ok) {
+        throw new Error(`Failed to fetch unstaking info: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    enabled: !!spokeProvider && !!userAddress,
+    refetchInterval,
+  });
+}