@sodax/dapp-kit 1.0.1-beta-rc3 → 1.0.2-beta

package/dist/index.d.mts

@@ -1,8 +1,6 @@
-import * as _sodax_sdk from '@sodax/sdk';
-import { Sodax, SpokeProvider, GetEstimateGasReturnType, TxReturnType, SpokeChainId, StellarSpokeProvider, EvmHubProvider, IWalletProvider, UserReserveData, MoneyMarketAction, Address as Address$1, XToken as XToken$1, ReserveData, FormatReserveUSDResponse, SolverIntentQuoteRequest, Result, SolverIntentQuoteResponse, SolverErrorResponse, SolverExecutionResponse, Intent, IntentDeliveryInfo, IntentError, IntentErrorCode, CreateIntentParams, Hex, SolverIntentStatusResponse, IntentResponse, OrderbookResponse, MoneyMarketPosition, MoneyMarketAsset, MoneyMarketAssetBorrowers, MoneyMarketAssetSuppliers, MoneyMarketBorrowers, CreateBridgeIntentParams, SpokeTxHash, HubTxHash, BridgeError, BridgeErrorCode, StakeParams, UnstakeParams, ClaimParams, CancelUnstakeParams, StakingInfo, UnstakingInfo, UnstakeRequestWithPenalty, StakingConfig, InstantUnstakeParams, SodaxConfig } from '@sodax/sdk';
-import { RpcConfig, SpokeChainId as SpokeChainId$1, XToken } from '@sodax/types';
-import * as _tanstack_react_query from '@tanstack/react-query';
-import { UseMutationResult, UseQueryResult } from '@tanstack/react-query';
+import { Sodax, SpokeProvider, GetEstimateGasReturnType, TxReturnType, SpokeChainId, StellarSpokeProvider, EvmHubProvider, IWalletProvider, MoneyMarketBorrowParams, MoneyMarketError, RelayErrorCode, MoneyMarketRepayParams, MoneyMarketSupplyParams, MoneyMarketWithdrawParams, UserReserveData, AggregatedReserveData, BaseCurrencyInfo, MoneyMarketParams, XToken, ReserveData, FormatReserveUSDResponse, FormatUserSummaryResponse, SolverIntentQuoteRequest, Result, SolverIntentQuoteResponse, SolverErrorResponse, SolverExecutionResponse, Intent, IntentDeliveryInfo, IntentError, IntentErrorCode, CreateIntentParams, Hex, SolverIntentStatusResponse, CreateLimitOrderParams, IntentResponse, Address as Address$1, UserIntentsResponse, OrderbookResponse, MoneyMarketPosition, MoneyMarketAsset, MoneyMarketAssetBorrowers, MoneyMarketAssetSuppliers, MoneyMarketBorrowers, CreateBridgeIntentParams, SpokeTxHash, HubTxHash, BridgeError, BridgeErrorCode, StakeParams, UnstakeParams, ClaimParams, CancelUnstakeParams, StakingInfo, UnstakingInfo, UnstakeRequestWithPenalty, StakingConfig, InstantUnstakeParams, SodaxConfig } from '@sodax/sdk';
+import { RpcConfig, SpokeChainId as SpokeChainId$1, XToken as XToken$1 } from '@sodax/types';
+import { UseMutationResult, UseQueryResult, UseQueryOptions } from '@tanstack/react-query';
 import { Address } from 'viem';
 import { ReactNode, ReactElement } from 'react';
 
@@ -156,160 +154,196 @@ interface BorrowResponse {
     ok: true;
     value: [string, string];
 }
+type UseBorrowParams = {
+    params: MoneyMarketBorrowParams;
+    spokeProvider: SpokeProvider;
+};
 /**
- * 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.
+ * React hook for borrowing tokens in the Sodax money market protocol.
  *
- * @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.
+ * Encapsulates the async process to initiate a borrow transaction via the money market,
+ * handling transaction creation, submission, and cross-chain logic.
  *
- * @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
+ * @returns {UseMutationResult<
+ *   BorrowResponse,
+ *   MoneyMarketError<'CREATE_BORROW_INTENT_FAILED' | 'BORROW_UNKNOWN_ERROR' | RelayErrorCode>,
+ *   UseBorrowParams
+ * >} A React Query mutation result object containing:
+ *   - mutateAsync: (params: UseBorrowParams) => Promise<BorrowResponse>
+ *     Triggers the borrow action. Expects an object with valid borrow params and a `SpokeProvider`.
+ *   - isPending: `boolean` if a borrow transaction is in progress.
+ *   - error: `MoneyMarketError` if the transaction fails, or `null`.
  *
  * @example
  * ```typescript
- * const { mutateAsync: borrow, isPending, error } = useBorrow(spokeToken);
- * await borrow('100');
+ * const { mutateAsync: borrow, isPending, error } = useBorrow();
+ * await borrow({ params: borrowParams, spokeProvider });
  * ```
  *
  * @throws {Error} When:
- *   - spokeProvider is not available
- *   - Transaction execution fails
+ *   - `spokeProvider` is missing or invalid.
+ *   - The underlying borrow transaction fails.
  */
-declare function useBorrow(spokeToken: XToken, spokeProvider: SpokeProvider | undefined): UseMutationResult<BorrowResponse, Error, string>;
+declare function useBorrow(): UseMutationResult<BorrowResponse, MoneyMarketError<'CREATE_BORROW_INTENT_FAILED' | 'BORROW_UNKNOWN_ERROR' | RelayErrorCode>, UseBorrowParams>;
 
 interface RepayResponse {
     ok: true;
     value: [string, string];
 }
+type UseRepayParams = {
+    params: MoneyMarketRepayParams;
+    spokeProvider: SpokeProvider;
+};
 /**
- * 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.
+ * React hook for repaying a borrow in the Sodax money market protocol.
  *
- * @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.
+ * This hook encapsulates the process of sending a repay transaction to the money market.
+ * It manages the asynchronous operation for repayment, including sending the transaction
+ * and error handling.
  *
- * @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
+ * @returns {UseMutationResult<RepayResponse, MoneyMarketError<'CREATE_REPAY_INTENT_FAILED' | 'REPAY_UNKNOWN_ERROR' | RelayErrorCode>, UseRepayParams>} React Query mutation result object containing:
+ *   - mutateAsync: (params: UseRepayParams) => Promise<RepayResponse>
+ *     Initiates a repay transaction using the given MoneyMarketRepayParams and SpokeProvider.
+ *   - isPending: boolean indicating if a transaction is in progress.
+ *   - error: MoneyMarketError if an error occurred while repaying, otherwise undefined.
  *
  * @example
  * ```typescript
- * const { mutateAsync: repay, isPending, error } = useRepay(spokeToken);
- * await repay('100');
+ * const { mutateAsync: repay, isPending, error } = useRepay();
+ * await repay({ params: repayParams, spokeProvider });
  * ```
  *
  * @throws {Error} When:
- *   - spokeProvider is not available
- *   - Transaction execution fails
+ *   - `spokeProvider` is missing or invalid.
+ *   - The underlying repay transaction fails.
  */
-declare function useRepay(spokeToken: XToken, spokeProvider: SpokeProvider | undefined): UseMutationResult<RepayResponse, Error, string>;
+declare function useRepay(): UseMutationResult<RepayResponse, MoneyMarketError<'CREATE_REPAY_INTENT_FAILED' | 'REPAY_UNKNOWN_ERROR' | RelayErrorCode>, UseRepayParams>;
 
 interface SupplyResponse {
     ok: true;
     value: [string, string];
 }
+type UseSupplyParams = {
+    params: MoneyMarketSupplyParams;
+    spokeProvider: SpokeProvider;
+};
 /**
- * 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.
+ * React hook for supplying tokens to the Sodax money market protocol.
  *
- * @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.
+ * Provides a mutation for performing the supply operation using React Query. Useful
+ * for UI components needing to manage the full state (pending, error, etc.) of a supply
+ * transaction. It handles transaction creation, cross-chain logic, and errors.
  *
- * @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
+ * @returns {UseMutationResult<SupplyResponse, MoneyMarketError<'CREATE_SUPPLY_INTENT_FAILED' | 'SUPPLY_UNKNOWN_ERROR' | RelayErrorCode>, UseSupplyParams>}
+ *   Mutation result object from React Query, where:
+ *   - mutateAsync(params: UseSupplyParams): Promise<SupplyResponse>
+ *     Initiates a supply transaction using the given MoneyMarketSupplyParams and SpokeProvider.
+ *   - isPending: boolean indicating if a transaction is in progress.
+ *   - error: MoneyMarketError if an error occurred while supplying, otherwise undefined.
  *
  * @example
  * ```typescript
- * const { mutateAsync: supply, isPending, error } = useSupply(spokeToken);
- * await supply('100');
+ * const { mutateAsync: supply, isPending, error } = useSupply();
+ * await supply({ params: supplyParams, spokeProvider });
  * ```
  *
- * @throws {Error} When:
- *   - spokeProvider is not available
+ * @throws {Error|MoneyMarketError<...>} When:
+ *   - `spokeProvider` is not provided or invalid.
+ *   - The underlying supply transaction fails.
  */
-declare function useSupply(spokeToken: XToken, spokeProvider: SpokeProvider | undefined): UseMutationResult<SupplyResponse, Error, string>;
+declare function useSupply(): UseMutationResult<SupplyResponse, MoneyMarketError<'CREATE_SUPPLY_INTENT_FAILED' | 'SUPPLY_UNKNOWN_ERROR' | RelayErrorCode>, UseSupplyParams>;
 
+type UseWithdrawParams = {
+    params: MoneyMarketWithdrawParams;
+    spokeProvider: SpokeProvider;
+};
 interface WithdrawResponse {
     ok: true;
     value: [string, string];
 }
 /**
- * Hook for withdrawing supplied tokens from the Sodax money market.
+ * Hook for performing withdrawals 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.
+ * This hook exposes a mutation that executes the complete withdrawal logic, including transaction
+ * creation and handling cross-chain communication. It leverages React Query's mutation API for
+ * easy asynchronous handling and status tracking within UI components.
  *
- * @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, MoneyMarketError<'CREATE_WITHDRAW_INTENT_FAILED' | 'WITHDRAW_UNKNOWN_ERROR' | RelayErrorCode>, UseWithdrawParams>}
+ *   Mutation result object, with:
+ *   - mutateAsync: (params: UseWithdrawParams) => Promise<WithdrawResponse>
+ *       Initiates the withdrawal using the provided params.
+ *   - isPending: boolean indicating if a transaction is in progress.
+ *   - error: MoneyMarketError if an error occurred while withdrawing, otherwise undefined.
  *
- * @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');
+ * const { mutateAsync: withdraw, isPending, error } = useWithdraw();
+ * await withdraw({ params: withdrawParams, spokeProvider });
  * ```
  *
  * @throws {Error} When:
- *   - spokeProvider is not available
- *   - Transaction execution fails
+ *   - spokeProvider is not provided or invalid.
+ *   - Underlying withdrawal logic fails.
  */
-declare function useWithdraw(spokeToken: XToken, spokeProvider: SpokeProvider | undefined): UseMutationResult<WithdrawResponse, Error, string>;
+declare function useWithdraw(): UseMutationResult<WithdrawResponse, MoneyMarketError<'CREATE_WITHDRAW_INTENT_FAILED' | 'WITHDRAW_UNKNOWN_ERROR' | RelayErrorCode>, UseWithdrawParams>;
 
+type UseUserReservesDataParams = {
+    spokeProvider: SpokeProvider | undefined;
+    address: string | undefined;
+    queryOptions?: UseQueryOptions<readonly [readonly UserReserveData[], number], Error>;
+};
 /**
  * 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.
+ * @param params (optional) - Object including:
+ *   - spokeProvider: The SpokeProvider instance required for data fetching. If not provided, data fetching is disabled.
+ *   - address: The user's address (string) whose reserves data will be fetched. If not provided, data fetching is disabled.
+ *   - queryOptions: (optional) Custom React Query options such as `queryKey`, `enabled`, or cache policy.
  *
- * @example
- * ```typescript
- * const { data: userReservesData, isLoading, error } = useUserReservesData(spokeProvider, address);
- * ```
+ * @returns {UseQueryResult<readonly [readonly UserReserveData[], number], Error>} React Query result object containing:
+ *   - data: A tuple with array of UserReserveData and associated number, or undefined if loading
+ *   - isLoading: Boolean loading state
+ *   - isError: Boolean error state
+ *   - error: Error object, if present
  *
- * @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
+ * @example
+ * const { data: userReservesData, isLoading, error } = useUserReservesData({
+ *   spokeProvider,
+ *   address,
+ * });
  */
-declare function useUserReservesData(spokeProvider: SpokeProvider | undefined, address: string | undefined, refetchInterval?: number): UseQueryResult<readonly [readonly UserReserveData[], number], Error>;
+declare function useUserReservesData(params?: UseUserReservesDataParams): UseQueryResult<readonly [readonly UserReserveData[], number], Error>;
 
+type UseReservesDataParams = {
+    queryOptions?: UseQueryOptions<readonly [readonly AggregatedReserveData[], BaseCurrencyInfo], Error>;
+};
 /**
- * Hook for fetching reserves data from the Sodax money market.
+ * React hook for fetching the latest 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.
+ * Provides the full set of aggregated reserves and base currency information.
+ * Optionally accepts React Query options for customizing the query key, cache time, and related behaviors.
  *
- * @example
- * ```typescript
- * const { data: reservesData, isLoading, error } = useReservesData();
- * ```
+ * @param params (optional) - Object including:
+ *   - queryOptions: Custom React Query options
  *
- * @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
+ * @returns {UseQueryResult<readonly [readonly AggregatedReserveData[], BaseCurrencyInfo], Error>}
+ *   React Query result object containing:
+ *     - data: [aggregated reserves[], base currency info], or undefined if not loaded
+ *     - isLoading: True if the request is loading
+ *     - isError: True if the request failed
+ *     - error: Error object, if present
+ *
+ * @example
+ * const { data, isLoading, error } = useReservesData();
+ * const { data } = useReservesData({ queryOptions: { queryKey: ['custom', 'reservesData'] } });
  */
-declare function useReservesData(): _tanstack_react_query.UseQueryResult<readonly [readonly _sodax_sdk.AggregatedReserveData[], _sodax_sdk.BaseCurrencyInfo], Error>;
+declare function useReservesData(params?: UseReservesDataParams): UseQueryResult<readonly [readonly AggregatedReserveData[], BaseCurrencyInfo], Error>;
 
+type UseMMAllowanceParams = {
+    params: MoneyMarketParams | undefined;
+    spokeProvider: SpokeProvider | undefined;
+    queryOptions?: UseQueryOptions<boolean, Error>;
+};
 /**
  * Hook for checking token allowance for money market operations.
  *
@@ -331,77 +365,125 @@ declare function useReservesData(): _tanstack_react_query.UseQueryResult<readonl
  * const { data: hasAllowed, isLoading } = useMMAllowance(token, "100", "repay", provider);
  * ```
  */
-declare function useMMAllowance(token: XToken, amount: string, action: MoneyMarketAction, spokeProvider: SpokeProvider | undefined): UseQueryResult<boolean, Error>;
+declare function useMMAllowance({ params, spokeProvider, queryOptions, }: UseMMAllowanceParams): UseQueryResult<boolean, Error>;
 
-interface UseApproveReturn$2 {
-    approve: ({ amount, action }: {
-        amount: string;
-        action: MoneyMarketAction;
-    }) => Promise<boolean>;
-    isLoading: boolean;
-    error: Error | null;
-    resetError: () => void;
-}
+type UseMMApproveParams = {
+    params: MoneyMarketParams;
+    spokeProvider: SpokeProvider | undefined;
+};
 /**
- * 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
+ * Hook for approving ERC20 token spending for Sodax money market actions.
+ *
+ * This hook manages the approval transaction, allowing the user
+ * to grant the protocol permission to spend their tokens for specific money market actions
+ * (such as supply, borrow, or repay). Upon successful approval, it also invalidates and
+ * refetches the associated allowance status so the UI remains up-to-date.
+ *
+ * @returns {UseMutationResult<string, Error, UseMMApproveParams>} A React Query mutation result containing:
+ *   - mutateAsync: Function to trigger the approval (see below)
+ *   - isPending: Boolean indicating if approval transaction is in progress
+ *   - error: Error object if the last approval failed, null otherwise
+ *
  * @example
  * ```tsx
- * const { approve, isLoading, error } = useMMApprove(token, spokeProvider);
- *
- * // Approve tokens for supply action
- * await approve({ amount: "100", action: "supply" });
+ * const { mutateAsync: approve, isPending, error } = useMMApprove();
+ * await approve({ params: { token, amount: "100", action: "supply", ... }, spokeProvider });
  * ```
+ *
+ * @throws {Error} When:
+ *   - spokeProvider is undefined or invalid
+ *   - Approval transaction fails for any reason
  */
-declare function useMMApprove(token: XToken, spokeProvider: SpokeProvider | undefined): UseApproveReturn$2;
+declare function useMMApprove(): UseMutationResult<string, Error, UseMMApproveParams>;
 
+type UseATokenParams = {
+    aToken: string;
+    queryOptions?: UseQueryOptions<XToken, Error>;
+};
 /**
- * React hook for fetching an AToken's ERC20 metadata from the Sodax money market.
+ * React hook to fetch and cache metadata for a given aToken address.
  *
- * Fetches and caches the metadata (name, symbol, decimals, address) for a given aToken address and chain using React Query.
- * This metadata is typically required for rendering balances and labels in UI components.
+ * Accepts an aToken address and React Query options to control query behavior.
+ * Returns the aToken's ERC20-style metadata from the Sodax money market, with querying/caching
+ * powered by React Query.
  *
- * @param {Address | undefined} aToken - The aToken contract address to look up. Should be an EVM address.
- * @param {ChainId | undefined} chainId - The EVM chain ID for the aToken.
+ * @param {UseATokenParams} params - Required params object:
+ *   @property {Address} aToken - The aToken contract address to query.
+ *   @property {UseQueryOptions<XToken, Error>} queryOptions - React Query options to control query (e.g., staleTime, refetch, etc.).
+ *
+ * @returns {UseQueryResult<XToken, Error>} React Query result object:
+ *   - data: XToken metadata, if available
+ *   - isLoading: Boolean loading state
+ *   - error: Error, if API call fails
  *
  * @example
- * ```typescript
- * const { data: aToken, isLoading, error } = useAToken(aTokenAddress, chainId);
- * if (aToken) {
- *   console.log(aToken.symbol); // 'aETH'
+ * const { data: xToken, isLoading, error } = useAToken({ aToken: aTokenAddress, queryOptions: {} });
+ * if (xToken) {
+ *   console.log(xToken.symbol);
  * }
- * ```
- *
- * @returns {UseQueryResult<Erc20Token, Error>} A React Query result object containing:
- *   - data: The aToken ERC20 metadata when available.
- *   - isLoading: Loading state indicator.
- *   - error: Any error that occurred during data fetching.
  */
-declare function useAToken(aToken: Address$1 | undefined): UseQueryResult<XToken$1, Error>;
+declare function useAToken({ aToken, queryOptions }: UseATokenParams): UseQueryResult<XToken, Error>;
 
+type UseReservesUsdFormatParams = {
+    queryOptions?: UseQueryOptions<(ReserveData & {
+        priceInMarketReferenceCurrency: string;
+    } & FormatReserveUSDResponse)[], Error>;
+};
 /**
- * Hook for fetching formatted summary of Sodax user portfolio (holdings, total liquidity,
- *  collateral, borrows, liquidation threshold, health factor, available borrowing power, etc..).
+ * Hook for fetching reserves data formatted with USD values in the Sodax money market.
  *
- * This hook provides access to the current state of user portfolio in the money market protocol.
- * The data is automatically fetched and cached using React Query.
+ * This hook returns an array of reserve objects, each extended with its price in the market reference
+ * currency and formatted USD values. Data is automatically fetched and cached using React Query.
  *
- * @example
- * ```typescript
- * const { data: userFormattedSummary, isLoading, error } = useUserFormattedSummary();
- * ```
+ * @param params (optional) - Object including:
+ *   - queryOptions: Custom React Query options such as `queryKey`, cache behavior, or refetching policy.
  *
- * @returns A React Query result object containing:
- *   - data: The formatted summary of Sodax user portfolio when available
- *   - isLoading: Loading state indicator
- *   - error: Any error that occurred during data fetching
+ * @returns {UseQueryResult<(ReserveData & { priceInMarketReferenceCurrency: string } & FormatReserveUSDResponse)[], Error>} React Query result object containing:
+ *   - data: Array of reserves with USD-formatted values, or undefined if loading
+ *   - isLoading: Boolean loading state
+ *   - isError: Boolean error state
+ *   - error: Error object, if present
+ *
+ * @example
+ * const { data: reservesUSD, isLoading, error } = useReservesUsdFormat();
  */
-declare function useReservesUsdFormat(): UseQueryResult<(ReserveData & {
+declare function useReservesUsdFormat(params?: UseReservesUsdFormatParams): UseQueryResult<(ReserveData & {
     priceInMarketReferenceCurrency: string;
 } & FormatReserveUSDResponse)[], Error>;
 
+type UseUserFormattedSummaryParams = {
+    spokeProvider?: SpokeProvider;
+    address?: string;
+    queryOptions?: UseQueryOptions<FormatUserSummaryResponse<FormatReserveUSDResponse>, Error>;
+};
+/**
+ * React hook to fetch a formatted summary of a user's Sodax money market portfolio.
+ *
+ * Accepts an optional params object:
+ *   - `spokeProvider`: The SpokeProvider instance for the target chain
+ *   - `address`: The user wallet address to get the summary for
+ *   - `queryOptions`: Optional React Query options (key, caching, intervals, etc)
+ *
+ * The hook returns a React Query result object containing the formatted summary, loading and error state.
+ * The query is enabled only if both the spokeProvider and address are provided.
+ *
+ * @param params Optional parameters:
+ *   - spokeProvider: SpokeProvider to query chain data (required for enabled query)
+ *   - address: User account address (required for enabled query)
+ *   - queryOptions: React Query options for customization (optional)
+ *
+ * @returns {UseQueryResult<FormatUserSummaryResponse<FormatReserveUSDResponse>, Error>}
+ *   A result object from React Query including:
+ *     - data: The user's formatted portfolio summary (or undefined if not loaded)
+ *     - isLoading: Boolean loading state
+ *     - isError: Boolean error state
+ *     - error: Error if thrown in fetching
+ *
+ * @example
+ * const { data, isLoading, error } = useUserFormattedSummary({ spokeProvider, address });
+ */
+declare function useUserFormattedSummary(params?: UseUserFormattedSummaryParams): UseQueryResult<FormatUserSummaryResponse<FormatReserveUSDResponse>, Error>;
+
 /**
  * Hook for fetching a quote for an intent-based swap.
  *
@@ -495,12 +577,12 @@ declare function useSwap(spokeProvider: SpokeProvider | undefined): UseMutationR
 declare const useStatus: (intent_tx_hash: Hex) => UseQueryResult<Result<SolverIntentStatusResponse, SolverErrorResponse> | undefined>;
 
 /**
- * Hook for checking token allowance for money market operations.
+ * Hook for checking token allowance for swap 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.
+ * This hook verifies if the user has approved enough tokens for a specific swap action.
+ * It automatically queries and tracks the allowance status.
  *
- * @param {CreateIntentParams} params - The parameters for the intent to check allowance for.
+ * @param {CreateIntentParams | CreateLimitOrderParams} 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:
@@ -510,22 +592,22 @@ declare const useStatus: (intent_tx_hash: Hex) => UseQueryResult<Result<SolverIn
  *
  * @example
  * ```typescript
- * const { data: hasAllowed, isLoading } = useMMAllowance(params, spokeProvider);
+ * const { data: hasAllowed, isLoading } = useSwapAllowance(params, spokeProvider);
  * ```
  */
-declare function useSwapAllowance(params: CreateIntentParams | undefined, spokeProvider: SpokeProvider | undefined): UseQueryResult<boolean, Error>;
+declare function useSwapAllowance(params: CreateIntentParams | CreateLimitOrderParams | undefined, spokeProvider: SpokeProvider | undefined): UseQueryResult<boolean, Error>;
 
 interface UseApproveReturn$1 {
     approve: ({ params }: {
-        params: CreateIntentParams;
+        params: CreateIntentParams | CreateLimitOrderParams;
     }) => 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
+ * Hook for approving token spending for swap actions
+ * @param params The parameters for the intent 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
@@ -536,7 +618,7 @@ interface UseApproveReturn$1 {
  * await approve({ amount: "100", action: "supply" });
  * ```
  */
-declare function useSwapApprove(params: CreateIntentParams | undefined, spokeProvider: SpokeProvider | undefined): UseApproveReturn$1;
+declare function useSwapApprove(params: CreateIntentParams | CreateLimitOrderParams | undefined, spokeProvider: SpokeProvider | undefined): UseApproveReturn$1;
 
 type CancelIntentParams = {
     intent: Intent;
@@ -564,169 +646,284 @@ type CancelIntentResult = Result<TxReturnType<SpokeProvider, boolean>>;
  */
 declare function useCancelSwap(spokeProvider: SpokeProvider | undefined): UseMutationResult<CancelIntentResult, Error, CancelIntentParams>;
 
+type CreateLimitOrderResult = Result<[
+    SolverExecutionResponse,
+    Intent,
+    IntentDeliveryInfo
+], IntentError<IntentErrorCode>>;
 /**
- * Hook for fetching intent details by intent created transaction hash from the backend API.
- *
- * This hook provides access to intent data associated with the transaction hash from when
- * the intent was created on the hub chain, including intent details, events, and transaction
- * information. The data is automatically fetched and cached using React Query.
+ * Hook for creating a limit order intent (no deadline, must be cancelled manually by user).
+ * Uses React Query's useMutation for better state management and caching.
  *
- * @param {string | undefined} txHash - The intent created transaction hash from the hub chain to fetch intent for. If undefined, the query will be disabled.
+ * Limit orders remain active until manually cancelled by the user. Unlike swaps, limit orders
+ * do not have a deadline (deadline is automatically set to 0n).
  *
- * @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
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for creating the limit order
+ * @returns {UseMutationResult} Mutation result object containing mutation function and state
  *
  * @example
  * ```typescript
- * const { data: intent, isLoading, error } = useIntentByTxHash('0x123...');
+ * const { mutateAsync: createLimitOrder, isPending } = useCreateLimitOrder(spokeProvider);
+ *
+ * const handleCreateLimitOrder = async () => {
+ *   const result = await createLimitOrder({
+ *     inputToken: '0x...',
+ *     outputToken: '0x...',
+ *     inputAmount: 1000000000000000000n,
+ *     minOutputAmount: 900000000000000000n,
+ *     allowPartialFill: false,
+ *     srcChain: '0xa4b1.arbitrum',
+ *     dstChain: '0x89.polygon',
+ *     srcAddress: '0x...',
+ *     dstAddress: '0x...',
+ *     solver: '0x0000000000000000000000000000000000000000',
+ *     data: '0x'
+ *   });
  *
- * if (isLoading) return <div>Loading intent...</div>;
- * if (error) return <div>Error: {error.message}</div>;
- * if (intent) {
- *   console.log('Intent found:', intent.intentHash);
- * }
+ *   if (result.ok) {
+ *     const [solverExecutionResponse, intent, intentDeliveryInfo] = result.value;
+ *     console.log('Limit order created:', intent);
+ *     console.log('Intent hash:', solverExecutionResponse.intent_hash);
+ *   }
+ * };
  * ```
- *
- * @remarks
- * - Intents are only created on the hub chain, so the transaction hash must be from the hub chain
- * - 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, refetchInterval?: number) => UseQueryResult<IntentResponse | undefined>;
+declare function useCreateLimitOrder(spokeProvider: SpokeProvider | undefined): UseMutationResult<CreateLimitOrderResult, Error, CreateLimitOrderParams>;
 
+type CancelLimitOrderParams = {
+    intent: Intent;
+    spokeProvider: SpokeProvider;
+    timeout?: number;
+};
+type CancelLimitOrderResult = Result<[string, string], IntentError<IntentErrorCode>>;
 /**
- * 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.
+ * Hook for canceling a limit order intent and submitting it to the Relayer API.
+ * Uses React Query's useMutation for better state management and caching.
  *
- * @param {string | undefined} intentHash - The intent hash to fetch intent for. If undefined, the query will be disabled.
+ * This hook wraps cancelLimitOrder which cancels the intent on the spoke chain,
+ * submits it to the relayer API, and waits for execution on the destination/hub chain.
  *
- * @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
+ * @returns {UseMutationResult} Mutation result object containing mutation function and state
  *
  * @example
  * ```typescript
- * const { data: intent, isLoading, error } = useIntentByHash('0xabc...');
+ * const { mutateAsync: cancelLimitOrder, isPending } = useCancelLimitOrder();
+ *
+ * const handleCancelLimitOrder = async () => {
+ *   const result = await cancelLimitOrder({
+ *     intent: intentObject,
+ *     spokeProvider,
+ *     timeout: 60000 // optional, defaults to 60 seconds
+ *   });
+ *
+ *   if (result.ok) {
+ *     const [cancelTxHash, dstTxHash] = result.value;
+ *     console.log('Cancel transaction hash:', cancelTxHash);
+ *     console.log('Destination transaction hash:', dstTxHash);
+ *   }
+ * };
+ * ```
+ */
+declare function useCancelLimitOrder(): UseMutationResult<CancelLimitOrderResult, Error, CancelLimitOrderParams>;
+
+type UseBackendIntentByTxHashParams = {
+    params: {
+        txHash: string | undefined;
+    };
+    queryOptions?: UseQueryOptions<IntentResponse | undefined, Error>;
+};
+/**
+ * React hook for fetching intent details from the backend API using a transaction hash.
+ *
+ * @param {UseBackendIntentByTxHashParams | undefined} params - Parameters for the query:
+ *   - params: { txHash: string | undefined }
+ *       - `txHash`: Transaction hash used to retrieve the associated intent; query is disabled if undefined or empty.
+ *   - queryOptions (optional): React Query options to customize request behavior (e.g., caching, retry, refetchInterval, etc.).
+ *
+ * @returns {UseQueryResult<IntentResponse | undefined, Error>} React Query result object, including:
+ *   - `data`: The intent response or undefined if unavailable,
+ *   - `isLoading`: Loading state,
+ *   - `error`: Error (if request failed),
+ *   - `refetch`: Function to refetch the data.
+ *
+ * @example
+ * const { data: intent, isLoading, error } = useBackendIntentByTxHash({
+ *   params: { txHash: '0x123...' },
+ * });
  *
  * 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
+ * - Intents are only created on the hub chain, so `txHash` must originate from there.
+ * - Query is disabled if `params` is undefined, or if `params.params.txHash` is undefined or an empty string.
+ * - Default refetch interval is 1 second. Uses React Query for state management, caching, and retries.
  */
-declare const useBackendIntentByHash: (intentHash: string | undefined) => UseQueryResult<IntentResponse | undefined>;
+declare const useBackendIntentByTxHash: (params: UseBackendIntentByTxHashParams | undefined) => UseQueryResult<IntentResponse | undefined, Error>;
 
+type UseBackendIntentByHashParams = {
+    params: {
+        intentHash: string | undefined;
+    };
+    queryOptions?: UseQueryOptions<IntentResponse | undefined, Error>;
+};
 /**
- * Hook for fetching the solver orderbook from the backend API.
+ * React hook to fetch intent details from the backend API using an intent hash.
  *
- * 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 {UseBackendIntentByHashParams | undefined} params - Parameters for the query:
+ *   - params: { intentHash: string | undefined }
+ *     - `intentHash`: The hash identifying the intent to fetch (disables query if undefined or empty).
+ *   - queryOptions (optional): Options to customize React Query (e.g., staleTime, enabled).
  *
- * @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
+ * @returns {UseQueryResult<IntentResponse | undefined, Error>} React Query result containing intent response data, loading, error, and refetch states.
  *
  * @example
- * ```typescript
- * const { data: orderbook, isLoading, error } = useOrderbook({
- *   offset: '0',
- *   limit: '10'
+ * const { data: intent, isLoading, error } = useBackendIntentByHash({
+ *   params: { intentHash: '0xabc...' },
  * });
  *
- * if (isLoading) return <div>Loading orderbook...</div>;
+ * if (isLoading) return <div>Loading intent...</div>;
  * if (error) return <div>Error: {error.message}</div>;
- * if (orderbook) {
- *   console.log('Total intents:', orderbook.total);
- *   console.log('Intents:', orderbook.data);
+ * if (intent) {
+ *   console.log('Intent found:', intent.intentHash);
  * }
- * ```
  *
  * @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
+ * - Returns `undefined` data if no intentHash is provided or query is disabled.
+ * - Query is cached and managed using React Query.
+ * - Use `queryOptions` to customize caching, retry and fetch behavior.
  */
-declare const useBackendOrderbook: (params: {
+declare const useBackendIntentByHash: (params: UseBackendIntentByHashParams | undefined) => UseQueryResult<IntentResponse | undefined, Error>;
+
+type BackendPaginationParams = {
     offset: string;
     limit: string;
-} | undefined) => UseQueryResult<OrderbookResponse | undefined>;
+};
 
+type GetUserIntentsParams = {
+    userAddress: Address$1;
+    startDate?: number;
+    endDate?: number;
+};
+type UseBackendUserIntentsParams = {
+    params?: GetUserIntentsParams;
+    queryOptions?: UseQueryOptions<UserIntentsResponse | undefined, Error>;
+    pagination?: BackendPaginationParams;
+};
 /**
- * Hook for fetching money market position for a specific user from the backend API.
+ * React hook for fetching user-created intents from the backend API for a given user address,
+ * with optional support for a date filtering range.
+ *
+ * @param {UseBackendUserIntentsParams} args - Query configuration.
+ *   @param {GetUserIntentsParams | undefined} args.params - User intent filter parameters.
+ *     @param {Address} args.params.userAddress - The wallet address of the user (required).
+ *     @param {number} [args.params.startDate] - Include intents created after this timestamp (ms).
+ *     @param {number} [args.params.endDate] - Include intents created before this timestamp (ms).
+ *   @param {UseQueryOptions<UserIntentsResponse | undefined, Error>} [args.queryOptions] - Optional React Query options.
+ *   @param {BackendPaginationParams} [args.pagination] - (currently ignored) Pagination options.
+ *
+ * @returns {UseQueryResult<UserIntentsResponse | undefined, Error>} React Query result:
+ *   - `data`: The user intent response, or undefined if unavailable.
+ *   - `isLoading`: `true` if loading.
+ *   - `error`: An Error instance if any occurred.
+ *   - `refetch`: Function to refetch data.
  *
- * 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.
+ * @example
+ * const { data: userIntents, isLoading, error } = useBackendUserIntents({
+ *   params: { userAddress: "0x123..." }
+ * });
  *
- * @param {string | undefined} userAddress - The user's wallet address. If undefined, the query will be disabled.
+ * @example
+ * const { data } = useBackendUserIntents({
+ *   params: {
+ *     userAddress: "0xabc...",
+ *     startDate: Date.now() - 1_000_000,
+ *     endDate: Date.now(),
+ *   },
+ * });
  *
- * @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
+ * @remarks
+ * The query is disabled if `params` or `params.userAddress` is missing or empty. Uses React Query for
+ * cache/state management and auto-retries failed requests three times by default.
+ */
+declare const useBackendUserIntents: ({ params, queryOptions, }: UseBackendUserIntentsParams) => UseQueryResult<UserIntentsResponse | undefined, Error>;
+
+type UseBackendOrderbookParams = {
+    queryOptions?: UseQueryOptions<OrderbookResponse | undefined, Error>;
+    pagination?: BackendPaginationParams;
+};
+/**
+ * Hook for fetching the solver orderbook from the backend API.
  *
- * @example
- * ```typescript
- * const { data: position, isLoading, error } = useMoneyMarketPosition('0x123...');
+ * @param {UseBackendOrderbookParams | undefined} params - Optional parameters:
+ *   - `pagination`: Pagination configuration (see `BackendPaginationParams`), including
+ *      `offset` and `limit` (both required for fetch to be enabled).
+ *   - `queryOptions`: Optional React Query options to override default behavior.
  *
- * 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);
- * }
- * ```
+ * @returns {UseQueryResult<OrderbookResponse | undefined, Error>} React Query result object:
+ *   - `data`: The orderbook response, or undefined if unavailable.
+ *   - `isLoading`: Loading state.
+ *   - `error`: Error instance if the query failed.
+ *   - `refetch`: Function to re-trigger the query.
+ *
+ * @example
+ * const { data, isLoading, error } = useBackendOrderbook({
+ *   pagination: { offset: '0', limit: '10' },
+ *   queryOptions: { staleTime: 60000 },
+ * });
  *
  * @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
+ * - Query is disabled if `params?.pagination`, `offset`, or `limit` are missing/empty.
+ * - Caches and manages server state using React Query.
+ * - Default `staleTime` is 30 seconds to support near-real-time updates.
  */
-declare const useBackendMoneyMarketPosition: (userAddress: string | undefined) => UseQueryResult<MoneyMarketPosition | undefined>;
+declare const useBackendOrderbook: (params: UseBackendOrderbookParams | undefined) => UseQueryResult<OrderbookResponse | undefined>;
 
+type UseBackendMoneyMarketPositionParams = {
+    userAddress: string | undefined;
+    queryOptions?: UseQueryOptions<MoneyMarketPosition | undefined, Error>;
+};
 /**
- * Hook for fetching all money market assets from the backend API.
+ * React hook for fetching a user's money market position 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.
+ * @param {UseBackendMoneyMarketPositionParams | undefined} params - Parameters object:
+ *   - userAddress: The user's wallet address to fetch positions for. If undefined or empty, the query is disabled.
+ *   - queryOptions: (Optional) React Query options to customize behavior (e.g., staleTime, enabled).
  *
- * @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
+ * @returns {UseQueryResult<MoneyMarketPosition | undefined, Error>} - React Query result object with:
+ *   - data: The user's money market position data, or undefined if not available.
+ *   - isLoading: Loading state.
+ *   - error: An Error instance if fetching failed.
+ *   - refetch: Function to manually trigger a refetch.
  *
  * @example
- * ```typescript
- * const { data: assets, isLoading, error } = useAllMoneyMarketAssets();
+ * const { data, isLoading, error } = useBackendMoneyMarketPosition({
+ *   userAddress: '0xabc...',
+ *   queryOptions: { staleTime: 60000 },
+ * });
+ */
+declare const useBackendMoneyMarketPosition: (params: UseBackendMoneyMarketPositionParams | undefined) => UseQueryResult<MoneyMarketPosition | undefined, Error>;
+
+type UseBackendAllMoneyMarketAssetsParams = {
+    queryOptions?: UseQueryOptions<MoneyMarketAsset[], Error>;
+};
+/**
+ * React hook to fetch all money market assets from the backend API.
+ *
+ * @param {UseBackendAllMoneyMarketAssetsParams | undefined} params - Optional parameters:
+ *   - `queryOptions` (optional): React Query options to override default behavior (e.g., caching, retry, etc).
+ *
+ * @returns {UseQueryResult<MoneyMarketAsset[], Error>} React Query result object:
+ *   - `data`: Array of all 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
+ * const { data: assets, isLoading, error } = useBackendAllMoneyMarketAssets();
  *
  * if (isLoading) return <div>Loading assets...</div>;
  * if (error) return <div>Error: {error.message}</div>;
@@ -736,35 +933,39 @@ declare const useBackendMoneyMarketPosition: (userAddress: string | undefined) =
  *     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
+ * - No required parameters — fetches all available money market assets from backend.
+ * - Uses React Query for caching, retries, and loading/error state management.
+ * - Supports overriding React Query config via `queryOptions`.
  */
-declare const useBackendAllMoneyMarketAssets: () => UseQueryResult<MoneyMarketAsset[]>;
+declare const useBackendAllMoneyMarketAssets: (params: UseBackendAllMoneyMarketAssetsParams | undefined) => UseQueryResult<MoneyMarketAsset[], Error>;
 
+type UseBackendMoneyMarketAssetParams = {
+    params: {
+        reserveAddress: string | undefined;
+    };
+    queryOptions?: UseQueryOptions<MoneyMarketAsset | undefined, Error>;
+};
 /**
- * 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.
+ * React hook to fetch a specific money market asset from the backend API.
  *
- * @param {string | undefined} reserveAddress - The reserve contract address. If undefined, the query will be disabled.
+ * @param params - The hook input parameter object (may be undefined):
+ *   - `params`: An object containing:
+ *       - `reserveAddress` (string | undefined): Reserve contract address to fetch asset details. Disables query if undefined or empty.
+ *   - `queryOptions` (optional): React Query options for advanced configuration (e.g. caching, staleTime, retry, etc.).
  *
- * @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
+ * @returns A React Query result object: {@link UseQueryResult} for {@link MoneyMarketAsset} or `undefined` on error or if disabled,
+ *   including:
+ *   - `data`: The money market asset (when available) or `undefined`.
+ *   - `isLoading`: Whether the query is running.
+ *   - `error`: An error encountered by the query (if any).
+ *   - `refetch`: Function to manually refetch the asset.
  *
  * @example
- * ```typescript
- * const { data: asset, isLoading, error } = useMoneyMarketAsset('0xabc...');
- *
+ * const { data: asset, isLoading, error } = useBackendMoneyMarketAsset({
+ *   params: { reserveAddress: '0xabc...' },
+ * });
  * if (isLoading) return <div>Loading asset...</div>;
  * if (error) return <div>Error: {error.message}</div>;
  * if (asset) {
@@ -772,39 +973,40 @@ declare const useBackendAllMoneyMarketAssets: () => UseQueryResult<MoneyMarketAs
  *   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
+ * - Query is disabled if `params`, `params.params`, or `params.params.reserveAddress` is missing or empty.
+ * - Uses React Query for caching and background-state management.
+ * - Loading and error handling are managed automatically.
  */
-declare const useBackendMoneyMarketAsset: (reserveAddress: string | undefined) => UseQueryResult<MoneyMarketAsset | undefined>;
+declare const useBackendMoneyMarketAsset: (params: UseBackendMoneyMarketAssetParams | undefined) => UseQueryResult<MoneyMarketAsset | undefined, Error>;
 
+type UseBackendMoneyMarketAssetBorrowersParams = {
+    params: {
+        reserveAddress: string | undefined;
+    };
+    pagination: BackendPaginationParams;
+    queryOptions?: UseQueryOptions<MoneyMarketAssetBorrowers | undefined, Error>;
+};
 /**
- * Hook for fetching borrowers for a specific money market asset from the backend API.
+ * React hook for fetching borrowers for a specific money market asset from the backend API with pagination.
  *
- * 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)
+ * @param {UseBackendMoneyMarketAssetBorrowersParams | undefined} params - Query parameters:
+ *   - `params`: Object containing:
+ *       - `reserveAddress`: Reserve contract address for which to fetch borrowers, or `undefined` to disable query.
+ *   - `pagination`: Pagination controls with `offset` and `limit` (both required as strings).
+ *   - `queryOptions` (optional): React Query options to override defaults (e.g. `staleTime`, `enabled`, etc.).
  *
- * @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
+ * @returns {UseQueryResult<MoneyMarketAssetBorrowers | undefined, Error>} React Query result object including:
+ *   - `data`: The money market asset borrowers data, or `undefined` if not available.
+ *   - `isLoading`: Boolean indicating whether the query is loading.
+ *   - `error`: An Error instance 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'
+ * const { data: borrowers, isLoading, error } = useBackendMoneyMarketAssetBorrowers({
+ *   params: { reserveAddress: '0xabc...' },
+ *   pagination: { offset: '0', limit: '20' }
  * });
  *
  * if (isLoading) return <div>Loading borrowers...</div>;
@@ -813,43 +1015,40 @@ declare const useBackendMoneyMarketAsset: (reserveAddress: string | undefined) =
  *   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
+ * - The query is disabled if `reserveAddress`, `offset`, or `limit` are not provided.
+ * - Uses React Query for caching, retries, and auto error/loading management.
+ * - Pagination is handled via `pagination.offset` and `pagination.limit`.
  */
-declare const useBackendMoneyMarketAssetBorrowers: (params: {
-    reserveAddress: string | undefined;
-    offset: string;
-    limit: string;
-}) => UseQueryResult<MoneyMarketAssetBorrowers | undefined>;
+declare const useBackendMoneyMarketAssetBorrowers: (params: UseBackendMoneyMarketAssetBorrowersParams | undefined) => UseQueryResult<MoneyMarketAssetBorrowers | undefined, Error>;
 
+type UseBackendMoneyMarketAssetSuppliersParams = {
+    params: {
+        reserveAddress: string | undefined;
+    };
+    pagination: BackendPaginationParams;
+    queryOptions?: UseQueryOptions<MoneyMarketAssetSuppliers | undefined, Error>;
+};
 /**
- * Hook for fetching suppliers for a specific money market asset from the backend API.
+ * React hook for fetching suppliers for a specific money market asset from the backend API, with pagination support.
  *
- * 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 {UseBackendMoneyMarketAssetSuppliersParams | undefined} params - Hook parameters:
+ *   - `params`: Object containing:
+ *       - `reserveAddress`: The reserve contract address to query, or undefined to disable the query.
+ *   - `pagination`: Backend pagination controls (`offset` and `limit` as strings).
+ *   - `queryOptions` (optional): React Query options to override defaults.
  *
- * @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
+ * @returns {UseQueryResult<MoneyMarketAssetSuppliers | undefined, Error>} - Query result object with:
+ *   - `data`: The asset suppliers data when available.
+ *   - `isLoading`: Indicates if the request is in progress.
+ *   - `error`: Error object if the request failed.
+ *   - `refetch`: Function to trigger a manual data refresh.
  *
  * @example
- * ```typescript
- * const { data: suppliers, isLoading, error } = useMoneyMarketAssetSuppliers({
- *   reserveAddress: '0xabc...',
- *   offset: '0',
- *   limit: '20'
+ * const { data: suppliers, isLoading, error } = useBackendMoneyMarketAssetSuppliers({
+ *   params: { reserveAddress: '0xabc...' },
+ *   pagination: { offset: '0', limit: '20' }
  * });
  *
  * if (isLoading) return <div>Loading suppliers...</div>;
@@ -858,20 +1057,18 @@ declare const useBackendMoneyMarketAssetBorrowers: (params: {
  *   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
+ * - The query is disabled if `reserveAddress`, `offset`, or `limit` are not provided.
+ * - Uses React Query for efficient caching, automatic retries, and error/loading handling.
+ * - Pagination is handled via `pagination.offset` and `pagination.limit`.
  */
-declare const useBackendMoneyMarketAssetSuppliers: (params: {
-    reserveAddress: string | undefined;
-    offset: string;
-    limit: string;
-}) => UseQueryResult<MoneyMarketAssetSuppliers | undefined>;
+declare const useBackendMoneyMarketAssetSuppliers: (params: UseBackendMoneyMarketAssetSuppliersParams | undefined) => UseQueryResult<MoneyMarketAssetSuppliers | undefined, Error>;
 
+type UseBackendAllMoneyMarketBorrowersParams = {
+    pagination: BackendPaginationParams;
+    queryOptions?: UseQueryOptions<MoneyMarketBorrowers | undefined, Error>;
+};
 /**
  * Hook for fetching all money market borrowers from the backend API.
  *
@@ -910,10 +1107,7 @@ declare const useBackendMoneyMarketAssetSuppliers: (params: {
  * - 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>;
+declare const useBackendAllMoneyMarketBorrowers: (params: UseBackendAllMoneyMarketBorrowersParams | undefined) => UseQueryResult<MoneyMarketBorrowers | undefined>;
 
 /**
  * Hook for checking token allowance for bridge operations.
@@ -1015,7 +1209,7 @@ declare function useBridge(spokeProvider: SpokeProvider | undefined): UseMutatio
  * }
  * ```
  */
-declare function useGetBridgeableAmount(from: XToken$1 | undefined, to: XToken$1 | undefined): UseQueryResult<bigint, Error>;
+declare function useGetBridgeableAmount(from: XToken | undefined, to: XToken | undefined): UseQueryResult<bigint, Error>;
 
 /**
 /**
@@ -1050,7 +1244,7 @@ declare function useGetBridgeableAmount(from: XToken$1 | undefined, to: XToken$1
  * }
  * ```
  */
-declare function useGetBridgeableTokens(from: SpokeChainId | undefined, to: SpokeChainId | undefined, token: string | undefined): UseQueryResult<XToken$1[], Error>;
+declare function useGetBridgeableTokens(from: SpokeChainId | undefined, to: SpokeChainId | undefined, token: string | undefined): UseQueryResult<XToken[], Error>;
 
 /**
  * Hook for executing stake transactions to stake SODA tokens and receive xSODA shares.
@@ -1474,11 +1668,11 @@ declare const MIGRATION_MODE_ICX_SODA = "icxsoda";
 declare const MIGRATION_MODE_BNUSD = "bnusd";
 type MigrationMode = typeof MIGRATION_MODE_ICX_SODA | typeof MIGRATION_MODE_BNUSD;
 interface MigrationIntentParams {
-    token: XToken | undefined;
+    token: XToken$1 | undefined;
     amount: string | undefined;
     sourceAddress: string | undefined;
     migrationMode?: MigrationMode;
-    toToken?: XToken;
+    toToken?: XToken$1;
     destinationAddress?: string;
 }
 
@@ -1562,4 +1756,4 @@ interface SodaxProviderProps {
 }
 declare const SodaxProvider: ({ children, testnet, config, rpcConfig }: SodaxProviderProps) => ReactElement;
 
-export { MIGRATION_MODE_BNUSD, MIGRATION_MODE_ICX_SODA, type MigrationIntentParams, type MigrationMode, SodaxProvider, useAToken, 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, useMigrate, useMigrationAllowance, useMigrationApprove, useQuote, useRepay, useRequestTrustline, useReservesData, useReservesUsdFormat, useSodaxContext, useSpokeProvider, useStake, useStakeAllowance, useStakeApprove, useStakeRatio, useStakingConfig, useStakingInfo, useStatus, useStellarTrustlineCheck, useSupply, useSwap, useSwapAllowance, useSwapApprove, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserReservesData, useWithdraw };
+export { type BackendPaginationParams, MIGRATION_MODE_BNUSD, MIGRATION_MODE_ICX_SODA, type MigrationIntentParams, type MigrationMode, SodaxProvider, type UseATokenParams, type UseBorrowParams, type UseMMAllowanceParams, type UseMMApproveParams, type UseRepayParams, type UseReservesDataParams, type UseReservesUsdFormatParams, type UseSupplyParams, type UseUserFormattedSummaryParams, type UseUserReservesDataParams, type UseWithdrawParams, useAToken, useBackendAllMoneyMarketAssets, useBackendAllMoneyMarketBorrowers, useBackendIntentByHash, useBackendIntentByTxHash, useBackendMoneyMarketAsset, useBackendMoneyMarketAssetBorrowers, useBackendMoneyMarketAssetSuppliers, useBackendMoneyMarketPosition, useBackendOrderbook, useBackendUserIntents, useBorrow, useBridge, useBridgeAllowance, useBridgeApprove, useCancelLimitOrder, useCancelSwap, useCancelUnstake, useClaim, useConvertedAssets, useCreateLimitOrder, useDeriveUserWalletAddress, useEstimateGas, useGetBridgeableAmount, useGetBridgeableTokens, useHubProvider, useInstantUnstake, useInstantUnstakeAllowance, useInstantUnstakeApprove, useInstantUnstakeRatio, useMMAllowance, useMMApprove, useMigrate, useMigrationAllowance, useMigrationApprove, useQuote, useRepay, useRequestTrustline, useReservesData, useReservesUsdFormat, useSodaxContext, useSpokeProvider, useStake, useStakeAllowance, useStakeApprove, useStakeRatio, useStakingConfig, useStakingInfo, useStatus, useStellarTrustlineCheck, useSupply, useSwap, useSwapAllowance, useSwapApprove, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserFormattedSummary, useUserReservesData, useWithdraw };