@aave/react 4.0.0-next.45 → 4.0.0-next.47

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-import { AaveClient, CurrencyQueryOptions, TimeWindowQueryOptions, UnexpectedError, TransactionReceipt, ActivitiesRequest, PaginatedActivitiesResult } from '@aave/client';
+import { AaveClient, CurrencyQueryOptions, TimeWindowQueryOptions, UnexpectedError, ActivitiesRequest, PaginatedActivitiesResult, TransactionReceipt } from '@aave/client';
 export * from '@aave/client';
 import React, { ReactNode } from 'react';
-import { a as UseAsyncTask, C as CancelOperation, P as PendingTransaction, S as SendTransactionError, b as PendingTransactionError, E as ExecutionPlanHandler } from './writes-CcVGQGt5.js';
-export { A as AsyncTaskError, c as AsyncTaskIdle, d as AsyncTaskLoading, e as AsyncTaskState, f as AsyncTaskSuccess, T as TransactionHandlerOptions, U as UseSendTransactionResult } from './writes-CcVGQGt5.js';
-import { HubRequest, Hub, HubsRequest, HubAssetsRequest, HubAsset, HubSummaryHistoryRequest, HubSummarySample, AssetRequest, Asset, AssetPriceHistoryRequest, AssetPriceSample, AssetSupplyHistoryRequest, AssetSupplySample, AssetBorrowHistoryRequest, AssetBorrowSample, ProtocolHistoryRequest, ProtocolHistorySample, ReserveRequest, Reserve, ReservesRequest, BorrowApyHistoryRequest, ApySample, SupplyApyHistoryRequest, UserClaimableRewardsRequest, UserClaimableReward, SpokeRequest, Spoke, SpokesRequest, SpokePositionManagersRequest, PaginatedSpokePositionManagerResult, SpokeUserPositionManagersRequest, PaginatedSpokeUserPositionManagerResult, TokenSwapQuoteRequest, SwapQuote, InsufficientLiquidityError, SwappableTokensRequest, Token, UserSwapsRequest, PaginatedUserSwapsResult, SwapStatusRequest, SwapStatus, SupplySwapQuoteRequest, BorrowSwapQuoteRequest, PositionSwapApproval, SwapTypedData, SwapReceipt, InsufficientBalanceError, RepayWithSupplyQuoteRequest, WithdrawSwapQuoteRequest, Erc20Approval, SwapTransactionRequest, TransactionRequest, PrepareSwapCancelRequest, SwapCancelledResult, PreContractActionRequired, SupplyRequest, BorrowRequest, RepayRequest, WithdrawRequest, RenounceSpokeUserPositionManagerRequest, UpdateUserPositionConditionsRequest, SetUserSuppliesAsCollateralRequest, LiquidatePositionRequest, SetSpokeUserPositionManagerRequest, PreviewRequest, PreviewUserPosition, ClaimRewardsRequest, UserSuppliesRequest, UserSupplyItem, UserBorrowsRequest, UserBorrowItem, UserSummaryRequest, UserSummary, UserPositionsRequest, UserPosition, UserPositionRequest, UserBalancesRequest, UserBalance, UserRiskPremiumBreakdownRequest, UserRiskPremiumBreakdownItem, UserSummaryHistoryRequest, UserSummaryHistoryItem } from '@aave/graphql';
+import { a as UseAsyncTask, C as CancelOperation, P as PendingTransaction, S as SendTransactionError, b as PendingTransactionError, c as cancel, E as ExecutionPlanHandler } from './writes-sBt0thuG.js';
+export { A as AsyncTaskError, d as AsyncTaskIdle, e as AsyncTaskLoading, f as AsyncTaskState, g as AsyncTaskSuccess, T as TransactionHandlerOptions, U as UseSendTransactionResult } from './writes-sBt0thuG.js';
+import { HubRequest, Hub, HubsRequest, HubAssetsRequest, HubAsset, HubSummaryHistoryRequest, HubSummarySample, AssetRequest, Asset, AssetPriceHistoryRequest, AssetPriceSample, AssetSupplyHistoryRequest, AssetSupplySample, AssetBorrowHistoryRequest, AssetBorrowSample, ProtocolHistoryRequest, ProtocolHistorySample, ReserveRequest, Reserve, ReservesRequest, BorrowApyHistoryRequest, ApySample, SupplyApyHistoryRequest, UserClaimableRewardsRequest, UserClaimableReward, SpokeRequest, Spoke, SpokesRequest, SpokePositionManagersRequest, PaginatedSpokePositionManagerResult, SpokeUserPositionManagersRequest, PaginatedSpokeUserPositionManagerResult, PositionSwapApproval, SwapTypedData, SwapQuote, BorrowSwapQuoteRequest, SwapReceipt, InsufficientBalanceError, InsufficientLiquidityError, TransactionRequest, PrepareSwapCancelRequest, SwapCancelledResult, RepayWithSupplyQuoteRequest, SupplySwapQuoteRequest, SwappableTokensRequest, Token, SwapStatusRequest, SwapStatus, Erc20Approval, SwapTransactionRequest, TokenSwapQuoteRequest, UserSwapsRequest, PaginatedUserSwapsResult, WithdrawSwapQuoteRequest, PreContractActionRequired, BorrowRequest, ClaimRewardsRequest, LiquidatePositionRequest, PreviewRequest, PreviewUserPosition, RenounceSpokeUserPositionManagerRequest, RepayRequest, SetSpokeUserPositionManagerRequest, SetUserSuppliesAsCollateralRequest, SupplyRequest, UpdateUserPositionConditionsRequest, WithdrawRequest, UserSuppliesRequest, UserSupplyItem, UserBorrowsRequest, UserBorrowItem, UserSummaryRequest, UserSummary, UserPositionsRequest, UserPosition, UserPositionRequest, UserBalancesRequest, UserBalance, UserRiskPremiumBreakdownRequest, UserRiskPremiumBreakdownItem, UserSummaryHistoryRequest, UserSummaryHistoryItem } from '@aave/graphql';
 import { Prettify, ResultAsync, Signature, ResultAwareError } from '@aave/types';
-import { S as Suspendable, a as SuspenseResult, P as Pausable, b as PausableSuspenseResult, R as ReadResult, c as PausableReadResult } from './misc-COaS62_P.js';
-export { d as UseChainArgs, f as UseChainsArgs, i as UseExchangeRateArgs, U as UseNetworkFee, l as UseNetworkFeeArgs, k as UseNetworkFeeRequestQuery, u as useChain, e as useChainAction, g as useChains, j as useExchangeRate, h as useExchangeRateAction } from './misc-COaS62_P.js';
-import { UnexpectedError as UnexpectedError$1, ValidationError, CancelError, SigningError, TimeoutError, TransactionError } from '@aave/core';
+import { S as Suspendable, a as SuspenseResult, P as Pausable, b as PausableSuspenseResult, R as ReadResult, c as PausableReadResult } from './misc-BqyLi2XD.js';
+export { d as UseChainArgs, f as UseChainsArgs, i as UseExchangeRateArgs, U as UseNetworkFee, l as UseNetworkFeeArgs, k as UseNetworkFeeRequestQuery, u as useChain, e as useChainAction, g as useChains, j as useExchangeRate, h as useExchangeRateAction } from './misc-BqyLi2XD.js';
+import { CancelError, SigningError, UnexpectedError as UnexpectedError$1, ValidationError, TimeoutError, TransactionError } from '@aave/core';
 import { UserPositionQueryOptions } from '@aave/client/actions';
 
 /**
@@ -1149,40 +1149,83 @@ declare function useSpokeUserPositionManagers(args: UseSpokeUserPositionManagers
  */
 declare function useSpokeUserPositionManagers(args: Pausable<UseSpokeUserPositionManagersArgs>): PausableReadResult<PaginatedSpokeUserPositionManagerResult>;
 
-type UseTokenSwapQuoteArgs = Prettify<TokenSwapQuoteRequest & CurrencyQueryOptions>;
+type SwapHandlerOptions = {
+    cancel: CancelOperation;
+};
+type SwapSignerError = CancelError | SigningError | UnexpectedError$1;
+type PositionSwapPlan = PositionSwapApproval | SwapTypedData;
+type PositionSwapHandler = (plan: PositionSwapPlan, options: SwapHandlerOptions) => ResultAsync<PendingTransaction | Signature, SwapSignerError>;
+type PositionSwapValue = {
+    quote?: SwapQuote;
+};
+
+type UseBorrowSwapRequest = Prettify<BorrowSwapQuoteRequest & CurrencyQueryOptions>;
 /**
- * Fetch a swap quote for the specified trade parameters.
+ * Orchestrate the borrow swap execution plan.
+ *
+ * ```tsx
+ * const [signTypedData] = useSignTypedData(wallet);
+ *
+ * const [swapBorrow, { loading, error }] = useBorrowSwap((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'PositionSwapAdapterContractApproval':
+ *     case 'PositionSwapPositionManagerApproval':
+ *       return signTypedData(plan.bySignature);
+ *
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
+ *   }
+ * });
+ *
+ * const result = await swapBorrow({
+ *   market: {
+ *     debtPosition: userBorrowItem.id,
+ *     buyReserve: targetReserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapReceipt
+ * ```
+ */
+declare function useBorrowSwap(handler: PositionSwapHandler): UseAsyncTask<BorrowSwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
+type UseBorrowSwapQuoteArgs = Prettify<BorrowSwapQuoteRequest & CurrencyQueryOptions>;
+/**
+ * Fetch a quote for a borrow swap operation with the specified parameters.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useTokenSwapQuote({
+ * const { data } = useBorrowSwapQuote({
  *   market: {
- *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
- *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
  *     amount: bigDecimal('1000'),
- *     kind: SwapKind.Sell,
  *     user: evmAddress('0x742d35cc…'),
  *   },
- *   chainId: chainId(1),
  *   suspense: true,
  * });
  * ```
  */
-declare function useTokenSwapQuote(args: UseTokenSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+declare function useBorrowSwapQuote(args: UseBorrowSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
 /**
- * Fetch a swap quote for the specified trade parameters.
+ * Fetch a quote for a borrow swap operation with the specified parameters.
  *
  * Pausable suspense mode.
  *
  * ```tsx
- * const { data } = useTokenSwapQuote({
+ * const { data } = useBorrowSwapQuote({
  *   market: {
- *     chainId: chainId(1),
- *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
- *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
  *     amount: bigDecimal('1000'),
- *     kind: SwapKind.Sell,
  *     user: evmAddress('0x742d35cc…'),
  *   },
  *   suspense: true,
@@ -1190,240 +1233,281 @@ declare function useTokenSwapQuote(args: UseTokenSwapQuoteArgs & Suspendable): S
  * });
  * ```
  */
-declare function useTokenSwapQuote(args: Pausable<UseTokenSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+declare function useBorrowSwapQuote(args: Pausable<UseBorrowSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
 /**
- * Fetch a swap quote for the specified trade parameters.
+ * Fetch a quote for a borrow swap operation with the specified parameters.
  *
  * ```tsx
- * const { data, error, loading } = useTokenSwapQuote({
+ * const { data, error, loading } = useBorrowSwapQuote({
  *   market: {
- *     chainId: chainId(1),
- *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
- *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
  *     amount: bigDecimal('1000'),
- *     kind: SwapKind.Sell,
  *     user: evmAddress('0x742d35cc…'),
  *   },
  * });
  * ```
  */
-declare function useTokenSwapQuote(args: UseTokenSwapQuoteArgs): ReadResult<SwapQuote>;
+declare function useBorrowSwapQuote(args: UseBorrowSwapQuoteArgs): ReadResult<SwapQuote>;
 /**
- * Fetch a swap quote for the specified trade parameters.
+ * Fetch a quote for a borrow swap operation with the specified parameters.
  *
  * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading, paused } = useTokenSwapQuote({
+ * const { data, error, loading, paused } = useBorrowSwapQuote({
  *   market: {
- *     chainId: chainId(1),
- *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
- *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
  *     amount: bigDecimal('1000'),
- *     kind: SwapKind.Sell,
  *     user: evmAddress('0x742d35cc…'),
  *   },
  *   pause: true,
  * });
  * ```
  */
-declare function useTokenSwapQuote(args: Pausable<UseTokenSwapQuoteArgs>): PausableReadResult<SwapQuote>;
+declare function useBorrowSwapQuote(args: Pausable<UseBorrowSwapQuoteArgs>): PausableReadResult<SwapQuote>;
 /**
- * Low-level hook to execute a swap quote action directly.
+ * Low-level hook to execute a borrow swap quote action directly.
  *
  * @remarks
  * This hook **does not** actively watch for updated data on the swap quote.
- * Use this hook to retrieve quotes on demand as part of a larger workflow
- * (e.g., in an event handler to get a fresh quote before executing a swap).
+ * Use this hook to retrieve quotes on demand as part of a larger workflow.
  *
  * ```ts
- * const [getQuote, { called, data, error, loading }] = useTokenSwapQuoteAction();
+ * const [getQuote, { called, data, error, loading }] = useBorrowSwapQuoteAction();
  *
  * // …
  *
  * const result = await getQuote({
- *   market: {
- *     chainId: chainId(1),
- *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
- *     sell: { erc20: evmAddress('0x6B175474E…') },
- *     amount: bigDecimal('1000'),
- *     kind: SwapKind.Sell,
- *   },
+ *   debtPosition: userBorrowItem.id,
+ *   buyReserve: reserve.id,
+ *   amount: bigDecimal('1000'),
+ *   user: evmAddress('0x742d35cc…'),
  * });
  *
  * if (result.isOk()) {
- *   console.log('Swap quote:', result.value);
+ *   console.log('Borrow swap quote:', result.value);
  * } else {
  *   console.error(result.error);
  * }
  * ```
  */
-declare function useTokenSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<TokenSwapQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
-type UseSwappableTokensArgs = SwappableTokensRequest;
+declare function useBorrowSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<BorrowSwapQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
+
+type CancelSwapHandler = (data: SwapTypedData | TransactionRequest, options: {
+    cancel: typeof cancel;
+}) => ResultAsync<PendingTransaction | Signature, SwapSignerError>;
+declare class CannotCancelSwapError extends ResultAwareError {
+    name: "CannotCancelSwapError";
+}
+type CancelSwapError = CancelError | CannotCancelSwapError | SigningError | TimeoutError | TransactionError | UnexpectedError$1;
 /**
- * Fetch the list of tokens available for swapping on a specific chain.
- *
- * This signature supports React Suspense:
+ * Executes the complete swap cancellation workflow combining preparation and execution.
  *
  * ```tsx
- * const { data } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
- *   suspense: true,
- * });
- * ```
- */
-declare function useSwappableTokens(args: UseSwappableTokensArgs & Suspendable): SuspenseResult<Token[]>;
-/**
- * Fetch the list of tokens available for swapping on a specific chain.
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [signTypedData] = useSignTypedData(wallet);
  *
- * Pausable suspense mode.
+ * const [cancelSwap, { loading, error }] = useCancelSwap((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
  *
- * ```tsx
- * const { data } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
- *   suspense: true,
- *   pause: true,
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
+ *   }
  * });
- * ```
- */
-declare function useSwappableTokens(args: Pausable<UseSwappableTokensArgs> & Suspendable): PausableSuspenseResult<Token[]>;
-/**
- * Fetch the list of tokens available for swapping on a specific chain.
  *
- * ```tsx
- * const { data, error, loading } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
+ * const result = await cancelSwap({
+ *   id: swapId('123…'),
  * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapCancelledResult
+ * console.log('Swap cancelled:', result.value);
  * ```
  */
-declare function useSwappableTokens(args: UseSwappableTokensArgs): ReadResult<Token[]>;
+declare function useCancelSwap(handler: CancelSwapHandler): UseAsyncTask<PrepareSwapCancelRequest, SwapCancelledResult, CancelSwapError>;
+
+type UseRepayWithSupplyRequest = Prettify<RepayWithSupplyQuoteRequest & CurrencyQueryOptions>;
 /**
- * Fetch the list of tokens available for swapping on a specific chain.
- *
- * Pausable loading state mode.
+ * Orchestrate the repay with supply execution plan.
  *
  * ```tsx
- * const { data, error, loading, paused } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
- *   pause: true,
+ * const [signTypedData] = useSignTypedData(wallet);
+ *
+ * const [repayWithSupply, { loading, error }] = useRepayWithSupply((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'PositionSwapAdapterContractApproval':
+ *     case 'PositionSwapPositionManagerApproval':
+ *       return signTypedData(plan.bySignature);
+ *
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
+ *   }
+ * });
+ *
+ * const result = await repayWithSupply({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapReceipt
  * ```
  */
-declare function useSwappableTokens(args: Pausable<UseSwappableTokensArgs>): PausableReadResult<Token[]>;
-type UseUserSwapsArgs = Prettify<UserSwapsRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
+declare function useRepayWithSupply(handler: PositionSwapHandler): UseAsyncTask<RepayWithSupplyQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
+type UseRepayWithSupplyQuoteArgs = Prettify<RepayWithSupplyQuoteRequest & CurrencyQueryOptions>;
 /**
- * Fetch the user's swap history for a specific chain.
+ * Fetch a quote for a repay with supply operation with the specified parameters.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useUserSwaps({
- *   chainId: chainId(1),
- *   user: evmAddress('0x742d35cc…'),
- *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ * const { data } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   suspense: true,
  * });
  * ```
  */
-declare function useUserSwaps(args: UseUserSwapsArgs & Suspendable): SuspenseResult<PaginatedUserSwapsResult>;
+declare function useRepayWithSupplyQuote(args: UseRepayWithSupplyQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
 /**
- * Fetch the user's swap history for a specific chain.
+ * Fetch a quote for a repay with supply operation with the specified parameters.
  *
  * Pausable suspense mode.
  *
  * ```tsx
- * const { data } = useUserSwaps({
- *   chainId: chainId(1),
- *   user: evmAddress('0x742d35cc…'),
- *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ * const { data } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   suspense: true,
  *   pause: true,
  * });
  * ```
  */
-declare function useUserSwaps(args: Pausable<UseUserSwapsArgs> & Suspendable): PausableSuspenseResult<PaginatedUserSwapsResult>;
+declare function useRepayWithSupplyQuote(args: Pausable<UseRepayWithSupplyQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
 /**
- * Fetch the user's swap history for a specific chain.
+ * Fetch a quote for a repay with supply operation with the specified parameters.
  *
  * ```tsx
- * const { data, error, loading } = useUserSwaps({
- *   chainId: chainId(1),
- *   user: evmAddress('0x742d35cc…'),
- *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
- * });
- * ```
- */
-declare function useUserSwaps(args: UseUserSwapsArgs): ReadResult<PaginatedUserSwapsResult>;
-/**
- * Fetch the user's swap history for a specific chain.
+ * const { data, error, loading } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ * });
+ * ```
+ */
+declare function useRepayWithSupplyQuote(args: UseRepayWithSupplyQuoteArgs): ReadResult<SwapQuote>;
+/**
+ * Fetch a quote for a repay with supply operation with the specified parameters.
  *
  * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading, paused } = useUserSwaps({
- *   chainId: chainId(1),
- *   user: evmAddress('0x742d35cc…'),
- *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ * const { data, error, loading, paused } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   pause: true,
  * });
  * ```
  */
-declare function useUserSwaps(args: Pausable<UseUserSwapsArgs>): PausableReadResult<PaginatedUserSwapsResult>;
-type UseSwapStatusArgs = Prettify<SwapStatusRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
+declare function useRepayWithSupplyQuote(args: Pausable<UseRepayWithSupplyQuoteArgs>): PausableReadResult<SwapQuote>;
 /**
- * Monitor the status of a single swap operation in real-time.
+ * Low-level hook to execute a repay with supply quote action directly.
  *
- * Polls automatically until the swap reaches a terminal state (fulfilled, cancelled, or expired).
+ * @remarks
+ * This hook **does not** actively watch for updated data on the swap quote.
+ * Use this hook to retrieve quotes on demand as part of a larger workflow.
  *
- * This signature supports React Suspense:
+ * ```ts
+ * const [getQuote, { called, data, error, loading }] = useRepayWithSupplyQuoteAction();
  *
- * ```tsx
- * const { data } = useSwapStatus({
- *   id: swapReceipt.id,
- *   suspense: true,
+ * // …
+ *
+ * const result = await getQuote({
+ *   repayWithReserve: reserve.id,
+ *   debtPosition: userBorrowItem.id,
+ *   amount: bigDecimal('1000'),
+ *   user: evmAddress('0x742d35cc…'),
  * });
+ *
+ * if (result.isOk()) {
+ *   console.log('Repay with supply quote:', result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
  * ```
  */
-declare function useSwapStatus(args: UseSwapStatusArgs & Suspendable): SuspenseResult<SwapStatus>;
+declare function useRepayWithSupplyQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<RepayWithSupplyQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
+
+type UseSupplySwapRequest = Prettify<SupplySwapQuoteRequest & CurrencyQueryOptions>;
 /**
- * Monitor the status of a single swap operation in real-time.
- *
- * Pausable suspense mode.
+ * Orchestrate the supply swap execution plan.
  *
  * ```tsx
- * const { data } = useSwapStatus({
- *   id: swapReceipt.id,
- *   suspense: true,
- *   pause: shouldPause,
- * });
- * ```
- */
-declare function useSwapStatus(args: Pausable<UseSwapStatusArgs> & Suspendable): PausableSuspenseResult<SwapStatus>;
-/**
- * Monitor the status of a single swap operation in real-time.
+ * const [signTypedData] = useSignTypedData(wallet);
  *
- * Polls automatically until the swap reaches a terminal state (fulfilled, cancelled, or expired).
+ * const [swapSupply, { loading, error }] = useSupplySwap((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'PositionSwapAdapterContractApproval':
+ *     case 'PositionSwapPositionManagerApproval':
+ *       return signTypedData(plan.bySignature);
  *
- * ```tsx
- * const { data, error, loading } = useSwapStatus({
- *   id: swapReceipt.id,
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
+ *   }
  * });
- * ```
- */
-declare function useSwapStatus(args: UseSwapStatusArgs): ReadResult<SwapStatus>;
-/**
- * Monitor the status of a single swap operation in real-time.
- *
- * Pausable loading state mode.
  *
- * ```tsx
- * const { data, error, loading, paused } = useSwapStatus({
- *   id: swapReceipt.id,
- *   pause: shouldPause,
+ * const result = await swapSupply({
+ *   market: {
+ *     sellPosition: supplyPosition.id,
+ *     buyReserve: targetReserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *     enableCollateral: true,
+ *   },
  * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapReceipt
  * ```
  */
-declare function useSwapStatus(args: Pausable<UseSwapStatusArgs>): PausableReadResult<SwapStatus>;
+declare function useSupplySwap(handler: PositionSwapHandler): UseAsyncTask<SupplySwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
 type UseSupplySwapQuoteArgs = Prettify<SupplySwapQuoteRequest & CurrencyQueryOptions>;
 /**
  * Fetch a quote for a supply swap operation with the specified parameters.
@@ -1522,174 +1606,144 @@ declare function useSupplySwapQuote(args: Pausable<UseSupplySwapQuoteArgs>): Pau
  * ```
  */
 declare function useSupplySwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<SupplySwapQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
-type UseBorrowSwapQuoteArgs = Prettify<BorrowSwapQuoteRequest & CurrencyQueryOptions>;
+
+type UseSwappableTokensArgs = SwappableTokensRequest;
 /**
- * Fetch a quote for a borrow swap operation with the specified parameters.
+ * Fetch the list of tokens available for swapping on a specific chain.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useBorrowSwapQuote({
- *   market: {
- *     sellPosition: userBorrowItem.id,
- *     buyReserve: reserve.id,
- *     amount: bigDecimal('1000'),
- *     user: evmAddress('0x742d35cc…'),
- *   },
+ * const { data } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
  *   suspense: true,
  * });
  * ```
  */
-declare function useBorrowSwapQuote(args: UseBorrowSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+declare function useSwappableTokens(args: UseSwappableTokensArgs & Suspendable): SuspenseResult<Token[]>;
 /**
- * Fetch a quote for a borrow swap operation with the specified parameters.
+ * Fetch the list of tokens available for swapping on a specific chain.
  *
  * Pausable suspense mode.
  *
  * ```tsx
- * const { data } = useBorrowSwapQuote({
- *   market: {
- *     sellPosition: userBorrowItem.id,
- *     buyReserve: reserve.id,
- *     amount: bigDecimal('1000'),
- *     user: evmAddress('0x742d35cc…'),
- *   },
+ * const { data } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
  *   suspense: true,
  *   pause: true,
  * });
  * ```
  */
-declare function useBorrowSwapQuote(args: Pausable<UseBorrowSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+declare function useSwappableTokens(args: Pausable<UseSwappableTokensArgs> & Suspendable): PausableSuspenseResult<Token[]>;
 /**
- * Fetch a quote for a borrow swap operation with the specified parameters.
+ * Fetch the list of tokens available for swapping on a specific chain.
  *
  * ```tsx
- * const { data, error, loading } = useBorrowSwapQuote({
- *   market: {
- *     sellPosition: userBorrowItem.id,
- *     buyReserve: reserve.id,
- *     amount: bigDecimal('1000'),
- *     user: evmAddress('0x742d35cc…'),
- *   },
+ * const { data, error, loading } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
  * });
  * ```
  */
-declare function useBorrowSwapQuote(args: UseBorrowSwapQuoteArgs): ReadResult<SwapQuote>;
+declare function useSwappableTokens(args: UseSwappableTokensArgs): ReadResult<Token[]>;
 /**
- * Fetch a quote for a borrow swap operation with the specified parameters.
+ * Fetch the list of tokens available for swapping on a specific chain.
  *
  * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading, paused } = useBorrowSwapQuote({
- *   market: {
- *     sellPosition: userBorrowItem.id,
- *     buyReserve: reserve.id,
- *     amount: bigDecimal('1000'),
- *     user: evmAddress('0x742d35cc…'),
- *   },
+ * const { data, error, loading, paused } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
  *   pause: true,
  * });
  * ```
  */
-declare function useBorrowSwapQuote(args: Pausable<UseBorrowSwapQuoteArgs>): PausableReadResult<SwapQuote>;
+declare function useSwappableTokens(args: Pausable<UseSwappableTokensArgs>): PausableReadResult<Token[]>;
+
+type UseSwapStatusArgs = Prettify<SwapStatusRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
- * Low-level hook to execute a borrow swap quote action directly.
- *
- * @remarks
- * This hook **does not** actively watch for updated data on the swap quote.
- * Use this hook to retrieve quotes on demand as part of a larger workflow.
+ * Monitor the status of a single swap operation in real-time.
  *
- * ```ts
- * const [getQuote, { called, data, error, loading }] = useBorrowSwapQuoteAction();
+ * Polls automatically until the swap reaches a terminal state (fulfilled, cancelled, or expired).
  *
- * // …
+ * This signature supports React Suspense:
  *
- * const result = await getQuote({
- *   debtPosition: userBorrowItem.id,
- *   buyReserve: reserve.id,
- *   amount: bigDecimal('1000'),
- *   user: evmAddress('0x742d35cc…'),
+ * ```tsx
+ * const { data } = useSwapStatus({
+ *   id: swapReceipt.id,
+ *   suspense: true,
  * });
- *
- * if (result.isOk()) {
- *   console.log('Borrow swap quote:', result.value);
- * } else {
- *   console.error(result.error);
- * }
  * ```
  */
-declare function useBorrowSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<BorrowSwapQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
-type SwapHandlerOptions = {
-    cancel: CancelOperation;
-};
-type SwapSignerError = CancelError | SigningError | UnexpectedError$1;
-type PositionSwapPlan = PositionSwapApproval | SwapTypedData;
-type PositionSwapHandler = (plan: PositionSwapPlan, options: SwapHandlerOptions) => ResultAsync<PendingTransaction | Signature, SwapSignerError>;
-type PositionSwapValue = {
-    quote?: SwapQuote;
-};
-type UseSupplySwapRequest = Prettify<SupplySwapQuoteRequest & CurrencyQueryOptions>;
+declare function useSwapStatus(args: UseSwapStatusArgs & Suspendable): SuspenseResult<SwapStatus>;
 /**
- * Orchestrate the supply swap execution plan.
- *
- * ```tsx
- * const [signTypedData] = useSignTypedData(wallet);
- *
- * const [swapSupply, { loading, error }] = useSupplySwap((plan) => {
- *   switch (plan.__typename) {
- *     case 'PositionSwapAdapterContractApproval':
- *     case 'PositionSwapPositionManagerApproval':
- *       return signTypedData(plan.bySignature);
+ * Monitor the status of a single swap operation in real-time.
  *
- *     case 'SwapTypedData':
- *       return signTypedData(plan);
- *   }
- * });
+ * Pausable suspense mode.
  *
- * const result = await swapSupply({
- *   market: {
- *     sellPosition: supplyPosition.id,
- *     buyReserve: targetReserve.id,
- *     amount: bigDecimal('1000'),
- *     user: evmAddress('0x742d35cc…'),
- *     enableCollateral: true,
- *   },
+ * ```tsx
+ * const { data } = useSwapStatus({
+ *   id: swapReceipt.id,
+ *   suspense: true,
+ *   pause: shouldPause,
  * });
- *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
- *
- * // result.value: SwapReceipt
  * ```
  */
-declare function useSupplySwap(handler: PositionSwapHandler): UseAsyncTask<SupplySwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
-type UseBorrowSwapRequest = Prettify<BorrowSwapQuoteRequest & CurrencyQueryOptions>;
+declare function useSwapStatus(args: Pausable<UseSwapStatusArgs> & Suspendable): PausableSuspenseResult<SwapStatus>;
 /**
- * Orchestrate the borrow swap execution plan.
+ * Monitor the status of a single swap operation in real-time.
  *
- * ```tsx
- * const [signTypedData] = useSignTypedData(wallet);
+ * Polls automatically until the swap reaches a terminal state (fulfilled, cancelled, or expired).
  *
- * const [swapBorrow, { loading, error }] = useBorrowSwap((plan) => {
- *   switch (plan.__typename) {
- *     case 'PositionSwapAdapterContractApproval':
- *     case 'PositionSwapPositionManagerApproval':
- *       return signTypedData(plan.bySignature);
+ * ```tsx
+ * const { data, error, loading } = useSwapStatus({
+ *   id: swapReceipt.id,
+ * });
+ * ```
+ */
+declare function useSwapStatus(args: UseSwapStatusArgs): ReadResult<SwapStatus>;
+/**
+ * Monitor the status of a single swap operation in real-time.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSwapStatus({
+ *   id: swapReceipt.id,
+ *   pause: shouldPause,
+ * });
+ * ```
+ */
+declare function useSwapStatus(args: Pausable<UseSwapStatusArgs>): PausableReadResult<SwapStatus>;
+
+type UseTokenSwapRequest = Prettify<TokenSwapQuoteRequest & CurrencyQueryOptions>;
+type TokenSwapPlan = SwapTypedData | Erc20Approval | SwapTransactionRequest;
+type TokenSwapHandler = (plan: TokenSwapPlan, options: SwapHandlerOptions) => ResultAsync<PendingTransaction | Signature, SwapSignerError>;
+/**
+ * Orchestrate the token swap execution plan.
+ *
+ * ```tsx
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [signTypedData] = useSignTypedData(wallet);
+ *
+ * const [swap, { loading, error }] = useTokenSwap((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'Erc20Approval':
+ *       if (plan.bySignature) {
+ *         return signTypedData(plan.bySignature);
+ *       }
+ *       return sendTransaction(plan.byTransaction);
+ *
+ *     case 'SwapTransactionRequest':
+ *       return sendTransaction(plan.transaction);
  *
  *     case 'SwapTypedData':
  *       return signTypedData(plan);
  *   }
  * });
  *
- * const result = await swapBorrow({
- *   market: {
- *     debtPosition: userBorrowItem.id,
- *     buyReserve: targetReserve.id,
- *     amount: bigDecimal('1000'),
- *     user: evmAddress('0x742d35cc…'),
+ * const result = await swap({
+ *   fromQuote: {
+ *     quoteId: quote.quoteId,
  *   },
  * });
  *
@@ -1701,37 +1755,42 @@ type UseBorrowSwapRequest = Prettify<BorrowSwapQuoteRequest & CurrencyQueryOptio
  * // result.value: SwapReceipt
  * ```
  */
-declare function useBorrowSwap(handler: PositionSwapHandler): UseAsyncTask<BorrowSwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
-type UseRepayWithSupplyQuoteArgs = Prettify<RepayWithSupplyQuoteRequest & CurrencyQueryOptions>;
+declare function useTokenSwap(handler: TokenSwapHandler): UseAsyncTask<UseTokenSwapRequest, SwapReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
+type UseTokenSwapQuoteArgs = Prettify<TokenSwapQuoteRequest & CurrencyQueryOptions>;
 /**
- * Fetch a quote for a repay with supply operation with the specified parameters.
+ * Fetch a swap quote for the specified trade parameters.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useRepayWithSupplyQuote({
+ * const { data } = useTokenSwapQuote({
  *   market: {
- *     sellPosition: userSupplyItem.id,
- *     buyPosition: userBorrowItem.id,
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
  *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
  *     user: evmAddress('0x742d35cc…'),
  *   },
+ *   chainId: chainId(1),
  *   suspense: true,
  * });
  * ```
  */
-declare function useRepayWithSupplyQuote(args: UseRepayWithSupplyQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+declare function useTokenSwapQuote(args: UseTokenSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
 /**
- * Fetch a quote for a repay with supply operation with the specified parameters.
+ * Fetch a swap quote for the specified trade parameters.
  *
  * Pausable suspense mode.
  *
  * ```tsx
- * const { data } = useRepayWithSupplyQuote({
+ * const { data } = useTokenSwapQuote({
  *   market: {
- *     sellPosition: userSupplyItem.id,
- *     buyPosition: userBorrowItem.id,
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
  *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
  *     user: evmAddress('0x742d35cc…'),
  *   },
  *   suspense: true,
@@ -1739,75 +1798,144 @@ declare function useRepayWithSupplyQuote(args: UseRepayWithSupplyQuoteArgs & Sus
  * });
  * ```
  */
-declare function useRepayWithSupplyQuote(args: Pausable<UseRepayWithSupplyQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+declare function useTokenSwapQuote(args: Pausable<UseTokenSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
 /**
- * Fetch a quote for a repay with supply operation with the specified parameters.
+ * Fetch a swap quote for the specified trade parameters.
  *
  * ```tsx
- * const { data, error, loading } = useRepayWithSupplyQuote({
+ * const { data, error, loading } = useTokenSwapQuote({
  *   market: {
- *     sellPosition: userSupplyItem.id,
- *     buyPosition: userBorrowItem.id,
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
  *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
  *     user: evmAddress('0x742d35cc…'),
  *   },
  * });
  * ```
  */
-declare function useRepayWithSupplyQuote(args: UseRepayWithSupplyQuoteArgs): ReadResult<SwapQuote>;
+declare function useTokenSwapQuote(args: UseTokenSwapQuoteArgs): ReadResult<SwapQuote>;
 /**
- * Fetch a quote for a repay with supply operation with the specified parameters.
+ * Fetch a swap quote for the specified trade parameters.
  *
  * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading, paused } = useRepayWithSupplyQuote({
+ * const { data, error, loading, paused } = useTokenSwapQuote({
  *   market: {
- *     sellPosition: userSupplyItem.id,
- *     buyPosition: userBorrowItem.id,
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
  *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
  *     user: evmAddress('0x742d35cc…'),
  *   },
  *   pause: true,
  * });
  * ```
  */
-declare function useRepayWithSupplyQuote(args: Pausable<UseRepayWithSupplyQuoteArgs>): PausableReadResult<SwapQuote>;
+declare function useTokenSwapQuote(args: Pausable<UseTokenSwapQuoteArgs>): PausableReadResult<SwapQuote>;
 /**
- * Low-level hook to execute a repay with supply quote action directly.
+ * Low-level hook to execute a swap quote action directly.
  *
  * @remarks
  * This hook **does not** actively watch for updated data on the swap quote.
- * Use this hook to retrieve quotes on demand as part of a larger workflow.
+ * Use this hook to retrieve quotes on demand as part of a larger workflow
+ * (e.g., in an event handler to get a fresh quote before executing a swap).
  *
  * ```ts
- * const [getQuote, { called, data, error, loading }] = useRepayWithSupplyQuoteAction();
+ * const [getQuote, { called, data, error, loading }] = useTokenSwapQuoteAction();
  *
  * // …
  *
  * const result = await getQuote({
- *   repayWithReserve: reserve.id,
- *   debtPosition: userBorrowItem.id,
- *   amount: bigDecimal('1000'),
- *   user: evmAddress('0x742d35cc…'),
+ *   market: {
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
+ *   },
  * });
  *
  * if (result.isOk()) {
- *   console.log('Repay with supply quote:', result.value);
+ *   console.log('Swap quote:', result.value);
  * } else {
  *   console.error(result.error);
  * }
  * ```
  */
-declare function useRepayWithSupplyQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<RepayWithSupplyQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
-type UseRepayWithSupplyRequest = Prettify<RepayWithSupplyQuoteRequest & CurrencyQueryOptions>;
+declare function useTokenSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<TokenSwapQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
+
+type UseUserSwapsArgs = Prettify<UserSwapsRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
- * Orchestrate the repay with supply execution plan.
+ * Fetch the user's swap history for a specific chain.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserSwaps({
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x742d35cc…'),
+ *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserSwaps(args: UseUserSwapsArgs & Suspendable): SuspenseResult<PaginatedUserSwapsResult>;
+/**
+ * Fetch the user's swap history for a specific chain.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useUserSwaps({
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x742d35cc…'),
+ *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserSwaps(args: Pausable<UseUserSwapsArgs> & Suspendable): PausableSuspenseResult<PaginatedUserSwapsResult>;
+/**
+ * Fetch the user's swap history for a specific chain.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserSwaps({
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x742d35cc…'),
+ *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ * });
+ * ```
+ */
+declare function useUserSwaps(args: UseUserSwapsArgs): ReadResult<PaginatedUserSwapsResult>;
+/**
+ * Fetch the user's swap history for a specific chain.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useUserSwaps({
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x742d35cc…'),
+ *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserSwaps(args: Pausable<UseUserSwapsArgs>): PausableReadResult<PaginatedUserSwapsResult>;
+
+type UseWithdrawSwapRequest = Prettify<WithdrawSwapQuoteRequest & CurrencyQueryOptions>;
+/**
+ * Orchestrate the withdraw swap execution plan.
  *
  * ```tsx
  * const [signTypedData] = useSignTypedData(wallet);
  *
- * const [repayWithSupply, { loading, error }] = useRepayWithSupply((plan) => {
+ * const [withdrawSwap, { loading, error }] = useWithdrawSwap((plan) => {
  *   switch (plan.__typename) {
  *     case 'PositionSwapAdapterContractApproval':
  *     case 'PositionSwapPositionManagerApproval':
@@ -1818,10 +1946,10 @@ type UseRepayWithSupplyRequest = Prettify<RepayWithSupplyQuoteRequest & Currency
  *   }
  * });
  *
- * const result = await repayWithSupply({
+ * const result = await withdrawSwap({
  *   market: {
- *     sellPosition: userSupplyItem.id,
- *     buyPosition: userBorrowItem.id,
+ *     position: userSupplyItem.id,
+ *     buyToken: { erc20: evmAddress('0xA0b86a33E6…') },
  *     amount: bigDecimal('1000'),
  *     user: evmAddress('0x742d35cc…'),
  *   },
@@ -1835,7 +1963,8 @@ type UseRepayWithSupplyRequest = Prettify<RepayWithSupplyQuoteRequest & Currency
  * // result.value: SwapReceipt
  * ```
  */
-declare function useRepayWithSupply(handler: PositionSwapHandler): UseAsyncTask<RepayWithSupplyQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+declare function useWithdrawSwap(handler: PositionSwapHandler): UseAsyncTask<WithdrawSwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
 type UseWithdrawSwapQuoteArgs = Prettify<WithdrawSwapQuoteRequest & CurrencyQueryOptions>;
 /**
  * Fetch a quote for a withdraw swap operation with the specified parameters.
@@ -1934,177 +2063,91 @@ declare function useWithdrawSwapQuote(args: Pausable<UseWithdrawSwapQuoteArgs>):
  * ```
  */
 declare function useWithdrawSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<WithdrawSwapQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
-type UseWithdrawSwapRequest = Prettify<WithdrawSwapQuoteRequest & CurrencyQueryOptions>;
+
+type UseActivitiesArgs = Prettify<ActivitiesRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
- * Orchestrate the withdraw swap execution plan.
- *
- * ```tsx
- * const [signTypedData] = useSignTypedData(wallet);
- *
- * const [withdrawSwap, { loading, error }] = useWithdrawSwap((plan) => {
- *   switch (plan.__typename) {
- *     case 'PositionSwapAdapterContractApproval':
- *     case 'PositionSwapPositionManagerApproval':
- *       return signTypedData(plan.bySignature);
+ * Fetch paginated list of activities.
  *
- *     case 'SwapTypedData':
- *       return signTypedData(plan);
- *   }
- * });
+ * This signature supports React Suspense:
  *
- * const result = await withdrawSwap({
- *   market: {
- *     position: userSupplyItem.id,
- *     buyToken: { erc20: evmAddress('0xA0b86a33E6…') },
- *     amount: bigDecimal('1000'),
- *     user: evmAddress('0x742d35cc…'),
+ * ```tsx
+ * const { data } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
  *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
  * });
  *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
- *
- * // result.value: SwapReceipt
+ * // data.items: ActivityItem[]
  * ```
  */
-declare function useWithdrawSwap(handler: PositionSwapHandler): UseAsyncTask<WithdrawSwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
-type UseTokenSwapRequest = Prettify<TokenSwapQuoteRequest & CurrencyQueryOptions>;
-type TokenSwapPlan = SwapTypedData | Erc20Approval | SwapTransactionRequest;
-type TokenSwapHandler = (plan: TokenSwapPlan, options: SwapHandlerOptions) => ResultAsync<PendingTransaction | Signature, SwapSignerError>;
+declare function useActivities(args: UseActivitiesArgs & Suspendable): SuspenseResult<PaginatedActivitiesResult>;
 /**
- * Orchestrate the token swap execution plan.
+ * Fetch paginated list of activities.
  *
- * ```tsx
- * const [sendTransaction] = useSendTransaction(wallet);
- * const [signTypedData] = useSignTypedData(wallet);
+ * Pausable suspense mode.
  *
- * const [swap, { loading, error }] = useTokenSwap((plan) => {
- *   switch (plan.__typename) {
- *     case 'Erc20Approval':
- *       if (plan.bySignature) {
- *         return signTypedData(plan.bySignature);
- *       }
- *       return sendTransaction(plan.byTransaction);
- *
- *     case 'SwapTransactionRequest':
- *       return sendTransaction(plan.transaction);
- *
- *     case 'SwapTypedData':
- *       return signTypedData(plan);
- *   }
- * });
- *
- * const result = await swap({
- *   fromQuote: {
- *     quoteId: quote.quoteId,
+ * ```tsx
+ * const { data } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
  *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ *   pause: true,
  * });
  *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
- *
- * // result.value: SwapReceipt
+ * // data?.items: ActivityItem[] | undefined
  * ```
  */
-declare function useTokenSwap(handler: TokenSwapHandler): UseAsyncTask<UseTokenSwapRequest, SwapReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
-type CancelSwapHandler = (data: SwapTypedData | TransactionRequest, options: SwapHandlerOptions) => ResultAsync<PendingTransaction | Signature, SwapSignerError>;
-declare class CannotCancelSwapError extends ResultAwareError {
-    name: "CannotCancelSwapError";
-}
-type CancelSwapError = CancelError | CannotCancelSwapError | SigningError | TimeoutError | TransactionError | UnexpectedError$1;
+declare function useActivities(args: Pausable<UseActivitiesArgs> & Suspendable): PausableSuspenseResult<PaginatedActivitiesResult>;
 /**
- * Executes the complete swap cancellation workflow combining preparation and execution.
+ * Fetch paginated list of activities.
  *
  * ```tsx
- * const [sendTransaction] = useSendTransaction(wallet);
- * const [signTypedData] = useSignTypedData(wallet);
- *
- * const [cancelSwap, { loading, error }] = useCancelSwap((plan) => {
- *   switch (plan.__typename) {
- *     case 'TransactionRequest':
- *       return sendTransaction(plan);
- *
- *     case 'SwapTypedData':
- *       return signTypedData(plan);
- *   }
- * });
- *
- * const result = await cancelSwap({
- *   id: swapId('123…'),
+ * const { data, error, loading } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
  * });
- *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
- *
- * // result.value: SwapCancelledResult
- * console.log('Swap cancelled:', result.value);
  * ```
  */
-declare function useCancelSwap(handler: CancelSwapHandler): UseAsyncTask<PrepareSwapCancelRequest, SwapCancelledResult, CancelSwapError>;
-
+declare function useActivities(args: UseActivitiesArgs): ReadResult<PaginatedActivitiesResult>;
 /**
- * A hook that provides a way to supply assets to an Aave reserve.
- *
- * ```ts
- * const [sendTransaction] = useSendTransaction(wallet);
- * const [supply, { loading, error }] = useSupply((plan, { cancel }) => {
- *   switch (plan.__typename) {
- *     case 'TransactionRequest':
- *       return sendTransaction(plan);
+ * Fetch paginated list of activities.
  *
- *     case 'Erc20Approval':
- *       return sendTransaction(plan.byTransaction);
+ * Pausable loading state mode.
  *
- *     case 'PreContractActionRequired':
- *       return sendTransaction(plan.transaction);
- *   }
+ * ```tsx
+ * const { data, error, loading } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   pause: true,
  * });
  *
- * // …
- *
- * const result = await supply({ ... });
- *
- * if (result.isErr()) {
- *   switch (result.error.name) {
- *     case 'CancelError':
- *       // The user cancelled the operation
- *       return;
- *
- *     case 'SigningError':
- *       console.error(`Failed to sign the transaction: ${result.error.message}`);
- *       break;
- *
- *     case 'TimeoutError':
- *       console.error(`Transaction timed out: ${result.error.message}`);
- *       break;
- *
- *     case 'TransactionError':
- *       console.error(`Transaction failed: ${result.error.message}`);
- *       break;
- *
- *     case 'ValidationError':
- *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
- *       break;
- *
- *     case 'UnexpectedError':
- *       console.error(result.error.message);
- *       break;
- *   }
- *   return;
- * }
- *
- * console.log('Transaction sent with hash:', result.value.txHash);
+ * // data?.items: ActivityItem[] | undefined
+ * // error: UnexpectedError | undefined
+ * // loading: boolean | undefined
  * ```
+ */
+declare function useActivities(args: Pausable<UseActivitiesArgs>): PausableReadResult<PaginatedActivitiesResult>;
+/**
+ * Low-level hook to execute a {@link activities} action directly.
  *
- * @param handler - The handler that will be used to handle the transactions.
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook does not actively watch for updates. Use it to fetch activities on demand
+ * (e.g., in an event handler when paginating or refining filters).
+ *
+ * @param options - The query options.
+ * @returns The user history.
  */
-declare function useSupply(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, Signature | PendingTransaction>): UseAsyncTask<SupplyRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+declare function useActivitiesAction(options?: CurrencyQueryOptions & TimeWindowQueryOptions): UseAsyncTask<ActivitiesRequest, PaginatedActivitiesResult, UnexpectedError>;
+
 /**
  * A hook that provides a way to borrow assets from an Aave reserve.
  *
@@ -2159,27 +2202,21 @@ declare function useSupply(handler: ExecutionPlanHandler<TransactionRequest | Er
  * @param handler - The handler that will be used to handle the transactions.
  */
 declare function useBorrow(handler: ExecutionPlanHandler<TransactionRequest | PreContractActionRequired, PendingTransaction>): UseAsyncTask<BorrowRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+
 /**
- * A hook that provides a way to repay borrowed assets to an Aave reserve.
+ * A hook that provides a way to claim rewards.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [repay, { loading, error }] = useRepay((plan, { cancel }) => {
- *   switch (plan.__typename) {
- *     case 'TransactionRequest':
- *       return sendTransaction(plan);
- *
- *     case 'Erc20Approval':
- *       return sendTransaction(plan.byTransaction);
- *
- *     case 'PreContractActionRequired':
- *       return sendTransaction(plan.transaction);
- *   }
+ * const [claim, { loading, error }] = useClaimRewards((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
  * });
  *
  * // …
  *
- * const result = await repay({ ... });
+ * const result = await claim({
+ *   ids: [rewardId('abc123')],
+ * });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -2199,10 +2236,6 @@ declare function useBorrow(handler: ExecutionPlanHandler<TransactionRequest | Pr
  *       console.error(`Transaction failed: ${result.error.message}`);
  *       break;
  *
- *     case 'ValidationError':
- *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
- *       break;
- *
  *     case 'UnexpectedError':
  *       console.error(result.error.message);
  *       break;
@@ -2213,19 +2246,23 @@ declare function useBorrow(handler: ExecutionPlanHandler<TransactionRequest | Pr
  * console.log('Transaction sent with hash:', result.value.txHash);
  * ```
  *
- * @param handler - The handler that will be used to handle the transactions.
+ * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useRepay(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, Signature | PendingTransaction>): UseAsyncTask<RepayRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+declare function useClaimRewards(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<ClaimRewardsRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * A hook that provides a way to withdraw supplied assets from an Aave reserve.
+ * A hook that provides a way to liquidate a user's position.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [withdraw, { loading, error }] = useWithdraw((plan, { cancel }) => {
+ * const [liquidatePosition, { loading, error }] = useLiquidatePosition((plan, { cancel }) => {
  *   switch (plan.__typename) {
  *     case 'TransactionRequest':
  *       return sendTransaction(plan);
  *
+ *     case 'Erc20Approval':
+ *       return sendTransaction(plan.byTransaction);
+ *
  *     case 'PreContractActionRequired':
  *       return sendTransaction(plan.transaction);
  *   }
@@ -2233,7 +2270,13 @@ declare function useRepay(handler: ExecutionPlanHandler<TransactionRequest | Erc
  *
  * // …
  *
- * const result = await withdraw({ ... });
+ * const result = await liquidatePosition({
+ *   collateral: reserveId('SGVsbG8h'),
+ *   debt: reserveId('Q2lhbyE= '),
+ *   amount: amount,
+ *   liquidator: liquidator,
+ *   borrower: borrower,
+ * });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -2269,114 +2312,148 @@ declare function useRepay(handler: ExecutionPlanHandler<TransactionRequest | Erc
  *
  * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useWithdraw(handler: ExecutionPlanHandler<TransactionRequest | PreContractActionRequired, PendingTransaction>): UseAsyncTask<WithdrawRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+declare function useLiquidatePosition(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, PendingTransaction | Signature>): UseAsyncTask<LiquidatePositionRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+
 /**
- * A hook that provides a way to renounce a position manager of a user for a specific spoke.
+ * Preview the impact of a potential action on a user's position.
  *
- * ```ts
- * const [sendTransaction] = useSendTransaction(wallet);
- * const [renounceSpokeUserPositionManager, { loading, error }] = useRenounceSpokeUserPositionManager(sendTransaction);
+ * ```tsx
+ * const [getPreview, previewing] = usePreviewAction();
+ *
+ * const loading = previewing.loading;
+ * const error = previewing.error;
  *
  * // …
  *
- * const result = await renounceSpokeUserPositionManager({ ... });
+ * const result = await getPreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           value: '1000',
+ *         },
+ *       },
+ *       sender: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ * });
  *
  * if (result.isErr()) {
- *   switch (result.error.name) {
- *     case 'CancelError':
- *       // The user cancelled the operation
- *       return;
- *
- *     case 'SigningError':
- *       console.error(`Failed to sign the transaction: ${result.error.message}`);
- *       break;
- *
- *     case 'TimeoutError':
- *       console.error(`Transaction timed out: ${result.error.message}`);
- *       break;
- *
- *     case 'TransactionError':
- *       console.error(`Transaction failed: ${result.error.message}`);
- *       break;
- *
- *     case 'UnexpectedError':
- *       console.error(result.error.message);
- *       break;
- *   }
+ *   console.error(result.error);
  *   return;
  * }
  *
- * console.log('Transaction sent with hash:', result.value.txHash);
+ * console.log('Preview result:', result.value);
  * ```
- *
- * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useRenounceSpokeUserPositionManager(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<RenounceSpokeUserPositionManagerRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+declare function usePreviewAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<PreviewRequest, PreviewUserPosition, UnexpectedError>;
+type UsePreviewArgs = Prettify<PreviewRequest & CurrencyQueryOptions>;
 /**
- * Hook for updating user position conditions (dynamic config and/or risk premium).
- *
- * ```ts
- * const [sendTransaction] = useSendTransaction(wallet);
- * const [update, { loading, error }] = useUpdateUserPositionConditions((transaction, { cancel }) => {
- *   return sendTransaction(transaction);
- * });
- *
- * // …
+ * Fetch a preview of the impact of a potential action on a user's position.
  *
- * const result = await update({
- *   userPositionId: userPosition.id,
- *   update: UserPositionConditionsUpdate.AllDynamicConfig,
- * });
+ * This signature supports React Suspense:
  *
- * if (result.isErr()) {
- *   switch (result.error.name) {
- *     case 'CancelError':
- *       // The user cancelled the operation
- *       return;
+ * ```tsx
+ * const { data } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function usePreview(args: UsePreviewArgs & Suspendable): SuspenseResult<PreviewUserPosition>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
  *
- *     case 'SigningError':
- *       console.error(`Failed to sign the transaction: ${result.error.message}`);
- *       break;
+ * Pausable suspense mode.
  *
- *     case 'TimeoutError':
- *       console.error(`Transaction timed out: ${result.error.message}`);
- *       break;
+ * ```tsx
+ * const { data } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function usePreview(args: Pausable<UsePreviewArgs> & Suspendable): PausableSuspenseResult<PreviewUserPosition>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
  *
- *     case 'TransactionError':
- *       console.error(`Transaction failed: ${result.error.message}`);
- *       break;
+ * ```tsx
+ * const { data, error, loading } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare function usePreview(args: UsePreviewArgs): ReadResult<PreviewUserPosition>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
  *
- *     case 'UnexpectedError':
- *       console.error(result.error.message);
- *       break;
- *   }
- *   return;
- * }
+ * Pausable loading state mode.
  *
- * console.log('Transaction sent with hash:', result.value.txHash);
+ * ```tsx
+ * const { data, error, loading, paused } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   pause: true,
+ * });
  * ```
- *
- * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useUpdateUserPositionConditions(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<UpdateUserPositionConditionsRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+declare function usePreview(args: Pausable<UsePreviewArgs>): PausableReadResult<PreviewUserPosition>;
+
 /**
- * Hook for updating the collateral status of user's supplies.
+ * A hook that provides a way to renounce a position manager of a user for a specific spoke.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [setUserSuppliesAsCollateral, { loading, error }] = useSetUserSuppliesAsCollateral((transaction, { cancel }) => {
- *   return sendTransaction(transaction);
- * });
+ * const [renounceSpokeUserPositionManager, { loading, error }] = useRenounceSpokeUserPositionManager(sendTransaction);
  *
- * const result = await setUserSuppliesAsCollateral({
- *   changes: [
- *     {
- *       reserve: reserve.id,
- *       enableCollateral: true
- *     }
- *   ],
- *   sender: evmAddress('0x456...')
- * });
+ * // …
+ *
+ * const result = await renounceSpokeUserPositionManager({ ... });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -2408,13 +2485,14 @@ declare function useUpdateUserPositionConditions(handler: ExecutionPlanHandler<T
  *
  * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useSetUserSuppliesAsCollateral(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<SetUserSuppliesAsCollateralRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+declare function useRenounceSpokeUserPositionManager(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<RenounceSpokeUserPositionManagerRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * A hook that provides a way to liquidate a user's position.
+ * A hook that provides a way to repay borrowed assets to an Aave reserve.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [liquidatePosition, { loading, error }] = useLiquidatePosition((plan, { cancel }) => {
+ * const [repay, { loading, error }] = useRepay((plan, { cancel }) => {
  *   switch (plan.__typename) {
  *     case 'TransactionRequest':
  *       return sendTransaction(plan);
@@ -2429,13 +2507,7 @@ declare function useSetUserSuppliesAsCollateral(handler: ExecutionPlanHandler<Tr
  *
  * // …
  *
- * const result = await liquidatePosition({
- *   collateral: reserveId('SGVsbG8h'),
- *   debt: reserveId('Q2lhbyE= '),
- *   amount: amount,
- *   liquidator: liquidator,
- *   borrower: borrower,
- * });
+ * const result = await repay({ ... });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -2471,7 +2543,8 @@ declare function useSetUserSuppliesAsCollateral(handler: ExecutionPlanHandler<Tr
  *
  * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useLiquidatePosition(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, PendingTransaction | Signature>): UseAsyncTask<LiquidatePositionRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+declare function useRepay(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, Signature | PendingTransaction>): UseAsyncTask<RepayRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+
 /**
  * A hook that provides a way to set or remove a position manager for a user on a specific spoke.
  *
@@ -2534,232 +2607,182 @@ declare function useLiquidatePosition(handler: ExecutionPlanHandler<TransactionR
  * @param handler - The handler that will be used to handle the transaction.
  */
 declare function useSetSpokeUserPositionManager(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<SetSpokeUserPositionManagerRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * Preview the impact of a potential action on a user's position.
- *
- * ```tsx
- * const [getPreview, previewing] = usePreviewAction();
- *
- * const loading = previewing.loading;
- * const error = previewing.error;
+ * Hook for updating the collateral status of user's supplies.
  *
- * // …
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [setUserSuppliesAsCollateral, { loading, error }] = useSetUserSuppliesAsCollateral((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
+ * });
  *
- * const result = await getPreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           value: '1000',
- *         },
- *       },
- *       sender: evmAddress('0x9abc…'),
- *     },
- *   },
+ * const result = await setUserSuppliesAsCollateral({
+ *   changes: [
+ *     {
+ *       reserve: reserve.id,
+ *       enableCollateral: true
+ *     }
+ *   ],
+ *   sender: evmAddress('0x456...')
  * });
  *
  * if (result.isErr()) {
- *   console.error(result.error);
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
  *   return;
  * }
  *
- * console.log('Preview result:', result.value);
+ * console.log('Transaction sent with hash:', result.value.txHash);
  * ```
- */
-declare function usePreviewAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<PreviewRequest, PreviewUserPosition, UnexpectedError>;
-type UsePreviewArgs = Prettify<PreviewRequest & CurrencyQueryOptions>;
-/**
- * Fetch a preview of the impact of a potential action on a user's position.
  *
- * This signature supports React Suspense:
- *
- * ```tsx
- * const { data } = usePreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       supplier: evmAddress('0x9abc…'),
- *     },
- *   },
- *   suspense: true,
- * });
- * ```
+ * @param handler - The handler that will be used to handle the transaction.
  */
-declare function usePreview(args: UsePreviewArgs & Suspendable): SuspenseResult<PreviewUserPosition>;
+declare function useSetUserSuppliesAsCollateral(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<SetUserSuppliesAsCollateralRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * Fetch a preview of the impact of a potential action on a user's position.
+ * A hook that provides a way to supply assets to an Aave reserve.
  *
- * Pausable suspense mode.
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [supply, { loading, error }] = useSupply((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
  *
- * ```tsx
- * const { data } = usePreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       supplier: evmAddress('0x9abc…'),
- *     },
- *   },
- *   suspense: true,
- *   pause: true,
- * });
- * ```
- */
-declare function usePreview(args: Pausable<UsePreviewArgs> & Suspendable): PausableSuspenseResult<PreviewUserPosition>;
-/**
- * Fetch a preview of the impact of a potential action on a user's position.
+ *     case 'Erc20Approval':
+ *       return sendTransaction(plan.byTransaction);
  *
- * ```tsx
- * const { data, error, loading } = usePreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       supplier: evmAddress('0x9abc…'),
- *     },
- *   },
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
  * });
- * ```
- */
-declare function usePreview(args: UsePreviewArgs): ReadResult<PreviewUserPosition>;
-/**
- * Fetch a preview of the impact of a potential action on a user's position.
  *
- * Pausable loading state mode.
+ * // …
  *
- * ```tsx
- * const { data, error, loading, paused } = usePreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       supplier: evmAddress('0x9abc…'),
- *     },
- *   },
- *   pause: true,
- * });
- * ```
- */
-declare function usePreview(args: Pausable<UsePreviewArgs>): PausableReadResult<PreviewUserPosition>;
-type UseActivitiesArgs = Prettify<ActivitiesRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
-/**
- * Fetch paginated list of activities.
+ * const result = await supply({ ... });
  *
- * This signature supports React Suspense:
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
  *
- * ```tsx
- * const { data } = useActivities({
- *   query: {
- *     chainId: chainId(1),
- *   },
- *   user: evmAddress('0x742d35cc…'),
- *   suspense: true,
- * });
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
  *
- * // data.items: ActivityItem[]
- * ```
- */
-declare function useActivities(args: UseActivitiesArgs & Suspendable): SuspenseResult<PaginatedActivitiesResult>;
-/**
- * Fetch paginated list of activities.
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
  *
- * Pausable suspense mode.
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
  *
- * ```tsx
- * const { data } = useActivities({
- *   query: {
- *     chainId: chainId(1),
- *   },
- *   user: evmAddress('0x742d35cc…'),
- *   suspense: true,
- *   pause: true,
- * });
+ *     case 'ValidationError':
+ *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
+ *       break;
  *
- * // data?.items: ActivityItem[] | undefined
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value.txHash);
  * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useActivities(args: Pausable<UseActivitiesArgs> & Suspendable): PausableSuspenseResult<PaginatedActivitiesResult>;
+declare function useSupply(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, Signature | PendingTransaction>): UseAsyncTask<SupplyRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+
 /**
- * Fetch paginated list of activities.
+ * Hook for updating user position conditions (dynamic config and/or risk premium).
  *
- * ```tsx
- * const { data, error, loading } = useActivities({
- *   query: {
- *     chainId: chainId(1),
- *   },
- *   user: evmAddress('0x742d35cc…'),
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [update, { loading, error }] = useUpdateUserPositionConditions((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
  * });
- * ```
- */
-declare function useActivities(args: UseActivitiesArgs): ReadResult<PaginatedActivitiesResult>;
-/**
- * Fetch paginated list of activities.
  *
- * Pausable loading state mode.
+ * // …
  *
- * ```tsx
- * const { data, error, loading } = useActivities({
- *   query: {
- *     chainId: chainId(1),
- *   },
- *   user: evmAddress('0x742d35cc…'),
- *   pause: true,
+ * const result = await update({
+ *   userPositionId: userPosition.id,
+ *   update: UserPositionConditionsUpdate.AllDynamicConfig,
  * });
  *
- * // data?.items: ActivityItem[] | undefined
- * // error: UnexpectedError | undefined
- * // loading: boolean | undefined
- * ```
- */
-declare function useActivities(args: Pausable<UseActivitiesArgs>): PausableReadResult<PaginatedActivitiesResult>;
-/**
- * Low-level hook to execute a {@link activities} action directly.
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
  *
- * @experimental This hook is experimental and may be subject to breaking changes.
- * @remarks
- * This hook does not actively watch for updates. Use it to fetch activities on demand
- * (e.g., in an event handler when paginating or refining filters).
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
  *
- * @param options - The query options.
- * @returns The user history.
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value.txHash);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useActivitiesAction(options?: CurrencyQueryOptions & TimeWindowQueryOptions): UseAsyncTask<ActivitiesRequest, PaginatedActivitiesResult, UnexpectedError>;
+declare function useUpdateUserPositionConditions(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<UpdateUserPositionConditionsRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * A hook that provides a way to claim rewards.
+ * A hook that provides a way to withdraw supplied assets from an Aave reserve.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [claim, { loading, error }] = useClaimRewards((transaction, { cancel }) => {
- *   return sendTransaction(transaction);
+ * const [withdraw, { loading, error }] = useWithdraw((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
  * });
  *
  * // …
  *
- * const result = await claim({
- *   ids: [rewardId('abc123')],
- * });
+ * const result = await withdraw({ ... });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -2779,6 +2802,10 @@ declare function useActivitiesAction(options?: CurrencyQueryOptions & TimeWindow
  *       console.error(`Transaction failed: ${result.error.message}`);
  *       break;
  *
+ *     case 'ValidationError':
+ *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
+ *       break;
+ *
  *     case 'UnexpectedError':
  *       console.error(result.error.message);
  *       break;
@@ -2789,9 +2816,9 @@ declare function useActivitiesAction(options?: CurrencyQueryOptions & TimeWindow
  * console.log('Transaction sent with hash:', result.value.txHash);
  * ```
  *
- * @param handler - The handler that will be used to handle the transaction.
+ * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useClaimRewards(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<ClaimRewardsRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+declare function useWithdraw(handler: ExecutionPlanHandler<TransactionRequest | PreContractActionRequired, PendingTransaction>): UseAsyncTask<WithdrawRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
 
 type UseUserSuppliesArgs = Prettify<UserSuppliesRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**