@sodax/dapp-kit 0.0.1-rc.3 → 0.0.1-rc.30

package/dist/index.d.mts

@@ -0,0 +1,1425 @@
+import * as _sodax_sdk from '@sodax/sdk';
+import { Sodax, SpokeProvider, GetEstimateGasReturnType, TxReturnType, SpokeChainId, StellarSpokeProvider, EvmHubProvider, IWalletProvider, UserReserveData, MoneyMarketAction, SolverIntentQuoteRequest, Result, SolverIntentQuoteResponse, SolverErrorResponse, SolverExecutionResponse, Intent, IntentDeliveryInfo, IntentError, IntentErrorCode, CreateIntentParams, Hex, SolverIntentStatusResponse, IntentResponse, OrderbookResponse, MoneyMarketPosition, MoneyMarketAsset, MoneyMarketAssetBorrowers, MoneyMarketAssetSuppliers, MoneyMarketBorrowers, CreateBridgeIntentParams, SpokeTxHash, HubTxHash, BridgeError, BridgeErrorCode, XToken as XToken$1, StakeParams, UnstakeParams, ClaimParams, CancelUnstakeParams, StakingInfo, UnstakingInfo, UnstakeRequestWithPenalty, StakingConfig, InstantUnstakeParams, SodaxConfig } from '@sodax/sdk';
+import { RpcConfig, SpokeChainId as SpokeChainId$1, XToken, ChainId } from '@sodax/types';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseMutationResult, UseQueryResult } from '@tanstack/react-query';
+import { Address } from 'viem';
+import { ReactNode, ReactElement } from 'react';
+
+interface SodaxContextType {
+    sodax: Sodax;
+    testnet: boolean;
+    rpcConfig: RpcConfig;
+}
+
+/**
+ * Hook to access the Sodax context which provides access to the Sodax SDK instance and chain configuration
+ * @throws {Error} If used outside of a SodaxProvider
+ * @returns {SodaxContextType} The Sodax context containing SDK instance and configuration
+ */
+declare const useSodaxContext: () => SodaxContextType;
+
+declare function useEstimateGas<T extends SpokeProvider = SpokeProvider>(spokeProvider: T | undefined): UseMutationResult<GetEstimateGasReturnType<T>, Error, TxReturnType<T, true>>;
+
+/**
+ * Hook for deriving user wallet address for hub abstraction.
+ *
+ * This hook derives the user's abstracted wallet address for the hub chain.
+ * If the spoke chain is the same as the hub chain, it returns the original wallet address.
+ * Otherwise, it returns the abstracted wallet address for cross-chain operations.
+ *
+ * @param spokeProvider - The spoke provider instance for the origin chain
+ * @param walletAddress - Optional user wallet address on spoke chain. If not provided, will fetch from spokeProvider
+ * @returns A React Query result object containing:
+ *   - data: The derived user wallet address when available
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during derivation
+ *
+ * @example
+ * ```typescript
+ * const { data: derivedAddress, isLoading, error } = useDeriveUserWalletAddress(spokeProvider, userAddress);
+ * ```
+ */
+declare function useDeriveUserWalletAddress(spokeProvider: SpokeProvider | undefined, walletAddress?: string | undefined): UseQueryResult<Address, Error>;
+
+/**
+ * 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>;
+ * ```
+ */
+declare function useStellarTrustlineCheck<T extends SpokeProvider = SpokeProvider>(token: string | undefined, amount: bigint | undefined, spokeProvider: T | undefined, chainId: SpokeChainId | undefined): UseQueryResult<boolean, Error>;
+
+/**
+ * React hook to request a Stellar trustline for a given token and amount.
+ *
+ * This hook provides a mutation 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 {UseMutationResult<TxReturnType<StellarSpokeProvider, false>, Error, { token: string; amount: bigint; spokeProvider: T }>}
+ *   A React Query mutation result object containing:
+ *   - `mutate`/`mutateAsync`: Function to trigger the trustline request.
+ *   - `data`: The transaction result if successful.
+ *   - `error`: Any error encountered during the request.
+ *   - `isLoading`: Whether the mutation is in progress.
+ *   - Other React Query mutation state.
+ *
+ * @example
+ * ```tsx
+ * import { useRequestTrustline } from '@sodax/dapp-kit';
+ *
+ * const { mutate: requestTrustline, isLoading, error, data } = useRequestTrustline('USDC-G...TOKEN');
+ *
+ * // To request a trustline:
+ * 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 (data) return <span>Trustline requested! Tx: {data.txHash}</span>;
+ * ```
+ */
+declare function useRequestTrustline<T extends SpokeProvider = SpokeProvider>(token: string | undefined): UseMutationResult<TxReturnType<StellarSpokeProvider, false>, Error, {
+    token: string;
+    amount: bigint;
+    spokeProvider: T;
+}>;
+
+declare function useHubProvider(): EvmHubProvider;
+
+/**
+ * Hook to get the appropriate spoke provider based on the chain type.
+ * Supports EVM, SUI, ICON and INJECTIVE chains.
+ *
+ * @param {SpokeChainId | undefined} spokeChainId - The spoke chain ID to get the provider for
+ * @param {IWalletProvider | undefined} walletProvider - The wallet provider to use
+ * @returns {SpokeProvider | undefined} The appropriate spoke provider instance for the given chain ID, or undefined if invalid/unsupported
+ *
+ * @example
+ * ```tsx
+ * // Using a specific SpokeChainId and wallet provider
+ * const spokeProvider = useSpokeProvider(spokeChainId, walletProvider);
+ * ```
+ */
+declare function useSpokeProvider(spokeChainId: SpokeChainId$1 | undefined, walletProvider?: IWalletProvider | undefined): SpokeProvider | undefined;
+
+interface BorrowResponse {
+    ok: true;
+    value: [string, string];
+}
+/**
+ * Hook for borrowing tokens from the Sodax money market.
+ *
+ * This hook provides functionality to borrow tokens from the money market protocol,
+ * handling the entire borrow process including transaction creation, submission,
+ * and cross-chain communication.
+ *
+ * @param {XToken} spokeToken - The token to borrow from the spoke chain. Must be an XToken with valid address and chain information.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the borrow transaction. Must be a valid SpokeProvider instance.
+ *
+ * @returns {UseMutationResult<BorrowResponse, Error, string>} A mutation result object with the following properties:
+ *   - mutateAsync: Function to execute the borrow transaction
+ *   - isPending: Boolean indicating if a transaction is in progress
+ *   - error: Error object if the last transaction failed, null otherwise
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: borrow, isPending, error } = useBorrow(spokeToken);
+ * await borrow('100');
+ * ```
+ *
+ * @throws {Error} When:
+ *   - spokeProvider is not available
+ *   - Transaction execution fails
+ */
+declare function useBorrow(spokeToken: XToken, spokeProvider: SpokeProvider | undefined): UseMutationResult<BorrowResponse, Error, string>;
+
+interface RepayResponse {
+    ok: true;
+    value: [string, string];
+}
+/**
+ * Hook for repaying borrowed tokens to the Sodax money market.
+ *
+ * This hook provides functionality to repay borrowed tokens back to the money market protocol,
+ * handling the entire repayment process including transaction creation, submission,
+ * and cross-chain communication.
+ *
+ * @param {XToken} spokeToken - The token to repay on the spoke chain. Must be an XToken with valid address and chain information.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the repay transaction. Must be a valid SpokeProvider instance.
+ *
+ * @returns {UseMutationResult<RepayResponse, Error, string>} A mutation result object with the following properties:
+ *   - mutateAsync: Function to execute the repay transaction
+ *   - isPending: Boolean indicating if a transaction is in progress
+ *   - error: Error object if the last transaction failed, null otherwise
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: repay, isPending, error } = useRepay(spokeToken);
+ * await repay('100');
+ * ```
+ *
+ * @throws {Error} When:
+ *   - spokeProvider is not available
+ *   - Transaction execution fails
+ */
+declare function useRepay(spokeToken: XToken, spokeProvider: SpokeProvider | undefined): UseMutationResult<RepayResponse, Error, string>;
+
+interface SupplyResponse {
+    ok: true;
+    value: [string, string];
+}
+/**
+ * Hook for supplying tokens to the Sodax money market.
+ *
+ * This hook provides functionality to supply tokens to the money market protocol,
+ * handling the entire supply process including transaction creation, submission,
+ * and cross-chain communication.
+ *
+ * @param {XToken} spokeToken - The token to supply on the spoke chain. Must be an XToken with valid address and chain information.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the supply transaction. Must be a valid SpokeProvider instance.
+ *
+ * @returns {UseMutationResult<SupplyResponse, Error, string>} A mutation result object with the following properties:
+ *   - mutateAsync: Function to execute the supply transaction
+ *   - isPending: Boolean indicating if a transaction is in progress
+ *   - error: Error object if the last transaction failed, null otherwise
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: supply, isPending, error } = useSupply(spokeToken);
+ * await supply('100');
+ * ```
+ *
+ * @throws {Error} When:
+ *   - spokeProvider is not available
+ */
+declare function useSupply(spokeToken: XToken, spokeProvider: SpokeProvider | undefined): UseMutationResult<SupplyResponse, Error, string>;
+
+interface WithdrawResponse {
+    ok: true;
+    value: [string, string];
+}
+/**
+ * Hook for withdrawing supplied tokens from the Sodax money market.
+ *
+ * This hook provides functionality to withdraw previously supplied tokens from the money market protocol,
+ * handling the entire withdrawal process including transaction creation, submission,
+ * and cross-chain communication.
+ *
+ * @param {XToken} spokeToken - The token to withdraw from the spoke chain. Must be an XToken with valid address and chain information.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the withdraw transaction. Must be a valid SpokeProvider instance.
+ *
+ * @returns {UseMutationResult<WithdrawResponse, Error, string>} A mutation result object with the following properties:
+ *   - mutateAsync: Function to execute the withdraw transaction
+ *   - isPending: Boolean indicating if a transaction is in progress
+ * @example
+ * ```typescript
+ * const { mutateAsync: withdraw, isPending, error } = useWithdraw(spokeToken);
+ * await withdraw('100');
+ * ```
+ *
+ * @throws {Error} When:
+ *   - spokeProvider is not available
+ *   - Transaction execution fails
+ */
+declare function useWithdraw(spokeToken: XToken, spokeProvider: SpokeProvider | undefined): UseMutationResult<WithdrawResponse, Error, string>;
+
+/**
+ * Hook for fetching user reserves data from the Sodax money market.
+ *
+ * This hook provides access to the current state of user reserves in the money market protocol.
+ * The data is automatically fetched and cached using React Query.
+ *
+ * @example
+ * ```typescript
+ * const { data: userReservesData, isLoading, error } = useUserReservesData(spokeProvider, address);
+ * ```
+ *
+ * @returns A React Query result object containing:
+ *   - data: The user reserves data when available
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during data fetching
+ */
+declare function useUserReservesData(spokeProvider: SpokeProvider | undefined, address: string | undefined, refetchInterval?: number): UseQueryResult<readonly [readonly UserReserveData[], number], Error>;
+
+/**
+ * Hook for fetching reserves data from the Sodax money market.
+ *
+ * This hook provides access to the current state of all reserves in the money market protocol,
+ * including liquidity, interest rates, and other key metrics. The data is automatically
+ * fetched and cached using React Query.
+ *
+ * @example
+ * ```typescript
+ * const { data: reservesData, isLoading, error } = useReservesData();
+ * ```
+ *
+ * @returns A React Query result object containing:
+ *   - data: The reserves data when available
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during data fetching
+ */
+declare function useReservesData(): _tanstack_react_query.UseQueryResult<readonly [readonly _sodax_sdk.AggregatedReserveData[], _sodax_sdk.BaseCurrencyInfo], Error>;
+
+/**
+ * Hook for checking token allowance for money market operations.
+ *
+ * This hook verifies if the user has approved enough tokens for a specific money market action
+ * (borrow/repay). It automatically queries and tracks the allowance status.
+ *
+ * @param {XToken} token - The token to check allowance for. Must be an XToken with valid address and chain information.
+ * @param {string} amount - The amount to check allowance for, as a decimal string
+ * @param {MoneyMarketAction} action - The money market action to check allowance for ('borrow' or 'repay')
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for allowance checks
+ *
+ * @returns {UseQueryResult<boolean, Error>} A React Query result containing:
+ *   - data: Boolean indicating if allowance is sufficient
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during the check
+ *
+ * @example
+ * ```typescript
+ * const { data: hasAllowed, isLoading } = useMMAllowance(token, "100", "repay", provider);
+ * ```
+ */
+declare function useMMAllowance(token: XToken, amount: string, action: MoneyMarketAction, spokeProvider: SpokeProvider | undefined): UseQueryResult<boolean, Error>;
+
+interface UseApproveReturn$1 {
+    approve: ({ amount, action }: {
+        amount: string;
+        action: MoneyMarketAction;
+    }) => Promise<boolean>;
+    isLoading: boolean;
+    error: Error | null;
+    resetError: () => void;
+}
+/**
+ * Hook for approving token spending for money market actions
+ * @param token The token to approve spending for
+ * @param spokeProvider The spoke provider instance for the chain
+ * @returns Object containing approve function, loading state, error state and reset function
+ * @example
+ * ```tsx
+ * const { approve, isLoading, error } = useMMApprove(token, spokeProvider);
+ *
+ * // Approve tokens for supply action
+ * await approve({ amount: "100", action: "supply" });
+ * ```
+ */
+declare function useMMApprove(token: XToken, spokeProvider: SpokeProvider | undefined): UseApproveReturn$1;
+
+/**
+ * Hook for fetching a quote for an intent-based swap.
+ *
+ * This hook provides real-time quote data for an intent-based swap.
+ *
+ * @param {SolverIntentQuoteRequest | undefined} payload - The intent quote request parameters. If undefined, the query will be disabled.
+ *
+ * @returns {UseQueryResult<Result<SolverIntentQuoteResponse, SolverErrorResponse> | undefined>} A query result object containing:
+ *   - data: The quote result from the solver
+ *   - isLoading: Boolean indicating if the quote is being fetched
+ *   - error: Error object if the quote request failed
+ *   - refetch: Function to manually trigger a quote refresh
+ *
+ * @example
+ * ```typescript
+ * const { data: quote, isLoading } = useQuote({
+ *   token_src: '0x...',
+ *   token_src_blockchain_id: '1',
+ *   token_dst: '0x...',
+ *   token_dst_blockchain_id: '2',
+ *   amount: '1000000000000000000',
+ *   quote_type: 'exact_input',
+ * });
+ *
+ * if (isLoading) return <div>Loading quote...</div>;
+ * if (quote) {
+ *   console.log('Quote received:', quote);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The quote is automatically refreshed every 3 seconds
+ * - The query is disabled when payload is undefined
+ * - Uses React Query for efficient caching and state management
+ */
+declare const useQuote: (payload: SolverIntentQuoteRequest | undefined) => UseQueryResult<Result<SolverIntentQuoteResponse, SolverErrorResponse> | undefined>;
+
+type CreateIntentResult = Result<[SolverExecutionResponse, Intent, IntentDeliveryInfo], IntentError<IntentErrorCode>>;
+/**
+ * Hook for creating and submitting an swap intent order for cross-chain swaps.
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the swap
+ * @returns {UseMutationResult} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: swap, isPending } = useSwap(spokeProvider);
+ *
+ * const handleSwap = async () => {
+ *   const result = await swap({
+ *     token_src: '0x...',
+ *     token_src_blockchain_id: 'arbitrum',
+ *     token_dst: '0x...',
+ *     token_dst_blockchain_id: 'polygon',
+ *     amount: '1000000000000000000',
+ *     min_output_amount: '900000000000000000'
+ *   });
+ * };
+ * ```
+ */
+declare function useSwap(spokeProvider: SpokeProvider | undefined): UseMutationResult<CreateIntentResult, Error, CreateIntentParams>;
+
+/**
+ * Hook for monitoring the status of an intent-based swap.
+ *
+ * This hook provides real-time status updates for an intent-based swap transaction.
+ *
+ * @param {Hex} intent_tx_hash - The transaction hash of the intent order on the hub chain
+ *
+ * @returns {UseQueryResult<Result<SolverIntentStatusResponse, SolverErrorResponse> | undefined>} A query result object containing:
+ *   - data: The status result from the solver
+ *   - isLoading: Boolean indicating if the status is being fetched
+ *   - error: Error object if the status request failed
+ *   - refetch: Function to manually trigger a status refresh
+ *
+ * @example
+ * ```typescript
+ * const { data: status, isLoading } = useStatus('0x...');
+ *
+ * if (isLoading) return <div>Loading status...</div>;
+ * if (status?.ok) {
+ *   console.log('Status:', status.value);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The status is automatically refreshed every 3 seconds
+ * - Uses React Query for efficient caching and state management
+ */
+declare const useStatus: (intent_tx_hash: Hex) => UseQueryResult<Result<SolverIntentStatusResponse, SolverErrorResponse> | undefined>;
+
+/**
+ * Hook for checking token allowance for money market operations.
+ *
+ * This hook verifies if the user has approved enough tokens for a specific money market action
+ * (borrow/repay). It automatically queries and tracks the allowance status.
+ *
+ * @param {CreateIntentParams} params - The parameters for the intent to check allowance for.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for allowance checks
+ *
+ * @returns {UseQueryResult<boolean, Error>} A React Query result containing:
+ *   - data: Boolean indicating if allowance is sufficient
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during the check
+ *
+ * @example
+ * ```typescript
+ * const { data: hasAllowed, isLoading } = useMMAllowance(params, spokeProvider);
+ * ```
+ */
+declare function useSwapAllowance(params: CreateIntentParams | undefined, spokeProvider: SpokeProvider | undefined): UseQueryResult<boolean, Error>;
+
+interface UseApproveReturn {
+    approve: ({ params }: {
+        params: CreateIntentParams;
+    }) => Promise<boolean>;
+    isLoading: boolean;
+    error: Error | null;
+    resetError: () => void;
+}
+/**
+ * Hook for approving token spending for money market actions
+ * @param token The token to approve spending for
+ * @param spokeProvider The spoke provider instance for the chain
+ * @returns Object containing approve function, loading state, error state and reset function
+ * @example
+ * ```tsx
+ * const { approve, isLoading, error } = useApprove(token, spokeProvider);
+ *
+ * // Approve tokens for supply action
+ * await approve({ amount: "100", action: "supply" });
+ * ```
+ */
+declare function useSwapApprove(params: CreateIntentParams | undefined, spokeProvider: SpokeProvider | undefined): UseApproveReturn;
+
+type CancelIntentParams = {
+    intent: Intent;
+    raw?: boolean;
+};
+type CancelIntentResult = Result<TxReturnType<SpokeProvider, boolean>>;
+/**
+ * Hook for canceling a swap intent order.
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for canceling the intent
+ * @returns {UseMutationResult} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: cancelSwap, isPending } = useCancelSwap(spokeProvider);
+ *
+ * const handleCancelSwap = async () => {
+ *   const result = await cancelSwap({
+ *     intent: intentObject,
+ *     raw: false // optional, defaults to false
+ *   });
+ * };
+ * ```
+ */
+declare function useCancelSwap(spokeProvider: SpokeProvider | undefined): UseMutationResult<CancelIntentResult, Error, CancelIntentParams>;
+
+/**
+ * Hook for fetching intent details by transaction hash from the backend API.
+ *
+ * This hook provides access to intent data associated with a specific transaction hash,
+ * including intent details, events, and transaction information. The data is automatically
+ * fetched and cached using React Query.
+ *
+ * @param {string | undefined} txHash - The transaction hash to fetch intent for. If undefined, the query will be disabled.
+ *
+ * @returns {UseQueryResult<IntentResponse | undefined>} A query result object containing:
+ *   - data: The intent response data when available
+ *   - isLoading: Boolean indicating if the request is in progress
+ *   - error: Error object if the request failed
+ *   - refetch: Function to manually trigger a data refresh
+ *
+ * @example
+ * ```typescript
+ * const { data: intent, isLoading, error } = useIntentByTxHash('0x123...');
+ *
+ * if (isLoading) return <div>Loading intent...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (intent) {
+ *   console.log('Intent found:', intent.intentHash);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The query is disabled when txHash is undefined or empty
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ */
+declare const useBackendIntentByTxHash: (txHash: string | undefined) => UseQueryResult<IntentResponse | undefined>;
+
+/**
+ * Hook for fetching intent details by intent hash from the backend API.
+ *
+ * This hook provides access to intent data using the intent hash directly,
+ * including intent details, events, and transaction information. The data is automatically
+ * fetched and cached using React Query.
+ *
+ * @param {string | undefined} intentHash - The intent hash to fetch intent for. If undefined, the query will be disabled.
+ *
+ * @returns {UseQueryResult<IntentResponse | undefined>} A query result object containing:
+ *   - data: The intent response data when available
+ *   - isLoading: Boolean indicating if the request is in progress
+ *   - error: Error object if the request failed
+ *   - refetch: Function to manually trigger a data refresh
+ *
+ * @example
+ * ```typescript
+ * const { data: intent, isLoading, error } = useIntentByHash('0xabc...');
+ *
+ * if (isLoading) return <div>Loading intent...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (intent) {
+ *   console.log('Intent found:', intent.intentHash);
+ *   console.log('Open status:', intent.open);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The query is disabled when intentHash is undefined or empty
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ */
+declare const useBackendIntentByHash: (intentHash: string | undefined) => UseQueryResult<IntentResponse | undefined>;
+
+/**
+ * Hook for fetching the solver orderbook from the backend API.
+ *
+ * This hook provides access to the solver orderbook data, including intent states
+ * and intent data for all available intents. The data is automatically fetched
+ * and cached using React Query with pagination support.
+ *
+ * @param {Object} params - Pagination parameters for the orderbook
+ * @param {string} params.offset - The offset for pagination (number as string)
+ * @param {string} params.limit - The limit for pagination (number as string)
+ *
+ * @returns {UseQueryResult<OrderbookResponse | undefined>} A query result object containing:
+ *   - data: The orderbook response data when available
+ *   - isLoading: Boolean indicating if the request is in progress
+ *   - error: Error object if the request failed
+ *   - refetch: Function to manually trigger a data refresh
+ *
+ * @example
+ * ```typescript
+ * const { data: orderbook, isLoading, error } = useOrderbook({
+ *   offset: '0',
+ *   limit: '10'
+ * });
+ *
+ * if (isLoading) return <div>Loading orderbook...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (orderbook) {
+ *   console.log('Total intents:', orderbook.total);
+ *   console.log('Intents:', orderbook.data);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The query is disabled when params are undefined or invalid
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ * - Stale time of 30 seconds for real-time orderbook data
+ * - Supports pagination through offset and limit parameters
+ */
+declare const useBackendOrderbook: (params: {
+    offset: string;
+    limit: string;
+} | undefined) => UseQueryResult<OrderbookResponse | undefined>;
+
+/**
+ * Hook for fetching money market position for a specific user from the backend API.
+ *
+ * This hook provides access to a user's money market positions, including their
+ * aToken balances, variable debt token balances, and associated reserve information.
+ * The data is automatically fetched and cached using React Query.
+ *
+ * @param {string | undefined} userAddress - The user's wallet address. If undefined, the query will be disabled.
+ *
+ * @returns {UseQueryResult<MoneyMarketPosition | undefined>} A query result object containing:
+ *   - data: The money market position data when available
+ *   - isLoading: Boolean indicating if the request is in progress
+ *   - error: Error object if the request failed
+ *   - refetch: Function to manually trigger a data refresh
+ *
+ * @example
+ * ```typescript
+ * const { data: position, isLoading, error } = useMoneyMarketPosition('0x123...');
+ *
+ * if (isLoading) return <div>Loading position...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (position) {
+ *   console.log('User address:', position.userAddress);
+ *   console.log('Positions:', position.positions);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The query is disabled when userAddress is undefined or empty
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ * - Includes user's aToken and debt token balances across all reserves
+ */
+declare const useBackendMoneyMarketPosition: (userAddress: string | undefined) => UseQueryResult<MoneyMarketPosition | undefined>;
+
+/**
+ * Hook for fetching all money market assets from the backend API.
+ *
+ * This hook provides access to all available money market assets, including
+ * their reserve information, liquidity rates, borrow rates, and market statistics.
+ * The data is automatically fetched and cached using React Query.
+ *
+ * @returns {UseQueryResult<MoneyMarketAsset[]>} A query result object containing:
+ *   - data: Array of money market asset data when available
+ *   - isLoading: Boolean indicating if the request is in progress
+ *   - error: Error object if the request failed
+ *   - refetch: Function to manually trigger a data refresh
+ *
+ * @example
+ * ```typescript
+ * const { data: assets, isLoading, error } = useAllMoneyMarketAssets();
+ *
+ * if (isLoading) return <div>Loading assets...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (assets) {
+ *   console.log('Total assets:', assets.length);
+ *   assets.forEach(asset => {
+ *     console.log(`${asset.symbol}: ${asset.liquidityRate} liquidity rate`);
+ *   });
+ * }
+ * ```
+ *
+ * @remarks
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ * - Returns comprehensive asset information including rates and statistics
+ * - No parameters required - fetches all available assets
+ */
+declare const useBackendAllMoneyMarketAssets: () => UseQueryResult<MoneyMarketAsset[]>;
+
+/**
+ * Hook for fetching specific money market asset details from the backend API.
+ *
+ * This hook provides access to detailed information for a specific money market asset,
+ * including reserve information, liquidity rates, borrow rates, and market statistics.
+ * The data is automatically fetched and cached using React Query.
+ *
+ * @param {string | undefined} reserveAddress - The reserve contract address. If undefined, the query will be disabled.
+ *
+ * @returns {UseQueryResult<MoneyMarketAsset | undefined>} A query result object containing:
+ *   - data: The money market asset data when available
+ *   - isLoading: Boolean indicating if the request is in progress
+ *   - error: Error object if the request failed
+ *   - refetch: Function to manually trigger a data refresh
+ *
+ * @example
+ * ```typescript
+ * const { data: asset, isLoading, error } = useMoneyMarketAsset('0xabc...');
+ *
+ * if (isLoading) return <div>Loading asset...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (asset) {
+ *   console.log('Asset symbol:', asset.symbol);
+ *   console.log('Liquidity rate:', asset.liquidityRate);
+ *   console.log('Variable borrow rate:', asset.variableBorrowRate);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The query is disabled when reserveAddress is undefined or empty
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ * - Returns comprehensive asset information for the specified reserve
+ */
+declare const useBackendMoneyMarketAsset: (reserveAddress: string | undefined) => UseQueryResult<MoneyMarketAsset | undefined>;
+
+/**
+ * Hook for fetching borrowers for a specific money market asset from the backend API.
+ *
+ * This hook provides access to the list of borrowers for a specific money market asset,
+ * with pagination support. The data is automatically fetched and cached using React Query.
+ *
+ * @param {Object} params - Parameters for fetching asset borrowers
+ * @param {string | undefined} params.reserveAddress - The reserve contract address. If undefined, the query will be disabled.
+ * @param {string} params.offset - The offset for pagination (number as string)
+ * @param {string} params.limit - The limit for pagination (number as string)
+ *
+ * @returns {UseQueryResult<MoneyMarketAssetBorrowers | undefined>} A query result object containing:
+ *   - data: The asset borrowers data when available
+ *   - isLoading: Boolean indicating if the request is in progress
+ *   - error: Error object if the request failed
+ *   - refetch: Function to manually trigger a data refresh
+ *
+ * @example
+ * ```typescript
+ * const { data: borrowers, isLoading, error } = useMoneyMarketAssetBorrowers({
+ *   reserveAddress: '0xabc...',
+ *   offset: '0',
+ *   limit: '20'
+ * });
+ *
+ * if (isLoading) return <div>Loading borrowers...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (borrowers) {
+ *   console.log('Total borrowers:', borrowers.total);
+ *   console.log('Borrowers:', borrowers.borrowers);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The query is disabled when reserveAddress is undefined or empty
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ * - Supports pagination through offset and limit parameters
+ */
+declare const useBackendMoneyMarketAssetBorrowers: (params: {
+    reserveAddress: string | undefined;
+    offset: string;
+    limit: string;
+}) => UseQueryResult<MoneyMarketAssetBorrowers | undefined>;
+
+/**
+ * Hook for fetching suppliers for a specific money market asset from the backend API.
+ *
+ * This hook provides access to the list of suppliers for a specific money market asset,
+ * with pagination support. The data is automatically fetched and cached using React Query.
+ *
+ * @param {Object} params - Parameters for fetching asset suppliers
+ * @param {string | undefined} params.reserveAddress - The reserve contract address. If undefined, the query will be disabled.
+ * @param {string} params.offset - The offset for pagination (number as string)
+ * @param {string} params.limit - The limit for pagination (number as string)
+ *
+ * @returns {UseQueryResult<MoneyMarketAssetSuppliers | undefined>} A query result object containing:
+ *   - data: The asset suppliers data when available
+ *   - isLoading: Boolean indicating if the request is in progress
+ *   - error: Error object if the request failed
+ *   - refetch: Function to manually trigger a data refresh
+ *
+ * @example
+ * ```typescript
+ * const { data: suppliers, isLoading, error } = useMoneyMarketAssetSuppliers({
+ *   reserveAddress: '0xabc...',
+ *   offset: '0',
+ *   limit: '20'
+ * });
+ *
+ * if (isLoading) return <div>Loading suppliers...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (suppliers) {
+ *   console.log('Total suppliers:', suppliers.total);
+ *   console.log('Suppliers:', suppliers.suppliers);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The query is disabled when reserveAddress is undefined or empty
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ * - Supports pagination through offset and limit parameters
+ */
+declare const useBackendMoneyMarketAssetSuppliers: (params: {
+    reserveAddress: string | undefined;
+    offset: string;
+    limit: string;
+}) => UseQueryResult<MoneyMarketAssetSuppliers | undefined>;
+
+/**
+ * Hook for fetching all money market borrowers from the backend API.
+ *
+ * This hook provides access to the list of all borrowers across all money market assets,
+ * with pagination support. The data is automatically fetched and cached using React Query.
+ *
+ * @param {Object} params - Pagination parameters for fetching all borrowers
+ * @param {string} params.offset - The offset for pagination (number as string)
+ * @param {string} params.limit - The limit for pagination (number as string)
+ *
+ * @returns {UseQueryResult<MoneyMarketBorrowers | undefined>} A query result object containing:
+ *   - data: The all borrowers data when available
+ *   - isLoading: Boolean indicating if the request is in progress
+ *   - error: Error object if the request failed
+ *   - refetch: Function to manually trigger a data refresh
+ *
+ * @example
+ * ```typescript
+ * const { data: borrowers, isLoading, error } = useAllMoneyMarketBorrowers({
+ *   offset: '0',
+ *   limit: '50'
+ * });
+ *
+ * if (isLoading) return <div>Loading borrowers...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (borrowers) {
+ *   console.log('Total borrowers:', borrowers.total);
+ *   console.log('Borrowers:', borrowers.borrowers);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The query is disabled when params are undefined or invalid
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ * - Supports pagination through offset and limit parameters
+ * - Returns borrowers across all money market assets
+ */
+declare const useBackendAllMoneyMarketBorrowers: (params: {
+    offset: string;
+    limit: string;
+} | undefined) => UseQueryResult<MoneyMarketBorrowers | undefined>;
+
+/**
+ * Hook for checking token allowance for bridge operations.
+ *
+ * This hook verifies if the user has approved enough tokens for a specific bridge action.
+ * It automatically queries and tracks the allowance status.
+ *
+ * @param {BridgeParams} params - The parameters for the bridge to check allowance for.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for allowance checks
+ *
+ * @returns {UseQueryResult<boolean, Error>} A React Query result containing:
+ *   - data: Boolean indicating if allowance is sufficient
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during the check
+ *
+ * @example
+ * ```typescript
+ * const { data: hasAllowed, isLoading } = useBridgeAllowance(params, spokeProvider);
+ * ```
+ */
+declare function useBridgeAllowance(params: CreateBridgeIntentParams | undefined, spokeProvider: SpokeProvider | undefined): UseQueryResult<boolean, Error>;
+
+interface UseBridgeApproveReturn {
+    approve: (params: CreateBridgeIntentParams) => Promise<boolean>;
+    isLoading: boolean;
+    error: Error | null;
+    resetError: () => void;
+}
+/**
+ * Hook for approving token spending for bridge actions
+ * @param spokeProvider The spoke provider instance for the chain
+ * @returns Object containing approve function, loading state, error state and reset function
+ * @example
+ * ```tsx
+ * const { approve, isLoading, error } = useBridgeApprove(spokeProvider);
+ *
+ * // Approve tokens for bridge action
+ * await approve({
+ *   srcChainId: '0x2105.base',
+ *   srcAsset: '0x...',
+ *   amount: 1000n,
+ *   dstChainId: '0x89.polygon',
+ *   dstAsset: '0x...',
+ *   recipient: '0x...'
+ * });
+ * ```
+ */
+declare function useBridgeApprove(spokeProvider: SpokeProvider | undefined): UseBridgeApproveReturn;
+
+/**
+ * Hook for executing bridge transactions to transfer tokens between chains.
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the bridge
+ * @returns {UseMutationResult} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: bridge, isPending } = useBridge(spokeProvider);
+ *
+ * const handleBridge = async () => {
+ *   const result = await bridge({
+ *     srcChainId: '0x2105.base',
+ *     srcAsset: '0x...',
+ *     amount: 1000n,
+ *     dstChainId: '0x89.polygon',
+ *     dstAsset: '0x...',
+ *     recipient: '0x...'
+ *   });
+ *
+ *   console.log('Bridge transaction hashes:', {
+ *     spokeTxHash: result.spokeTxHash,
+ *     hubTxHash: result.hubTxHash
+ *   });
+ * };
+ * ```
+ */
+declare function useBridge(spokeProvider: SpokeProvider | undefined): UseMutationResult<Result<[SpokeTxHash, HubTxHash], BridgeError<BridgeErrorCode>>, Error, CreateBridgeIntentParams>;
+
+/**
+ * Hook for getting the amount available to be bridged.
+ *
+ * This hook is used to check if a target chain has enough balance to bridge when bridging.
+ * It automatically queries and tracks the available amount to be bridged.
+ *
+ * @param {SpokeChainId | undefined} chainId - The chain ID to get the balance for
+ * @param {string | undefined} token - The token address to get the balance for
+ *
+ * @returns {UseQueryResult<bigint, Error>} A React Query result containing:
+ *   - data: The available amount to be bridged (bigint)
+ *   - error: Any error that occurred during the check
+ *
+ * @example
+ * ```typescript
+ * const { data: balance, isLoading } = useSpokeAssetManagerTokenBalance(chainId, tokenAddress);
+ *
+ * if (balance) {
+ *   console.log('Asset manager token balance:', balance.toString());
+ * }
+ * ```
+ */
+declare function useGetBridgeableAmount(from: XToken$1 | undefined, to: XToken$1 | undefined): UseQueryResult<bigint, Error>;
+
+/**
+/**
+ * Hook for retrieving all bridgeable tokens from a source token on one chain to a destination chain.
+ *
+ * This hook queries and tracks the set of tokens on the destination chain that can be bridged to,
+ * given a source chain, destination chain, and source token address.
+ *
+ * @param {SpokeChainId | undefined} from - The source chain ID
+ * @param {SpokeChainId | undefined} to - The destination chain ID
+ * @param {string | undefined} token - The source token address
+ *
+ * @returns {UseQueryResult<XToken[], Error>} A React Query result containing:
+ *   - data: Array of bridgeable tokens (XToken[]) on the destination chain
+ *   - error: Any error that occurred during the query
+ *
+ *
+ * @example
+ * ```typescript
+ * const { data: bridgeableTokens, isLoading } = useGetBridgeableTokens(
+ *   fromChainId,
+ *   toChainId,
+ *   fromTokenAddress
+ * );
+ *
+ * if (bridgeableTokens && bridgeableTokens.length > 0) {
+ *   bridgeableTokens.forEach(token => {
+ *     console.log(`Bridgeable token: ${token.symbol} (${token.address}) on chain ${token.xChainId}`);
+ *   });
+ * } else {
+ *   console.log('No bridgeable tokens found for the selected route.');
+ * }
+ * ```
+ */
+declare function useGetBridgeableTokens(from: SpokeChainId | undefined, to: SpokeChainId | undefined, token: string | undefined): UseQueryResult<XToken$1[], Error>;
+
+/**
+ * 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);
+ * };
+ * ```
+ */
+declare function useStake(spokeProvider: SpokeProvider | undefined): UseMutationResult<[SpokeTxHash, HubTxHash], Error, StakeParams>;
+
+/**
+ * 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);
+ * };
+ * ```
+ */
+declare function useStakeApprove(spokeProvider: SpokeProvider | undefined): UseMutationResult<TxReturnType<SpokeProvider, false>, Error, Omit<StakeParams, 'action'>>;
+
+/**
+ * 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');
+ * }
+ * ```
+ */
+declare function useStakeAllowance(params: Omit<StakeParams, 'action'> | undefined, spokeProvider: SpokeProvider | undefined): UseQueryResult<boolean, Error>;
+
+/**
+ * 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);
+ * };
+ * ```
+ */
+declare function useUnstake(spokeProvider: SpokeProvider | undefined): UseMutationResult<[SpokeTxHash, HubTxHash], Error, Omit<UnstakeParams, 'action'>>;
+
+/**
+ * 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
+ *   });
+ *
+ *   console.log('Claim successful:', result);
+ * };
+ * ```
+ */
+declare function useClaim(spokeProvider: SpokeProvider | undefined): UseMutationResult<[SpokeTxHash, HubTxHash], Error, Omit<ClaimParams, 'action'>>;
+
+/**
+ * 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
+ *   });
+ *
+ *   console.log('Cancel unstake successful:', result);
+ * };
+ * ```
+ */
+declare function useCancelUnstake(spokeProvider: SpokeProvider | undefined): UseMutationResult<[SpokeTxHash, HubTxHash], Error, Omit<CancelUnstakeParams, 'action'>>;
+
+/**
+ * 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);
+ * }
+ * ```
+ */
+declare function useStakingInfo(spokeProvider: SpokeProvider | undefined, refetchInterval?: number): UseQueryResult<StakingInfo, Error>;
+
+type UnstakingInfoWithPenalty = UnstakingInfo & {
+    requestsWithPenalty: UnstakeRequestWithPenalty[];
+};
+/**
+ * Hook for fetching unstaking information with penalty calculations 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<UnstakingInfoWithPenalty, Error>} Query result object containing unstaking info with penalties and state
+ *
+ * @example
+ * ```typescript
+ * const { data: unstakingInfo, isLoading, error } = useUnstakingInfoWithPenalty(userAddress, spokeProvider);
+ *
+ * if (isLoading) return <div>Loading unstaking info...</div>;
+ * if (unstakingInfo) {
+ *   console.log('Total unstaking:', unstakingInfo.totalUnstaking);
+ *   unstakingInfo.requestsWithPenalty.forEach(request => {
+ *     console.log('Penalty:', request.penaltyPercentage + '%');
+ *     console.log('Claimable amount:', request.claimableAmount);
+ *   });
+ * }
+ * ```
+ */
+declare function useUnstakingInfoWithPenalty(userAddress: string | undefined, spokeProvider: SpokeProvider | undefined, refetchInterval?: number): UseQueryResult<UnstakingInfoWithPenalty, Error>;
+
+/**
+ * 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);
+ * }
+ * ```
+ */
+declare function useStakingConfig(refetchInterval?: number): UseQueryResult<StakingConfig, Error>;
+
+/**
+ * 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);
+ * }
+ * ```
+ */
+declare function useStakeRatio(amount: bigint | undefined, refetchInterval?: number): UseQueryResult<[bigint, bigint], Error>;
+
+/**
+ * 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);
+ * }
+ * ```
+ */
+declare function useInstantUnstakeRatio(amount: bigint | undefined, refetchInterval?: number): UseQueryResult<bigint, Error>;
+
+/**
+ * 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);
+ * }
+ * ```
+ */
+declare function useConvertedAssets(amount: bigint | undefined, refetchInterval?: number): UseQueryResult<bigint, Error>;
+
+/**
+ * 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
+ *
+ * @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);
+ * };
+ * ```
+ */
+declare function useInstantUnstake(spokeProvider: SpokeProvider | undefined): UseMutationResult<[string, string], Error, Omit<InstantUnstakeParams, 'action'>>;
+
+/**
+ * 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');
+ * }
+ * ```
+ */
+declare function useUnstakeAllowance(params: Omit<UnstakeParams, 'action'> | undefined, spokeProvider: SpokeProvider | undefined): UseQueryResult<boolean, Error>;
+
+/**
+ * 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);
+ * };
+ * ```
+ */
+declare function useUnstakeApprove(spokeProvider: SpokeProvider | undefined): UseMutationResult<TxReturnType<SpokeProvider, false>, Error, Omit<UnstakeParams, 'action'>>;
+
+/**
+ * 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);
+ *   });
+ * }
+ * ```
+ */
+declare function useUnstakingInfo(userAddress: string | undefined, spokeProvider: SpokeProvider | undefined, refetchInterval?: number): UseQueryResult<UnstakingInfo, Error>;
+
+/**
+ * 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);
+ * };
+ * ```
+ */
+declare function useInstantUnstakeApprove(spokeProvider: SpokeProvider | undefined): UseMutationResult<TxReturnType<SpokeProvider, false>, Error, Omit<InstantUnstakeParams, 'action'>>;
+
+/**
+ * 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');
+ * }
+ * ```
+ */
+declare function useInstantUnstakeAllowance(params: Omit<InstantUnstakeParams, 'action'> | undefined, spokeProvider: SpokeProvider | undefined): UseQueryResult<boolean, Error>;
+
+interface SodaxProviderProps {
+    children: ReactNode;
+    testnet?: boolean;
+    config?: SodaxConfig;
+    rpcConfig: RpcConfig;
+}
+declare const SodaxProvider: ({ children, testnet, config, rpcConfig }: SodaxProviderProps) => ReactElement;
+
+declare const getSpokeTokenAddressByVault: (spokeChainId: ChainId, vault: string) => string | undefined;
+
+export { SodaxProvider, getSpokeTokenAddressByVault, useBackendAllMoneyMarketAssets, useBackendAllMoneyMarketBorrowers, useBackendIntentByHash, useBackendIntentByTxHash, useBackendMoneyMarketAsset, useBackendMoneyMarketAssetBorrowers, useBackendMoneyMarketAssetSuppliers, useBackendMoneyMarketPosition, useBackendOrderbook, useBorrow, useBridge, useBridgeAllowance, useBridgeApprove, useCancelSwap, useCancelUnstake, useClaim, useConvertedAssets, useDeriveUserWalletAddress, useEstimateGas, useGetBridgeableAmount, useGetBridgeableTokens, useHubProvider, useInstantUnstake, useInstantUnstakeAllowance, useInstantUnstakeApprove, useInstantUnstakeRatio, useMMAllowance, useMMApprove, useQuote, useRepay, useRequestTrustline, useReservesData, useSodaxContext, useSpokeProvider, useStake, useStakeAllowance, useStakeApprove, useStakeRatio, useStakingConfig, useStakingInfo, useStatus, useStellarTrustlineCheck, useSupply, useSwap, useSwapAllowance, useSwapApprove, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserReservesData, useWithdraw };