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

package/src/hooks/shared/useGetUserHubWalletAddress.ts

@@ -1,7 +1,16 @@
-import { type SpokeProvider, type SpokeChainId, HubService } 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';
+
+export type UseGetUserHubWalletAddressParams = ReadHookParams<
+  Address,
+  {
+    spokeChainId?: SpokeChainKey;
+    spokeAddress?: string;
+  }
+>;
 
 /**
  * Hook for deriving user wallet address for hub abstraction.
@@ -14,41 +23,31 @@ import type { Address } from 'viem';
  * 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>;
+ * const { data: derivedAddress, isLoading, error } = useGetUserHubWalletAddress({
+ *   params: { spokeChainId, spokeAddress: userAddress },
+ * });
  * ```
  */
-export function useGetUserHubWalletAddress(
-  spokeChainId?: SpokeChainId | SpokeProvider | undefined,
-  spokeAddress?: string | undefined,
-): UseQueryResult<Address, Error> {
+export function useGetUserHubWalletAddress({
+  params,
+  queryOptions,
+}: UseGetUserHubWalletAddressParams = {}): UseQueryResult<Address, Error> {
   const { sodax } = useSodaxContext();
+  const spokeChainId = params?.spokeChainId;
+  const spokeAddress = params?.spokeAddress;
 
-  return useQuery({
-    queryKey: ['getUserHubWalletAddress', spokeChainId, spokeAddress],
+  return useQuery<Address, Error>({
+    queryKey: ['shared', 'userHubWalletAddress', 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 HubService.getUserHubWalletAddress(spokeAddress, spokeChainId, sodax.hubProvider);
+      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/useRequestTrustline.ts

@@ -1,86 +1,59 @@
-import { type SpokeProvider, StellarSpokeProvider, StellarSpokeService, type TxReturnType } from '@sodax/sdk';
 import { useQueryClient } from '@tanstack/react-query';
 import { useCallback, useState } from 'react';
+import type { IStellarWalletProvider, StellarChainKey } from '@sodax/sdk';
+import { useSodaxContext } from './useSodaxContext.js';
 
-/**
- * React hook to request a Stellar trustline for a given token and amount.
- *
- * This hook provides a callback function for requesting a trustline on the Stellar network
- * using the provided SpokeProvider. It is intended for use with StellarSpokeProvider
- * and will throw if used with a non-Stellar provider. Upon success, it invalidates
- * the trustline check query to ensure UI reflects the updated trustline state.
- *
- * @template T - The type of SpokeProvider, defaults to SpokeProvider.
- * @param {string | undefined} token - The Stellar asset code or token address for which to request a trustline.
- * @returns {Object} An object containing:
- *   - `requestTrustline`: Function to trigger the trustline request.
- *   - `isLoading`: Whether the request is in progress.
- *   - `isRequested`: Whether a trustline has been successfully requested.
- *   - `error`: Any error encountered during the request.
- *   - `data`: The transaction result if successful.
- *
- * @example
- * ```tsx
- * import { useRequestTrustline } from '@sodax/dapp-kit';
- *
- * const { requestTrustline, isLoading, isRequested, error, data } = useRequestTrustline('USDC-G...TOKEN');
- *
- * // To request a trustline:
- * await requestTrustline({
- *   token: 'USDC-G...TOKEN',
- *   amount: 10000000n,
- *   spokeProvider: stellarProvider,
- * });
- *
- * if (isLoading) return <span>Requesting trustline...</span>;
- * if (error) return <span>Error: {error.message}</span>;
- * if (isRequested) return <span>Trustline requested! Tx: {data?.txHash}</span>;
- * ```
- */
-
-export function useRequestTrustline<T extends SpokeProvider = SpokeProvider>(
-  token: string | undefined,
-): {
+export function useRequestTrustline(token: string | undefined): {
   requestTrustline: (params: {
     token: string;
     amount: bigint;
-    spokeProvider: T;
-  }) => Promise<TxReturnType<StellarSpokeProvider, false>>;
+    srcChainKey: StellarChainKey;
+    walletProvider: IStellarWalletProvider;
+  }) => Promise<string>;
   isLoading: boolean;
   isRequested: boolean;
   error: Error | null;
-  data: TxReturnType<StellarSpokeProvider, false> | null;
+  data: string | null;
 } {
+  const { sodax } = useSodaxContext();
   const queryClient = useQueryClient();
   const [isLoading, setIsLoading] = useState<boolean>(false);
   const [isRequested, setIsRequested] = useState<boolean>(false);
   const [error, setError] = useState<Error | null>(null);
-  const [data, setData] = useState<TxReturnType<StellarSpokeProvider, false> | null>(null);
+  const [data, setData] = useState<string | null>(null);
 
   const requestTrustline = useCallback(
     async ({
       token,
       amount,
-      spokeProvider,
+      srcChainKey,
+      walletProvider,
     }: {
       token: string;
       amount: bigint;
-      spokeProvider: T;
-    }): Promise<TxReturnType<StellarSpokeProvider, false>> => {
-      if (!spokeProvider || !token || !amount || !(spokeProvider instanceof StellarSpokeProvider)) {
-        const error = new Error('Spoke provider, token or amount not found');
+      srcChainKey: StellarChainKey;
+      walletProvider: IStellarWalletProvider;
+    }): Promise<string> => {
+      if (!token || !amount) {
+        const error = new Error('Token and amount are required');
         setError(error);
         throw error;
       }
-
       setIsLoading(true);
       setError(null);
-
       try {
-        const result = await StellarSpokeService.requestTrustline(token, amount, spokeProvider);
+        const srcAddress = await walletProvider.getWalletAddress();
+        const result = await sodax.spoke.stellar.requestTrustline<false>({
+          raw: false,
+          srcChainKey,
+          srcAddress,
+          token,
+          amount,
+          walletProvider,
+        });
         setData(result);
         setIsRequested(true);
-        queryClient.invalidateQueries({ queryKey: ['stellar-trustline-check', token] });
+        queryClient.invalidateQueries({ queryKey: ['shared', 'stellarTrustlineCheck', token] });
         return result;
       } catch (err) {
         const error = err instanceof Error ? err : new Error('Unknown error occurred');
@@ -90,14 +63,8 @@ export function useRequestTrustline<T extends SpokeProvider = SpokeProvider>(
         setIsLoading(false);
       }
     },
-    [queryClient],
+    [queryClient, sodax],
   );
 
-  return {
-    requestTrustline,
-    isLoading,
-    isRequested,
-    error,
-    data,
-  };
+  return { requestTrustline, isLoading, isRequested, error, data };
 }

package/src/hooks/shared/useSafeMutation.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { toResult } from './useSafeMutation.js';
+
+describe('toResult', () => {
+  it('packs a resolved promise into { ok: true, value }', async () => {
+    const r = await toResult(Promise.resolve(42));
+    expect(r).toEqual({ ok: true, value: 42 });
+  });
+
+  it('packs a rejected promise into { ok: false, error } — never rejects', async () => {
+    const err = new Error('user rejected');
+    const r = await toResult(Promise.reject(err));
+    expect(r).toEqual({ ok: false, error: err });
+  });
+
+  it('preserves non-Error throwables', async () => {
+    const r = await toResult(Promise.reject('boom'));
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.error).toBe('boom');
+  });
+
+  it('forwards the resolved value verbatim (no copy/transform)', async () => {
+    const value = { spokeTxHash: '0xaaa', hubTxHash: '0xbbb' };
+    const r = await toResult(Promise.resolve(value));
+    if (r.ok) expect(r.value).toBe(value); // same reference
+  });
+
+  it('does not catch synchronous throws above the await — caller must produce a Promise', async () => {
+    // Documents the contract: toResult only neutralizes Promise rejections, not sync throws
+    // before the Promise is constructed. Hooks always pass `mutateAsync(vars)` which is async.
+    const wrapped = (): Promise<Result<number>> =>
+      toResult(
+        (async () => {
+          throw new Error('async throw');
+        })(),
+      );
+    const r = await wrapped();
+    expect(r.ok).toBe(false);
+  });
+});
+
+// Local type alias to keep the file self-contained — mirrors @sodax/sdk's Result<T>.
+type Result<T> = { ok: true; value: T } | { ok: false; error: unknown };

package/src/hooks/shared/useSafeMutation.ts

@@ -0,0 +1,68 @@
+// packages/dapp-kit/src/hooks/shared/useSafeMutation.ts
+import type { Result } from '@sodax/sdk';
+import {
+  useMutation,
+  type MutateOptions,
+  type UseMutationOptions,
+  type UseMutationResult,
+} from '@tanstack/react-query';
+import { useCallback } from 'react';
+
+/**
+ * Return shape of every dapp-kit mutation hook. Extends `UseMutationResult` with one extra
+ * method, `mutateAsyncSafe`, that never rejects — it returns the SDK's `Result<T>` shape so
+ * callers can branch on `.ok` without `try/catch`.
+ *
+ * The underlying `mutationFn` still throws on SDK failure, so React Query's native error model
+ * (`isError`, `error`, `onError`, `retry`, `throwOnError`, devtools) keeps working as documented.
+ */
+export type SafeUseMutationResult<TData, TError, TVars, TContext = unknown> = UseMutationResult<
+  TData,
+  TError,
+  TVars,
+  TContext
+> & {
+  /**
+   * Like `mutateAsync` but never rejects. Returns `Result<TData>` so callers can branch
+   * on `.ok` without `try/catch`.
+   *
+   * Use this for imperative flows where rejection-style errors are awkward — e.g. sequential
+   * `if (!hasAllowance) await approve(...); await action(...)` chains where the user-reject
+   * case is the modal failure mode, not an exceptional one.
+   */
+  mutateAsyncSafe: (
+    vars: TVars,
+    options?: MutateOptions<TData, TError, TVars, TContext>,
+  ) => Promise<Result<TData>>;
+};
+
+/**
+ * Wraps a `Promise<T>` (typically `mutateAsync(vars)`) into a `Promise<Result<T>>` that never
+ * rejects. Pure, side-effect-free — extracted for unit testing.
+ */
+export async function toResult<T>(promise: Promise<T>): Promise<Result<T>> {
+  try {
+    const value = await promise;
+    return { ok: true, value };
+  } catch (error) {
+    return { ok: false, error };
+  }
+}
+
+/**
+ * Drop-in replacement for `useMutation` that augments the result with `mutateAsyncSafe`. Used
+ * by every dapp-kit mutation hook so consumers can pick rejection-style (`mutateAsync`) or
+ * Result-style (`mutateAsyncSafe`) ergonomics without the hook author having to think about it.
+ */
+export function useSafeMutation<TData, TError, TVars, TContext = unknown>(
+  options: UseMutationOptions<TData, TError, TVars, TContext>,
+): SafeUseMutationResult<TData, TError, TVars, TContext> {
+  const mutation = useMutation<TData, TError, TVars, TContext>(options);
+  const { mutateAsync } = mutation;
+  const mutateAsyncSafe = useCallback(
+    (vars: TVars, opts?: MutateOptions<TData, TError, TVars, TContext>): Promise<Result<TData>> =>
+      toResult(mutateAsync(vars, opts)),
+    [mutateAsync],
+  );
+  return { ...mutation, mutateAsyncSafe };
+}

package/src/hooks/shared/useSodaxContext.ts

@@ -1,4 +1,4 @@
-import { SodaxContext, type SodaxContextType } from '@/contexts';
+import { SodaxContext, type SodaxContextType } from '@/contexts/index.js';
 import { useContext } from 'react';
 
 /**

package/src/hooks/shared/useStellarTrustlineCheck.ts

@@ -1,71 +1,37 @@
-import { STELLAR_MAINNET_CHAIN_ID, StellarSpokeProvider, StellarSpokeService } from '@sodax/sdk';
-import type { SpokeChainId, SpokeProvider } from '@sodax/sdk';
+import { ChainKeys, type IStellarWalletProvider, type SpokeChainKey } from '@sodax/sdk';
 import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from './useSodaxContext.js';
+import type { ReadHookParams } from './types.js';
 
-/**
- * React hook to check if a Stellar account has a sufficient trustline for a given token and amount.
- *
- * This hook queries the Stellar network (via the provided SpokeProvider) to determine
- * whether the account has established a trustline for the specified token and if the trustline
- * is sufficient for the intended amount. It is useful for gating UI actions that require
- * a trustline to be present and funded.
- *
- * @template T - The type of SpokeProvider, defaults to SpokeProvider.
- * @param {string | undefined} token - The Stellar asset code or token address to check the trustline for.
- * @param {bigint | undefined} amount - The minimum amount required for the trustline.
- * @param {T | undefined} spokeProvider - The provider instance for interacting with the Stellar network.
- * @param {SpokeChainId | undefined} chainId - The chain ID to determine if the check should be performed (only on Stellar mainnet).
- * @returns {UseQueryResult<boolean, Error>} A React Query result object containing:
- *   - `data`: `true` if the trustline exists and is sufficient, `false` otherwise.
- *   - `error`: Any error encountered during the check.
- *   - `isLoading`: Whether the query is in progress.
- *   - Other React Query state.
- *
- * @example
- * ```tsx
- * import { useStellarTrustlineCheck } from '@sodax/dapp-kit';
- *
- * const { data: hasTrustline, isLoading, error } = useStellarTrustlineCheck(
- *   'USDC-G...TOKEN',
- *   10000000n,
- *   stellarProvider,
- *   'stellar'
- * );
- *
- * if (isLoading) return <span>Checking trustline...</span>;
- * if (error) return <span>Error: {error.message}</span>;
- * if (!hasTrustline) return <span>Trustline not established or insufficient.</span>;
- * return <span>Trustline is sufficient!</span>;
- * ```
- */
+export type UseStellarTrustlineCheckParams = ReadHookParams<
+  boolean,
+  {
+    token: string | undefined;
+    amount: bigint | undefined;
+    chainId: SpokeChainKey | undefined;
+    walletProvider: IStellarWalletProvider | undefined;
+  }
+>;
 
-export function useStellarTrustlineCheck<T extends SpokeProvider = SpokeProvider>(
-  token: string | undefined,
-  amount: bigint | undefined,
-  spokeProvider: T | undefined,
-  chainId: SpokeChainId | undefined,
-): UseQueryResult<boolean, Error> {
-  return useQuery({
-    queryKey: ['stellar-trustline-check', token],
-    queryFn: async () => {
-      if (chainId !== STELLAR_MAINNET_CHAIN_ID) {
-        return true;
-      }
-      if (!spokeProvider || !token || !amount || !(spokeProvider instanceof StellarSpokeProvider)) {
-        console.error(
-          'Spoke provider, token or amount not found. Details: spokeProvider:',
-          spokeProvider,
-          'token:',
-          token,
-          'amount:',
-          amount,
-        );
-        return false;
-      }
-      const response = await StellarSpokeService.hasSufficientTrustline(token, amount, spokeProvider);
+export function useStellarTrustlineCheck({
+  params,
+  queryOptions,
+}: UseStellarTrustlineCheckParams = {}): UseQueryResult<boolean, Error> {
+  const { sodax } = useSodaxContext();
+  const token = params?.token;
+  const amount = params?.amount;
+  const chainId = params?.chainId;
+  const walletProvider = params?.walletProvider;
 
-      return response;
+  return useQuery<boolean, Error>({
+    queryKey: ['shared', 'stellarTrustlineCheck', token],
+    queryFn: async () => {
+      if (chainId !== ChainKeys.STELLAR_MAINNET) return true;
+      if (!walletProvider || !token || !amount) return false;
+      const walletAddress = await walletProvider.getWalletAddress();
+      return sodax.spoke.stellar.hasSufficientTrustline(token, amount, walletAddress);
     },
-    enabled: !!spokeProvider && !!token && !!amount,
+    enabled: !!walletProvider && !!token && !!amount,
+    ...queryOptions,
   });
 }

package/src/hooks/shared/useXBalances.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { IXServiceBase, XToken } from '@sodax/sdk';
+import { getXBalancesQueryOptions } from './useXBalances.js';
+
+const makeToken = (symbol: string, address: string): XToken =>
+  ({
+    symbol,
+    name: symbol,
+    decimals: 18,
+    address,
+    chainKey: 'sonic',
+    hubAsset: '0x0000000000000000000000000000000000000000',
+    vault: '0x0000000000000000000000000000000000000000',
+  }) as XToken;
+
+const makeXService = (balances: Record<string, bigint>): IXServiceBase => ({
+  xChainType: 'EVM',
+  getBalance: vi.fn(),
+  getBalances: vi.fn().mockResolvedValue(balances),
+});
+
+describe('getXBalancesQueryOptions', () => {
+  const tokenA = makeToken('AAA', '0xaaa');
+  const tokenB = makeToken('BBB', '0xbbb');
+
+  it('builds a queryKey pairing each token symbol with its address', () => {
+    const opts = getXBalancesQueryOptions({
+      xService: makeXService({}),
+      xChainId: 'sonic',
+      xTokens: [tokenA, tokenB],
+      address: '0xuser',
+    });
+
+    expect(opts.queryKey).toEqual([
+      'shared',
+      'xBalances',
+      'sonic',
+      [
+        ['AAA', '0xaaa'],
+        ['BBB', '0xbbb'],
+      ],
+      '0xuser',
+    ]);
+  });
+
+  it('is disabled when xService is missing', () => {
+    const opts = getXBalancesQueryOptions({
+      xService: undefined,
+      xChainId: 'sonic',
+      xTokens: [tokenA],
+      address: '0xuser',
+    });
+    expect(opts.enabled).toBe(false);
+  });
+
+  it('is disabled when address is missing', () => {
+    const opts = getXBalancesQueryOptions({
+      xService: makeXService({}),
+      xChainId: 'sonic',
+      xTokens: [tokenA],
+      address: undefined,
+    });
+    expect(opts.enabled).toBe(false);
+  });
+
+  it('is disabled when xTokens is empty', () => {
+    const opts = getXBalancesQueryOptions({
+      xService: makeXService({}),
+      xChainId: 'sonic',
+      xTokens: [],
+      address: '0xuser',
+    });
+    expect(opts.enabled).toBe(false);
+  });
+
+  it('is enabled when all inputs are present', () => {
+    const opts = getXBalancesQueryOptions({
+      xService: makeXService({}),
+      xChainId: 'sonic',
+      xTokens: [tokenA],
+      address: '0xuser',
+    });
+    expect(opts.enabled).toBe(true);
+  });
+
+  it('queryFn delegates to xService.getBalances with address and tokens', async () => {
+    const expected = { '0xaaa': 42n };
+    const xService = makeXService(expected);
+
+    const opts = getXBalancesQueryOptions({
+      xService,
+      xChainId: 'sonic',
+      xTokens: [tokenA],
+      address: '0xuser',
+    });
+
+    const result = await opts.queryFn();
+    expect(result).toEqual(expected);
+    expect(xService.getBalances).toHaveBeenCalledWith('0xuser', [tokenA]);
+  });
+
+  it('queryFn returns {} when xService is undefined (defensive, enabled should prevent this)', async () => {
+    const opts = getXBalancesQueryOptions({
+      xService: undefined,
+      xChainId: 'sonic',
+      xTokens: [tokenA],
+      address: '0xuser',
+    });
+
+    const result = await opts.queryFn();
+    expect(result).toEqual({});
+  });
+});

package/src/hooks/shared/useXBalances.ts

@@ -0,0 +1,61 @@
+import { type UseQueryResult, useQuery } from '@tanstack/react-query';
+import type { SpokeChainKey, IXServiceBase, XToken } from '@sodax/sdk';
+import type { ReadHookParams } from './types.js';
+
+/**
+ * Domain inputs for {@link useXBalances}. `xChainId` is optional so the hook can be mounted
+ * before a chain is selected; `enabled` gates execution on every required field being present.
+ */
+export interface XBalancesInputs {
+  xService: IXServiceBase | undefined;
+  xChainId: SpokeChainKey | undefined;
+  xTokens: readonly XToken[];
+  address: string | undefined;
+}
+
+export type UseXBalancesParams = ReadHookParams<Record<string, bigint>, XBalancesInputs>;
+
+const REFETCH_INTERVAL_MS = 5_000;
+
+/**
+ * Pure builder for {@link useXBalances} query options. Exported for unit
+ * tests and for advanced callers that compose their own `useQuery` wrapper.
+ */
+export function getXBalancesQueryOptions({ xService, xChainId, xTokens, address }: XBalancesInputs) {
+  return {
+    // Pair symbol + address: readable in devtools, unique on-chain (symbol alone
+    // can collide — e.g. scam tokens copying legitimate ticker).
+    queryKey: ['shared', 'xBalances', xChainId, xTokens.map(x => [x.symbol, x.address] as const), address] as const,
+    queryFn: async (): Promise<Record<string, bigint>> => {
+      if (!xService) return {};
+      return xService.getBalances(address, xTokens);
+    },
+    enabled: !!xService && !!address && xTokens.length > 0,
+    refetchInterval: REFETCH_INTERVAL_MS,
+  };
+}
+
+/**
+ * Fetch token balances for multiple tokens on a specific chain. Returns an
+ * object mapping each token's address to its balance in smallest unit.
+ *
+ * @example
+ * ```tsx
+ * const xService = useXService({ xChainType: getXChainType(xChainId) });
+ * const { data: balances } = useXBalances({ params: { xService, xChainId, xTokens, address } });
+ * ```
+ */
+export function useXBalances({
+  params,
+  queryOptions,
+}: UseXBalancesParams = {}): UseQueryResult<Record<string, bigint>> {
+  return useQuery({
+    ...getXBalancesQueryOptions({
+      xService: params?.xService,
+      xChainId: params?.xChainId,
+      xTokens: params?.xTokens ?? [],
+      address: params?.address,
+    }),
+    ...queryOptions,
+  });
+}

package/src/hooks/staking/index.ts

@@ -1,19 +1,19 @@
 // packages/dapp-kit/src/hooks/staking/index.ts
-export { useStake } from './useStake';
-export { useStakeApprove } from './useStakeApprove';
-export { useStakeAllowance } from './useStakeAllowance';
-export { useUnstake } from './useUnstake';
-export { useClaim } from './useClaim';
-export { useCancelUnstake } from './useCancelUnstake';
-export { useStakingInfo } from './useStakingInfo';
-export { useUnstakingInfoWithPenalty } from './useUnstakingInfoWithPenalty';
-export { useStakingConfig } from './useStakingConfig';
-export { useStakeRatio } from './useStakeRatio';
-export { useInstantUnstakeRatio } from './useInstantUnstakeRatio';
-export { useConvertedAssets } from './useConvertedAssets';
-export { useInstantUnstake } from './useInstantUnstake';
-export { useUnstakeAllowance } from './useUnstakeAllowance';
-export { useUnstakeApprove } from './useUnstakeApprove';
-export { useUnstakingInfo } from './useUnstakingInfo';
-export { useInstantUnstakeApprove } from './useInstantUnstakeApprove';
-export { useInstantUnstakeAllowance } from './useInstantUnstakeAllowance';
+export { useStake } from './useStake.js';
+export { useStakeApprove } from './useStakeApprove.js';
+export { useStakeAllowance } from './useStakeAllowance.js';
+export { useUnstake } from './useUnstake.js';
+export { useClaim } from './useClaim.js';
+export { useCancelUnstake } from './useCancelUnstake.js';
+export { useStakingInfo } from './useStakingInfo.js';
+export { useUnstakingInfoWithPenalty } from './useUnstakingInfoWithPenalty.js';
+export { useStakingConfig } from './useStakingConfig.js';
+export { useStakeRatio } from './useStakeRatio.js';
+export { useInstantUnstakeRatio } from './useInstantUnstakeRatio.js';
+export { useConvertedAssets } from './useConvertedAssets.js';
+export { useInstantUnstake } from './useInstantUnstake.js';
+export { useUnstakeAllowance } from './useUnstakeAllowance.js';
+export { useUnstakeApprove } from './useUnstakeApprove.js';
+export { useUnstakingInfo } from './useUnstakingInfo.js';
+export { useInstantUnstakeApprove } from './useInstantUnstakeApprove.js';
+export { useInstantUnstakeAllowance } from './useInstantUnstakeAllowance.js';