AaveKit React Hooks Reference

Reference for all public AaveKit React hooks for Aave V4.

useActivities

Declarative hook to fetch paginated list of user activities.

import { useActivities } from "@aave/react";

const { data, loading, error } = useActivities({
  pause,
  ...request,
});

const { data } = useActivities({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: ActivitiesRequestQuery one of:
  • hub: HubInput - Fetch by hub
  • spoke: SpokeInput - Fetch by spoke
  • chainIds: [ChainId!] - Fetch by chain IDs
  • txHash: TxHashInput - Fetch by transaction hash
• request.user?: EvmAddress - User address (optional)
• request.currency?: Currency - Currency for value conversions (default: USD)
• pause?: boolean - Pause the query (default: false)

Returns:

• data?.items: ActivityItem[] - List of activities
• data?.pageInfo: PageInfo - Pagination information
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the activities

useActivitiesAction

Imperative hook to fetch paginated list of user activities.

import { useActivitiesAction } from "@aave/react";

const [execute, state] = useActivitiesAction(options);

const result = await execute(request);

Options:

• options.currency?: Currency - Currency for value conversions (default: USD)

Arguments:

• request.query: ActivitiesRequestQuery one of:
  • hub: HubInput - Fetch by hub
  • spoke: SpokeInput - Fetch by spoke
  • chainIds: [ChainId!] - Fetch by chain IDs
  • txHash: TxHashInput - Fetch by transaction hash
• request.user?: EvmAddress - User address (optional)

Returns:

• state.loading: boolean - Loading state
• state.error: UnexpectedError | undefined - Error fetching the activities
• state.called: boolean - Whether the hook has been called
• state.data: PaginatedActivitiesResult | undefined - Paginated activities result
• result: Result<PaginatedActivitiesResult, UnexpectedError> - Type-safe success or failure value:
  • Ok<PaginatedActivitiesResult> - Paginated activities result
  • Err<UnexpectedError> - Error fetching the activities

useAsset

Declarative hook to fetch information about a specific asset (ERC-20 token).

import { useAsset } from "@aave/react";

const { data, loading, error } = useAsset({
  pause,
  ...request,
});

const { data } = useAsset({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: AssetRequestQuery one of:
  • token: Erc20Input - ERC-20 token
    • address: EvmAddress - Token contract address
    • chainId: ChainId - Chain ID where the token exists
  • assetId: AssetId - Asset ID
• request.currency?: Currency - Currency for value conversions (optional)
• request.timeWindow?: TimeWindow - Time window for historical data (optional)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: Asset | null | undefined - Asset information or null if not found
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the asset

useAssetBorrowHistory

Declarative hook to fetch historical borrow data for an asset.

import { useAssetBorrowHistory } from "@aave/react";

const { data, loading, error } = useAssetBorrowHistory({
  pause,
  ...request,
});

const { data } = useAssetBorrowHistory({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: AssetBorrowHistoryRequestQuery one of:
  • token: Erc20Input - ERC-20 token (address, chainId)
  • assetId: AssetId - Asset ID
• request.window: TimeWindow - Time window for historical data
• pause?: boolean - Pause the query (default: false)

Returns:

• data: AssetBorrowSample[] | undefined - Array of historical borrow data points
  • data[].date: Date - Sample date
  • data[].amount: DecimalNumber - Total borrowed amount
  • data[].highestApy: PercentNumber - Highest borrow APY across hubs
  • data[].lowestApy: PercentNumber - Lowest borrow APY across hubs
  • data[].averageApy: PercentNumber - Average borrow APY across all hubs
  • data[].breakdown: AssetSampleBreakdown[] - Per-hub APY breakdown
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the borrow history

useAssetPriceHistory

Declarative hook to fetch historical price data for an asset.

import { useAssetPriceHistory } from "@aave/react";

const { data, loading, error } = useAssetPriceHistory({
  pause,
  ...request,
});

const { data } = useAssetPriceHistory({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: AssetPriceHistoryRequestQuery one of:
  • token: Erc20Input - ERC-20 token (address, chainId)
  • assetId: AssetId - Asset ID
• request.currency: Currency - Currency for the data
• request.window: TimeWindow - Time window for historical data
• pause?: boolean - Pause the query (default: false)

Returns:

• data: AssetPriceSample[] | undefined - Array of historical price data points
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the price history

useAssetSupplyHistory

Declarative hook to fetch historical supply data for an asset.

import { useAssetSupplyHistory } from "@aave/react";

const { data, loading, error } = useAssetSupplyHistory({
  pause,
  ...request,
});

const { data } = useAssetSupplyHistory({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: AssetSupplyHistoryRequestQuery one of:
  • token: Erc20Input - ERC-20 token (address, chainId)
  • assetId: AssetId - Asset ID
• request.window: TimeWindow - Time window for historical data
• pause?: boolean - Pause the query (default: false)

Returns:

• data: AssetSupplySample[] | undefined - Array of historical supply data points
  • data[].date: Date - Sample date
  • data[].amount: DecimalNumber - Total supplied amount
  • data[].highestApy: PercentNumber - Highest supply APY across hubs
  • data[].lowestApy: PercentNumber - Lowest supply APY across hubs
  • data[].averageApy: PercentNumber - Average supply APY across all hubs
  • data[].breakdown: AssetSampleBreakdown[] - Per-hub APY breakdown
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the supply history

useBorrow

Imperative transaction hook to borrow assets from the protocol.

import { useBorrow } from "@aave/react";

const [execute, state] = useBorrow((plan) => {
  switch (plan.__typename) {
    case "TransactionRequest":
      return sendTransaction(plan);
    case "PreContractActionRequired":
      return sendTransaction(plan.transaction);
  }
});

const result = await execute(request);

Arguments:

• request.reserve: ReserveId - Reserve ID
• request.amount: ReserveAmountInput one of:
  • erc20: { value: BigDecimal } - ERC-20 amount, e.g. { erc20: { value: bigDecimal("100") } }
  • native: BigDecimal - Native token amount
• request.sender: EvmAddress - Borrower address

Returns:

• state.loading: boolean - Loading state
• state.error: E | undefined - Error executing the transaction
• state.called: boolean - Whether the hook has been called
• state.data: TransactionReceipt | undefined - Transaction receipt
• result: Result<TransactionReceipt, E> - Type-safe success or failure value:
  • Ok<TransactionReceipt> - Transaction receipt
  • Err<E> - Error executing the transaction

Where E is one of:

• CancelError
• SigningError
• TimeoutError
• TransactionError
• UnexpectedError
• ValidationError<InsufficientBalanceError>

useBorrowApyHistory

Declarative hook to fetch borrow APY history for a specific reserve over time.

import { useBorrowApyHistory } from "@aave/react";

const { data, loading, error } = useBorrowApyHistory({
  pause,
  ...request,
});

const { data } = useBorrowApyHistory({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.reserve: ReserveId - Reserve ID
• request.window?: TimeWindow - Time window for historical data (default: LAST_DAY)
• request.includeRewards?: boolean - Include Merkl rewards in the rates (default: true)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: ApySample[] | undefined - Array of historical APY data points
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the borrow APY history

useBorrowSwapOrder

Imperative hook to execute a borrow (debt) swap through the Order API. It fetches a quote, collects the position-swap approval signatures, then prepares, signs, and submits the order.

import { useBorrowSwapOrder } from "@aave/react";

const [execute, state] = useBorrowSwapOrder((plan) => {
  switch (plan.__typename) {
    case "PositionSwapAdapterContractApproval":
    case "PositionSwapPositionManagerApproval":
    case "PositionSwapSetCollateralApproval":
      return signTypedData(plan.bySignature);
    case "OrderTypedData":
      return signTypedData(plan);
    case "OrderTransactionRequest":
      return sendTransaction(plan.transaction);
  }
});

const result = await execute(request);

Arguments:

• request: BorrowSwapQuoteRequest one of:
  • market: MarketDebtSwapQuoteInput - Market order quote
  • limit: LimitDebtSwapQuoteInput - Limit order quote
  • fromQuote: FromQuoteDebtSwapQuoteInput - Quote from an existing quote ID (quoteId)
• request.currency?: Currency - Currency for value conversions (default: USD)

Returns:

• state.loading: boolean - Loading state
• state.error: E | undefined - Error executing the order
• state.called: boolean - Whether the hook has been called
• state.data: OrderReceipt | undefined - Order receipt with the orderId
• result: Result<OrderReceipt, E> - Type-safe success or failure value:
  • Ok<OrderReceipt> - Order receipt with the orderId
  • Err<E> - Error executing the order

Where E is one of:

• CancelError
• SigningError
• TimeoutError
• TransactionError
• UnexpectedError
• ValidationError<InsufficientBalanceError | InsufficientLiquidityError>

useBorrowSwapQuote

Declarative hook to fetch a quote for a borrow (debt) swap.

import { useBorrowSwapQuote } from "@aave/react";

const { data, loading, error } = useBorrowSwapQuote({
  pause,
  ...request,
});

const { data } = useBorrowSwapQuote({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request: BorrowSwapQuoteRequest one of:
  • market: MarketDebtSwapQuoteInput - Market order quote
  • limit: LimitDebtSwapQuoteInput - Limit order quote
  • fromQuote: FromQuoteDebtSwapQuoteInput - Quote from an existing quote ID (quoteId)
• request.currency?: Currency - Currency for value conversions (default: USD)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: SwapQuote | undefined - Swap quote
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the quote

useBorrowSwapQuoteAction

Imperative hook to fetch a quote for a borrow (debt) swap.

import { useBorrowSwapQuoteAction } from "@aave/react";

const [execute, state] = useBorrowSwapQuoteAction(options);

const result = await execute(request);

Options:

• options.currency?: Currency - Currency for value conversions (default: USD)

Arguments:

• request: BorrowSwapQuoteRequest one of:
  • market: MarketDebtSwapQuoteInput - Market order quote
  • limit: LimitDebtSwapQuoteInput - Limit order quote
  • fromQuote: FromQuoteDebtSwapQuoteInput - Quote from an existing quote ID (quoteId)

Returns:

• state.loading: boolean - Loading state
• state.error: E | undefined - Error fetching the quote
• state.called: boolean - Whether the hook has been called
• state.data: SwapQuote | undefined - Swap quote
• result: Result<SwapQuote, E> - Type-safe success or failure value:
  • Ok<SwapQuote> - Swap quote
  • Err<E> - Error fetching the quote

Where E is one of:

• UnexpectedError
• ValidationError<InsufficientLiquidityError>

useCancelOrder

Imperative hook to cancel an open order.

import { useCancelOrder } from "@aave/react";

const [execute, state] = useCancelOrder((plan) => {
  switch (plan.__typename) {
    case "TransactionRequest":
      return sendTransaction(plan);
    case "OrderTypedData":
      return signTypedData(plan);
  }
});

const result = await execute(request);

Arguments:

• request.id: OrderId - Order ID to cancel

Returns:

• state.loading: boolean - Loading state
• state.error: CancelOrderError | undefined - Error cancelling the order
• state.called: boolean - Whether the hook has been called
• state.data: OrderCancelledResult | undefined - Cancelled order with the orderId
• result: Result<OrderCancelledResult, CancelOrderError> - Type-safe success or failure value:
  • Ok<OrderCancelledResult> - Cancelled order with the orderId
  • Err<CancelOrderError> - Error cancelling the order

Where CancelOrderError is one of:

• CancelError
• CannotCancelOrderError
• SigningError
• TimeoutError
• TransactionError
• UnexpectedError

useChain

Declarative hook to fetch a specific chain by ID.

import { useChain } from "@aave/react";

const { data, loading, error } = useChain({
  pause,
  ...request,
});

const { data } = useChain({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.chainId: ChainId - Chain ID to query
• pause?: boolean - Pause the query (default: false)

Returns:

• data: Chain | null | undefined - Chain information or null if not found
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the chain

useChainAction

Imperative hook to fetch chain data on demand. Does not watch for updated data; use it to retrieve data as part of a larger workflow.

import { useChainAction } from "@aave/react";

const [execute, state] = useChainAction();

const result = await execute(request);

Arguments:

• request.chainId: ChainId - Chain ID

Returns:

• state.loading: boolean - Loading state
• state.error: UnexpectedError | undefined - Error fetching the chain
• state.called: boolean - Whether the hook has been called
• state.data: Chain | null | undefined - Chain data or null if not found
• result: Result<Chain | null, UnexpectedError> - Type-safe success or failure value:
  • Ok<Chain | null> - Chain data or null if not found
  • Err<UnexpectedError> - Error fetching the chain

useChains

Declarative hook to fetch all supported chains.

import { useChains } from "@aave/react";
import { ChainsFilter } from "@aave/react";

const { data, loading, error } = useChains({
  query: { filter: ChainsFilter.ALL },
  pause,
});

import { useChains } from "@aave/react";
import { ChainsFilter } from "@aave/react";

const { data } = useChains({
  query: { filter: ChainsFilter.ALL },
  pause,
  suspense: true,
});

Arguments:

• request.query: ChainsRequestQuery one of:
  • filter: ChainsFilter - Filter for chains (e.g., ChainsFilter.ALL)
  • chainIds: [ChainId!] - Fetch by chain IDs
• pause?: boolean - Pause the query (default: false)

Returns:

• data: Chain[] | undefined - Array of supported chains
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the chains

useClaimRewards

Imperative transaction hook to claim rewards for a user on a specific chain.

import { useClaimRewards } from "@aave/react";

const [execute, state] = useClaimRewards((transaction) =>
  sendTransaction(transaction),
);

const result = await execute(request);

Arguments:

• request.ids: [RewardId!] - Reward IDs to claim
• request.user: EvmAddress - User claiming the rewards
• request.chainId: ChainId - Chain to claim on

Returns:

• state.loading: boolean - Loading state
• state.error: E | undefined - Error executing the transaction
• state.called: boolean - Whether the hook has been called
• state.data: TransactionReceipt | undefined - Transaction receipt
• result: Result<TransactionReceipt, E> - Type-safe success or failure value:
  • Ok<TransactionReceipt> - Transaction receipt
  • Err<E> - Error executing the transaction

Where E is one of:

• CancelError
• SigningError
• TimeoutError
• TransactionError
• UnexpectedError

useExchangeRate

Declarative hook to fetch the current exchange rate between two currencies.

import { useExchangeRate } from "@aave/react";

const { data, loading, error } = useExchangeRate({
  pause,
  ...request,
});

const { data } = useExchangeRate({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.from: AssetInput - Source asset (erc20 or native)
• request.to: Currency - Target currency
• pause?: boolean - Pause the query (default: false)

Returns:

• data: ExchangeAmount | undefined - Exchange rate value
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the exchange rate

useExchangeRateAction

Imperative hook to fetch exchange rate between two currencies.

import { useExchangeRateAction } from "@aave/react";

const [execute, state] = useExchangeRateAction();

const result = await execute(request);

Arguments:

• request.from: AssetInput - Source asset (erc20 or native)
• request.to: Currency - Target currency
• request.at?: Date - Historical date (optional)

Returns:

• state.loading: boolean - Loading state
• state.error: UnexpectedError | undefined - Error fetching the exchange rate
• state.called: boolean - Whether the hook has been called
• state.data: ExchangeAmount | undefined - Exchange rate value
• result: Result<ExchangeAmount, UnexpectedError> - Type-safe success or failure value:
  • Ok<ExchangeAmount> - Exchange rate value
  • Err<UnexpectedError> - Error fetching the exchange rate

useHub

Declarative hook to fetch a specific hub by address and chain ID.

import { useHub } from "@aave/react";

const { data, loading, error } = useHub({
  pause,
  ...request,
});

const { data } = useHub({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: HubRequestQuery one of:
  • hubInput: HubInput - Hub address and chain ID
    • address: EvmAddress - Hub contract address
    • chainId: ChainId - Chain ID where the hub exists
  • hubId: HubId - Hub ID
• request.currency?: Currency - Currency for value conversions (optional)
• request.timeWindow?: TimeWindow - Time window for change values (optional)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: Hub | null | undefined - Hub information or null if not found
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the hub

useHubAssetInterestRateModel

Declarative hook to fetch the interest rate model curve for a specific Hub Asset.

import { useHubAssetInterestRateModel } from "@aave/react";

const { data, loading, error } = useHubAssetInterestRateModel({
  pause,
  ...request,
});

const { data } = useHubAssetInterestRateModel({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: HubAssetInterestRateModelRequestQuery:
  • hubAssetId: HubAssetId - Hub Asset ID
• request.currency?: Currency - Currency for value conversions (optional)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: HubAssetInterestRateModelPoint[] | undefined - Array of interest rate model data points
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the interest rate model

useHubAssetInterestRateModelAction

Imperative hook to fetch interest rate model data for a Hub Asset.

import { useHubAssetInterestRateModelAction } from "@aave/react";

const [execute, state] = useHubAssetInterestRateModelAction(options);

const result = await execute(request);

Options:

• options.currency?: Currency - Currency for value conversions (default: USD)

Arguments:

• request.query: HubAssetInterestRateModelRequestQuery:
  • hubAssetId: HubAssetId - Hub Asset ID

Returns:

• state.loading: boolean - Loading state
• state.error: UnexpectedError | undefined - Error fetching the interest rate model
• state.called: boolean - Whether the hook has been called
• state.data: HubAssetInterestRateModelPoint[] | undefined - Array of interest rate model data points
• result: Result<HubAssetInterestRateModelPoint[], UnexpectedError> - Type-safe success or failure value:
  • Ok<HubAssetInterestRateModelPoint[]> - Array of interest rate model data points
  • Err<UnexpectedError> - Error fetching the interest rate model

useHubAssets

Declarative hook to fetch Hub Assets for a specific chain and optional hub/user filtering.

import { useHubAssets } from "@aave/react";

const { data, loading, error } = useHubAssets({
  pause,
  ...request,
});

const { data } = useHubAssets({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: HubAssetsRequestQuery one of:
  • hubInput: HubInput - Hub address and chain ID
    • address: EvmAddress - Hub contract address
    • chainId: ChainId - Chain ID
  • hubId: HubId - Hub ID
• request.user?: EvmAddress - Filter by user address (optional)
• request.orderBy?: HubAssetsRequestOrderBy one of:
  • assetName: OrderDirection - Sort by asset name
  • availableLiquidity: OrderDirection - Sort by available liquidity
  • supplyApy: OrderDirection - Sort by supply APY
  • borrowApy: OrderDirection - Sort by borrow APY
• request.currency?: Currency - Currency for value conversions (optional)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: HubAsset[] | undefined - Array of Hub Assets
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the Hub Assets

useHubs

Declarative hook to fetch all available hubs.

import { useHubs } from "@aave/react";

const { data, loading, error } = useHubs({
  pause,
  ...request,
});

const { data } = useHubs({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: HubsRequestQuery one of:
  • tokens: [Erc20Input!] - Filter by underlying tokens
    • address: EvmAddress - Token contract address
    • chainId: ChainId - Token chain ID
  • assetIds: [AssetId!] - Filter by asset IDs
  • chainIds: [ChainId!] - Filter by chain IDs
• request.orderBy?: HubsRequestOrderBy one of:
  • name: OrderDirection - Sort by hub name
  • totalBorrowed: OrderDirection - Sort by total borrowed amount
  • totalSupplied: OrderDirection - Sort by total supplied amount
• request.currency?: Currency - Currency for value conversions (optional)
• request.timeWindow?: TimeWindow - Time window for change values (optional)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: Hub[] | undefined - Array of hubs
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the hubs

useHubsAction

Imperative hook to fetch hubs data.

import { useHubsAction } from "@aave/react";

const [execute, state] = useHubsAction(options);

const result = await execute(request);

Options:

• options.currency?: Currency - Currency for value conversions (default: USD)

Arguments:

• request.query: HubsRequestQuery one of:
  • tokens: [Erc20Input!] - Filter by underlying tokens
    • address: EvmAddress - Token contract address
    • chainId: ChainId - Token chain ID
  • chainIds: [ChainId!] - Filter by chain IDs
• request.orderBy?: HubsRequestOrderBy one of:
  • name: OrderDirection - Sort by hub name
  • totalBorrowed: OrderDirection - Sort by total borrowed amount
  • totalSupplied: OrderDirection - Sort by total supplied amount

Returns:

• state.loading: boolean - Loading state
• state.error: UnexpectedError | undefined - Error fetching the hubs
• state.called: boolean - Whether the hook has been called
• state.data: Hub[] | undefined - Array of hubs
• result: Result<Hub[], UnexpectedError> - Type-safe success or failure value:
  • Ok<Hub[]> - Array of hubs
  • Err<UnexpectedError> - Error fetching the hubs

useHubSpokeConfigs

Declarative hook to fetch per-asset configuration for a specific hub and spoke pair.

import { useHubSpokeConfigs } from "@aave/react";

const { data, loading, error } = useHubSpokeConfigs({
  pause,
  ...request,
});

const { data } = useHubSpokeConfigs({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.hubId: HubId - Hub ID
• request.spokeId: SpokeId - Spoke ID
• request.currency?: Currency - Currency for nested amount conversions (default: USD)
• request.timeWindow?: TimeWindow - Time window for nested change calculations (default: LAST_DAY)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: HubSpokeConfig[] | undefined - Array of hub-spoke asset configurations
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the configs

useHubSummaryHistory

Declarative hook to fetch historical summary data for a specific hub.

import { useHubSummaryHistory } from "@aave/react";

const { data, loading, error } = useHubSummaryHistory({
  pause,
  ...request,
});

const { data } = useHubSummaryHistory({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: HubSummaryHistoryRequestQuery one of:
  • hubInput: HubInput - Hub address and chain ID
    • address: EvmAddress - Hub contract address
    • chainId: ChainId - Chain ID where the hub exists
  • hubId: HubId - Hub ID
• request.currency?: Currency - Currency for value conversions (default: USD)
• request.window?: TimeWindow - Time window for historical data (default: LAST_DAY)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: HubSummarySample[] | undefined - Array of historical hub summary data points
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the hub summary history

useLeverage

Imperative hook to open or increase a leveraged position through the Order API. It flash-loans the debt asset, swaps it into the collateral asset, supplies the collateral, then borrows the debt to repay the flash loan.

import { useLeverage } from "@aave/react";

const [execute, state] = useLeverage((plan) => {
  switch (plan.__typename) {
    case "OrderAdapterApproval":
    case "OrderPositionManagerApproval":
    case "OrderSetCollateralApproval":
      return signTypedData(plan.bySignature);
    case "OrderErc20Approval":
      return plan.byPermit
        ? signTypedData(plan.byPermit)
        : sendTransaction(plan.byTransaction);
    case "OrderTypedData":
      return signTypedData(plan);
    case "OrderTransactionRequest":
      return sendTransaction(plan.transaction);
  }
});

const result = await execute(request);

Arguments:

• request: LeverageQuoteRequest one of:
  • market: MarketLeverageQuoteInput - Market order quote
  • limit: LimitLeverageQuoteInput - Limit order quote
  • fromQuote: FromQuoteLeverageQuoteInput - Quote from an existing quote ID (quoteId)
• request.currency?: Currency - Currency for value conversions (default: USD)
• request.permitSig?: ERC20PermitSignature - Pre-built permit for the collateral top-up (optional; normally the handler signs it)

Returns:

• state.loading: boolean - Loading state
• state.error: E | undefined - Error executing the order
• state.called: boolean - Whether the hook has been called
• state.data: OrderReceipt | undefined - Order receipt with the orderId
• result: Result<OrderReceipt, E> - Type-safe success or failure value:
  • Ok<OrderReceipt> - Order receipt with the orderId
  • Err<E> - Error executing the order

Where E is one of:

• CancelError
• SigningError
• TimeoutError
• TransactionError
• UnexpectedError
• ValidationError<InsufficientBalanceError | InsufficientLiquidityError>

useLeverageQuote

Declarative hook to fetch a quote for a leverage operation.

import { useLeverageQuote } from "@aave/react";

const { data, loading, error } = useLeverageQuote({
  pause,
  ...request,
});

const { data } = useLeverageQuote({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request: LeverageQuoteRequest one of:
  • market: MarketLeverageQuoteInput - Market order quote
  • limit: LimitLeverageQuoteInput - Limit order quote
  • fromQuote: FromQuoteLeverageQuoteInput - Quote from an existing quote ID (quoteId)
• request.currency?: Currency - Currency for value conversions (default: USD)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: LeverageApprovalsRequired | undefined - Leverage quote, required approvals, and maxSafeMultiplier
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the quote

useLeverageQuoteAction

Imperative hook to fetch a quote for a leverage operation.

import { useLeverageQuoteAction } from "@aave/react";

const [execute, state] = useLeverageQuoteAction(options);

const result = await execute(request);

Options:

• options.currency?: Currency - Currency for value conversions (default: USD)

Arguments:

• request: LeverageQuoteRequest one of:
  • market: MarketLeverageQuoteInput - Market order quote
  • limit: LimitLeverageQuoteInput - Limit order quote
  • fromQuote: FromQuoteLeverageQuoteInput - Quote from an existing quote ID (quoteId)

Returns:

• state.loading: boolean - Loading state
• state.error: E | undefined - Error fetching the quote
• state.called: boolean - Whether the hook has been called
• state.data: LeverageApprovalsRequired | undefined - Leverage quote, required approvals, and maxSafeMultiplier
• result: Result<LeverageApprovalsRequired, E> - Type-safe success or failure value:
  • Ok<LeverageApprovalsRequired> - Leverage quote, required approvals, and maxSafeMultiplier
  • Err<E> - Error fetching the quote

Where E is one of:

• UnexpectedError
• ValidationError<InsufficientLiquidityError>

useLiquidatePosition

Imperative transaction hook to liquidate an undercollateralized position.

import { useLiquidatePosition } from "@aave/react";

const [execute, state] = useLiquidatePosition((plan) => {
  switch (plan.__typename) {
    case "TransactionRequest":
      return sendTransaction(plan);
    case "Erc20Approval":
      return sendTransaction(plan.byTransaction);
    case "PreContractActionRequired":
      return sendTransaction(plan.transaction);
  }
});

const result = await execute(request);

Arguments:

• request.collateral: ReserveId - Collateral reserve ID
• request.debt: ReserveId - Debt reserve ID
• request.amount: LiquidatePositionDebtAmount one of:
  • exact: { value: BigDecimal, permitSig?: ERC20PermitSignature } - Exact debt amount to cover
  • max: true - Cover the maximum liquidatable debt
• request.liquidator: EvmAddress - Liquidator address
• request.user: EvmAddress - User address to liquidate
• request.receiveShares?: boolean - Receive collateral shares instead of the underlying asset (default: false)

Returns:

• state.loading: boolean - Loading state
• state.error: E | undefined - Error executing the transaction
• state.called: boolean - Whether the hook has been called
• state.data: TransactionReceipt | undefined - Transaction receipt
• result: Result<TransactionReceipt, E> - Type-safe success or failure value:
  • Ok<TransactionReceipt> - Transaction receipt
  • Err<E> - Error executing the transaction

Where E is one of:

• CancelError
• SigningError
• TimeoutError
• TransactionError
• UnexpectedError
• ValidationError<InsufficientBalanceError>

useMultichainAsset

Declarative hook to fetch information about an asset (ERC-20 token) aggregated across multiple chains, matched by its token info ID or symbol.

import { useMultichainAsset } from "@aave/react";

const { data, loading, error } = useMultichainAsset({
  pause,
  ...request,
});

const { data } = useMultichainAsset({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: MultichainAssetRequestQuery one of:
  • tokenInfo: TokenInfoId - Token info ID
  • symbol: String - Token symbol (e.g. "USDC")
• request.chainIds?: [ChainId!] - Restrict aggregation to specific chains (optional)
• request.includeRewards?: boolean - Fold Merkl rewards into APY ranges (default: true)
• currency?: Currency - Currency for value conversions (default: USD)
• timeWindow?: TimeWindow - Time window for historical changes (default: LastDay)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: MultichainAsset | undefined - Aggregated asset data (assets and summary)
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the asset

useNetworkFee

Declarative hook to fetch the network fee for an activity (experimental).

import { useNetworkFee } from "@aave/react";

const { data, loading, error } = useNetworkFee({
  pause,
  ...request,
});

const { data } = useNetworkFee({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: UseNetworkFeeRequestQuery one of:
  • activity: ActivityItem - Calculate fee for past activity
  • estimate: PreviewAction - Estimate fee for preview action, one of:
    • supply: SupplyRequest - Supply action
    • borrow: BorrowRequest - Borrow action
    • repay: RepayRequest - Repay action
    • withdraw: WithdrawRequest - Withdraw action
    • setUserSuppliesAsCollateral: SetUserSuppliesAsCollateralRequest - Collateral changes
    • updateUserPositionConditions: UpdateUserPositionConditionsRequest - Position condition updates
• request.currency?: Currency - Currency for value conversions (optional)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: NativeAmount | undefined - Network fee amount
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the network fee

useOrderStatus

Declarative hook to monitor the status of an order. It polls until the order is fulfilled, cancelled, or expired.

import { useOrderStatus } from "@aave/react";

const { data, loading, error } = useOrderStatus({
  pause,
  ...request,
});

const { data } = useOrderStatus({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.id: OrderId - Order ID
• request.currency?: Currency - Currency for value conversions (default: USD)
• request.timeWindow?: TimeWindow - Time window for change values (optional)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: OrderStatus | undefined - Current order status, one of OrderOpen, OrderPendingSignature, OrderFulfilled, OrderCancelled, or OrderExpired
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the order status

usePendingOrders

Declarative hook to fetch a user’s orders on a chain.

import { usePendingOrders } from "@aave/react";

const { data, loading, error } = usePendingOrders({
  pause,
  ...request,
});

const { data } = usePendingOrders({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.chainId: ChainId - Chain ID
• request.user: EvmAddress - User address
• request.filterBy?: OrderStatusFilter[] - Filter by status: Open, PendingSignature, Fulfilled, Cancelled, or Expired (optional)
• request.pageSize?: PageSize - Page size (default: FIFTY)
• request.cursor?: Cursor - Pagination cursor (optional)
• request.currency?: Currency - Currency for value conversions (default: USD)
• request.timeWindow?: TimeWindow - Time window for change values (optional)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: PaginatedOrdersResult | undefined - Paginated orders (items: OrderStatus[], pageInfo)
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the orders

usePreview

Declarative hook to preview the outcome of a transaction before executing.

import { usePreview } from "@aave/react";

const { data, loading, error } = usePreview({
  pause,
  ...request,
});

const { data } = usePreview({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.action: PreviewActionInput one of:
  • supply: SupplyRequest - Preview a supply action
  • borrow: BorrowRequest - Preview a borrow action
  • repay: RepayRequest - Preview a repay action
  • withdraw: WithdrawRequest - Preview a withdraw action
  • setUserSuppliesAsCollateral: SetUserSuppliesAsCollateralRequest - Preview a collateral change
• request.currency?: Currency - Currency for value conversions (optional)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: PreviewUserPosition | undefined - Preview of user position after the action
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the preview

usePreviewAction

Imperative hook to preview the outcome of a transaction before executing.

import { usePreviewAction } from "@aave/react";

const [execute, state] = usePreviewAction(options);

const result = await execute(request);

Options:

• options.currency?: Currency - Currency for value conversions (default: USD)

Arguments:

• request.action: PreviewActionInput one of:
  • supply: SupplyRequest - Preview a supply action
  • borrow: BorrowRequest - Preview a borrow action
  • repay: RepayRequest - Preview a repay action
  • withdraw: WithdrawRequest - Preview a withdraw action
  • setUserSuppliesAsCollateral: SetUserSuppliesAsCollateralRequest - Preview a collateral change

Returns:

• state.loading: boolean - Loading state
• state.error: UnexpectedError | undefined - Error fetching the preview
• state.called: boolean - Whether the hook has been called
• state.data: PreviewUserPosition | undefined - Preview of user position after the action
• result: Result<PreviewUserPosition, UnexpectedError> - Type-safe success or failure value:
  • Ok<PreviewUserPosition> - Preview of user position after the action
  • Err<UnexpectedError> - Error fetching the preview

useProtocolHistory

Declarative hook to fetch protocol-wide historical data (deposits, borrows).

import { Currency, TimeWindow } from "@aave/react";
import { useProtocolHistory } from "@aave/react";

const { data, loading, error } = useProtocolHistory({
  currency: Currency.Usd,
  window: TimeWindow.LastWeek,
  pause,
});

const { data } = useProtocolHistory({
  currency: Currency.Usd,
  window: TimeWindow.LastWeek,
  suspense: true,
  pause,
});

Arguments:

• request.currency: Currency - Currency for exchange amounts (default: USD)
• request.window: TimeWindow - Time window for historical data (default: LAST_DAY)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: ProtocolHistorySample[] | undefined - Array of protocol history data points
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the protocol history

useRenounceSpokeUserPositionManager

Imperative transaction hook to renounce a position manager of a user for a specific spoke.

import { useRenounceSpokeUserPositionManager } from "@aave/react";

const [execute, state] = useRenounceSpokeUserPositionManager((transaction) =>
  sendTransaction(transaction),
);

const result = await execute(request);

Arguments:

• request.spoke: SpokeId - Spoke ID
• request.manager: EvmAddress - Address to remove as a position manager
• request.managing: EvmAddress - Address that manager was managing

Returns:

• state.loading: boolean - Loading state
• state.error: E | undefined - Error executing the transaction
• state.called: boolean - Whether the hook has been called
• state.data: TransactionReceipt | undefined - Transaction receipt
• result: Result<TransactionReceipt, E> - Type-safe success or failure value:
  • Ok<TransactionReceipt> - Transaction receipt
  • Err<E> - Error executing the transaction

Where E is one of:

• CancelError
• SigningError
• TimeoutError
• TransactionError
• UnexpectedError

useRepay

Imperative transaction hook to repay borrowed assets.

import { useRepay } from "@aave/react";

const [execute, state] = useRepay((plan) => {
  switch (plan.__typename) {
    case "TransactionRequest":
      return sendTransaction(plan);
    case "Erc20Approval":
      return sendTransaction(plan.byTransaction);
    case "PreContractActionRequired":
      return sendTransaction(plan.transaction);
  }
});

const result = await execute(request);

Arguments:

• request.reserve: ReserveId - Reserve ID
• request.amount: RepayAmountInputWithPermit one of:
  • erc20: { value: AmountInput, permit?: RepaySignedPermitInput } - ERC-20 amount, where value is { exact: BigDecimal } or { max: true }
  • native: AmountInput - Native token amount ({ exact: BigDecimal } or { max: true })
• request.sender: EvmAddress - Address repaying the debt

Returns:

• state.loading: boolean - Loading state
• state.error: E | undefined - Error executing the transaction
• state.called: boolean - Whether the hook has been called
• state.data: TransactionReceipt | undefined - Transaction receipt
• result: Result<TransactionReceipt, E> - Type-safe success or failure value:
  • Ok<TransactionReceipt> - Transaction receipt
  • Err<E> - Error executing the transaction

Where E is one of:

• CancelError
• SigningError
• TimeoutError
• TransactionError
• UnexpectedError
• ValidationError<InsufficientBalanceError>

useRepayWithSupplyOrder

Imperative hook to execute a repay with supply through the Order API. It fetches a quote, collects the position-swap approval signatures, then prepares, signs, and submits the order.

import { useRepayWithSupplyOrder } from "@aave/react";

const [execute, state] = useRepayWithSupplyOrder((plan) => {
  switch (plan.__typename) {
    case "PositionSwapAdapterContractApproval":
    case "PositionSwapPositionManagerApproval":
    case "PositionSwapSetCollateralApproval":
      return signTypedData(plan.bySignature);
    case "OrderTypedData":
      return signTypedData(plan);
    case "OrderTransactionRequest":
      return sendTransaction(plan.transaction);
  }
});

const result = await execute(request);

Arguments:

• request: RepayWithSupplyQuoteRequest one of:
  • market: MarketRepayWithSupplyQuoteInput - Market order quote
  • limit: LimitRepayWithSupplyQuoteInput - Limit order quote
  • fromQuote: FromQuoteRepayWithSupplyQuoteInput - Quote from an existing quote ID (quoteId)
• request.currency?: Currency - Currency for value conversions (default: USD)

Returns:

• state.loading: boolean - Loading state
• state.error: E | undefined - Error executing the order
• state.called: boolean - Whether the hook has been called
• state.data: OrderReceipt | undefined - Order receipt with the orderId
• result: Result<OrderReceipt, E> - Type-safe success or failure value:
  • Ok<OrderReceipt> - Order receipt with the orderId
  • Err<E> - Error executing the order

Where E is one of:

• CancelError
• SigningError
• TimeoutError
• TransactionError
• UnexpectedError
• ValidationError<InsufficientBalanceError | InsufficientLiquidityError>

useRepayWithSupplyQuote

Declarative hook to fetch a quote for a repay with supply.

import { useRepayWithSupplyQuote } from "@aave/react";

const { data, loading, error } = useRepayWithSupplyQuote({
  pause,
  ...request,
});

const { data } = useRepayWithSupplyQuote({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request: RepayWithSupplyQuoteRequest one of:
  • market: MarketRepayWithSupplyQuoteInput - Market order quote
  • limit: LimitRepayWithSupplyQuoteInput - Limit order quote
  • fromQuote: FromQuoteRepayWithSupplyQuoteInput - Quote from an existing quote ID (quoteId)
• request.currency?: Currency - Currency for value conversions (default: USD)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: SwapQuote | undefined - Swap quote
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the quote

useRepayWithSupplyQuoteAction

Imperative hook to fetch a quote for a repay with supply.

import { useRepayWithSupplyQuoteAction } from "@aave/react";

const [execute, state] = useRepayWithSupplyQuoteAction(options);

const result = await execute(request);

Options:

• options.currency?: Currency - Currency for value conversions (default: USD)

Arguments:

• request: RepayWithSupplyQuoteRequest one of:
  • market: MarketRepayWithSupplyQuoteInput - Market order quote
  • limit: LimitRepayWithSupplyQuoteInput - Limit order quote
  • fromQuote: FromQuoteRepayWithSupplyQuoteInput - Quote from an existing quote ID (quoteId)

Returns:

• state.loading: boolean - Loading state
• state.error: E | undefined - Error fetching the quote
• state.called: boolean - Whether the hook has been called
• state.data: SwapQuote | undefined - Swap quote
• result: Result<SwapQuote, E> - Type-safe success or failure value:
  • Ok<SwapQuote> - Swap quote
  • Err<E> - Error fetching the quote

Where E is one of:

• UnexpectedError
• ValidationError<InsufficientLiquidityError>

useReserve

Declarative hook to fetch a specific reserve by reserve ID, spoke, and chain.

import { useReserve } from "@aave/react";

const { data, loading, error } = useReserve({
  pause,
  ...request,
});

const { data } = useReserve({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: ReserveRequestQuery one of:
  • reserveId: ReserveId - Reserve ID
  • reserveInput: ReserveInput - Reserve input
    • chainId: ChainId - Chain ID
    • spoke: EvmAddress - Spoke contract address
    • onChainId: OnChainReserveId - On-chain reserve ID
• request.user?: EvmAddress - User address for position-specific data (optional)
• request.currency?: Currency - Currency for value conversions (optional)
• request.timeWindow?: TimeWindow - Time window for change values (optional)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: Reserve | null | undefined - Reserve information or null if not found
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching the reserve

useReserveAction

Imperative hook to fetch reserve data.

import { useReserveAction } from "@aave/react";

const [execute, state] = useReserveAction(options);

const result = await execute(request);

Options:

• options.currency?: Currency - Currency for value conversions (default: USD)
• options.timeWindow?: TimeWindow

Arguments:

• request.query: ReserveRequestQuery one of:
  • reserveId: ReserveId - Reserve ID
  • reserveInput: ReserveInput - Reserve input
    • chainId: ChainId - Chain ID
    • spoke: EvmAddress - Spoke contract address
    • onChainId: OnChainReserveId - On-chain reserve ID
• request.user?: EvmAddress - User address for position-specific data (optional)

Returns:

• state.loading: boolean - Loading state
• state.error: UnexpectedError | undefined - Error fetching the reserve
• state.called: boolean - Whether the hook has been called
• state.data: Reserve | null | undefined - Reserve data or null if not found
• result: Result<Reserve | null, UnexpectedError> - Type-safe success or failure value:
  • Ok<Reserve | null> - Reserve data or null if not found
  • Err<UnexpectedError> - Error fetching the reserve

useReserveHolders

Declarative hook to fetch a paginated list of top holders for a specific reserve.

import { ReserveHoldersFilter, useReserveHolders } from "@aave/react";

const { data, loading, error } = useReserveHolders({
  reserve: { reserveId },
  filter: ReserveHoldersFilter.Supplied,
});

import { ReserveHoldersFilter, useReserveHolders } from "@aave/react";

const { data } = useReserveHolders({
  reserve: { reserveId },
  filter: ReserveHoldersFilter.Supplied,
  suspense: true,
});

Arguments:

• request.reserve: ReserveRequestQuery one of:
  • reserveId: ReserveId - Reserve ID
• request.filter?: ReserveHoldersFilter - Filter by holder type (default: Supplied):
  • ReserveHoldersFilter.Supplied - Wallets that have supplied to this reserve
  • ReserveHoldersFilter.Borrowed - Wallets that have borrowed from this reserve
• request.pageSize?: PageSize - Number of results per page (default: TEN)
• request.cursor?: Cursor - Pagination cursor
• pause?: boolean - Pause the query (default: false)

Returns:

• data: PaginatedReserveHoldersResult | undefined
  • data.items: ReserveHolder[] - Array of holders
    • address: EvmAddress - Holder wallet address
    • amount: Erc20Amount - Amount supplied or borrowed
    • weight: PercentNumber - Percentage share of the total
  • data.pageInfo: PaginatedResultInfo - Pagination info with next and prev cursors
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching holders

useReserveHoldersAction

Imperative hook to fetch reserve holders on demand (e.g., for pagination).

import { useReserveHoldersAction } from "@aave/react";

const [execute, state] = useReserveHoldersAction(options);

const result = await execute(request);

Options:

• options.currency?: Currency - Currency for value conversions (default: USD)

Arguments:

• request.reserve: ReserveRequestQuery - Reserve query (see useReserveHolders)
• request.filter?: ReserveHoldersFilter - Holder type filter
• request.pageSize?: PageSize - Page size
• request.cursor?: Cursor - Pagination cursor

Returns:

• state.loading: boolean - Loading state
• state.error: UnexpectedError | undefined - Error fetching holders
• state.called: boolean - Whether the hook has been called
• state.data: PaginatedReserveHoldersResult | undefined - Paginated result
• result: Result<PaginatedReserveHoldersResult, UnexpectedError> - Type-safe success or failure value:
  • Ok<PaginatedReserveHoldersResult> - Paginated holder data
  • Err<UnexpectedError> - Error fetching holders

useReserves

Declarative hook to fetch reserves based on specified criteria.

import { useReserves } from "@aave/react";

const { data, loading, error } = useReserves({
  pause,
  ...request,
});

const { data } = useReserves({
  pause,
  suspense: true,
  ...request,
});

Arguments:

• request.query: ReservesRequestQuery one of:
  • spoke: SpokeInput - Get reserves for a spoke
    • address: EvmAddress - Spoke contract address
    • chainId: ChainId - Chain ID
  • spokeId: SpokeId - Get reserves by spoke ID
  • tokens: [Erc20Input!] - Get reserves with underlying tokens
    • address: EvmAddress - Token contract address
    • chainId: ChainId - Token chain ID
  • hubToken: HubTokenInput - Get reserves on hub for underlying
    • chainId: ChainId - Chain ID
    • hub: EvmAddress - Hub contract address
    • token: EvmAddress - Token address
  • chainIds: [ChainId!] - Get reserves on chains
  • spokeToken: SpokeTokenInput - Get reserves for spoke for underlying
    • spoke: SpokeId - Spoke ID
    • token: EvmAddress - Token address
  • hub: HubInput - Get reserves on hub
  • userPositionId: UserPositionId - Get reserves by user position ID
  • hubId: HubId - Get reserves by hub ID
  • hubIdToken: HubIdTokenInput - Get reserves on a hub (by ID) for an underlying (hubId, token)
  • chainTokenCategories: [ChainTokenCategories!] - Token categories per chain (chainId, categories)
  • tokenInfo: TokenInfoId - Get reserves by canonical token info ID, across chains
  • symbolChainIds: SymbolInput - Get reserves by raw symbol (symbol, chainIds?)
• request.user?: EvmAddress - User address to include ReserveUserState (optional)
• request.filter?: ReservesRequestFilter - Filter criteria (optional): Supply, Borrow, Collateral, or All
• request.orderBy?: ReservesRequestOrderBy one of:
  • assetName: OrderDirection - Sort by asset name
  • userBalance: OrderDirection - Sort by user balance
  • supplyApy: OrderDirection - Sort by supply APY
  • supplyAvailable: OrderDirection - Sort by available supply
  • borrowApy: OrderDirection - Sort by borrow APY
  • borrowAvailable: OrderDirection - Sort by available borrow
  • collateralFactor: OrderDirection - Sort by collateral factor
• request.currency?: Currency - Currency for value conversions (optional)
• request.timeWindow?: TimeWindow - Time window for change values (optional)
• pause?: boolean - Pause the query (default: false)

Returns:

• data: Reserve[] | undefined - Array of reserves
• loading: boolean - Loading state
• error: UnexpectedError | undefined - Error fetching reserves

useReservesAction

Imperative hook to fetch reserves list.

import { useReservesAction } from "@aave/react";

const [execute, state] = useReservesAction(options);

const result = await execute(request);

Options:

• options.currency?: Currency - Currency for value conversions (default: USD)
• options.timeWindow?: TimeWindow - Time window for change values (optional)

Arguments:

• request.query: ReservesRequestQuery one of:
  • spoke: SpokeInput - Get all reserves for a spoke
  • tokens: [Erc20Input!] - Get all reserves with underlying tokens
    • address: EvmAddress - Token contract address
    • chainId: ChainId - Token chain ID
  • hubToken: HubTokenInput - Get all reserves on a hub for an underlying
    • chainId: ChainId - Chain ID
    • hub: EvmAddress - Hub contract address
    • token: EvmAddress - Token address
  • chainIds: [ChainId!] - Get all reserves on a list of chains
  • spokeToken: SpokeTokenInput - Get all reserves for a spoke for an underlying
    • spoke: SpokeId - Spoke ID
    • token: EvmAddress - Token address
  • hub: HubInput - Get all tokens on a hub
  • userPositionId: UserPositionId - Get all reserves by user position ID
  • hubId: HubId - Get reserves by hub ID
  • hubIdToken: HubIdTokenInput - Get reserves on a hub (by ID) for an underlying (hubId, token)
  • chainTokenCategories: [ChainTokenCategories!] - Token categories per chain (chainId, categories)
  • tokenInfo: TokenInfoId - Get reserves by canonical token info ID, across chains
  • symbolChainIds: SymbolInput - Get reserves by raw symbol (symbol, chainIds?)
• request.user?: EvmAddress - User address to include ReserveUserState (optional)
• request.filter?: ReservesRequestFilter - Filter criteria (optional): Supply, Borrow, Collateral, or All

Returns:

• state.loading: boolean - Loading state
• state.error: UnexpectedError | undefined - Error fetching reserves
• state.called: boolean - Whether the hook has been called
• state.data: Reserve[] | undefined - Array of reserves
• result: Result<Reserve[], UnexpectedError> - Type-safe success or failure value:
  • Ok<Reserve[]> - Array of reserves
  • Err<UnexpectedError> - Error fetching reserves

useSendTransaction

Send transactions through connected wallet.

import { useSendTransaction } from "@aave/react/viem";
import { useWalletClient } from "wagmi";

const { data: walletClient } = useWalletClient();
const [sendTransaction, state] = useSendTransaction(walletClient);

import { useSendTransaction } from "@aave/react/ethers";
import { ethers } from "ethers";

const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();
const [sendTransaction, state] = useSendTransaction(signer);

import { useSendTransaction } from "@aave/react/privy";

const [sendTransaction, state] = useSendTransaction();

import { useSendTransaction } from "@aave/react/thirdweb";
import { createThirdwebClient } from "thirdweb";

const thirdwebClient = createThirdwebClient({
  clientId: "<YOUR_THIRDWEB_CLIENT_ID>",
});

const [sendTransaction, state] = useSendTransaction(thirdwebClient);

Arguments:

• request: TransactionRequest - Transaction request to send

Returns:

• state.loading: boolean - Loading state
• state.error: SendTransactionError | undefined - Error sending the transaction
• state.called: boolean - Whether the hook has been called
• state.data: PendingTransaction | undefined - Pending transaction
• result: Result<PendingTransaction, SendTransactionError> - Type-safe success or failure value:
  • Ok<PendingTransaction> - Pending transaction
  • Err<SendTransactionError> - Error sending the transaction

Where SendTransactionError is one of:

• CancelError
• SigningError
• UnexpectedError

useSetSpokeUserPositionManager

Imperative transaction hook to set a position manager for a spoke.

import { useSetSpokeUserPositionManager } from "@aave/react";

const [execute, state] = useSetSpokeUserPositionManager((transaction) =>
  sendTransaction(transaction),
);

const result = await execute(request);

Arguments:

• request.chainId: ChainId - Chain ID
• request.spoke: SpokeId - Spoke ID
• request.manager: EvmAddress - Position manager address

Returns:

• state.loading: boolean - Loading state
• state.error: E | undefined - Error executing the transaction
• state.called: boolean - Whether the hook has been called
• state.data: TransactionReceipt | undefined - Transaction receipt
• result: Result<TransactionReceipt, E> - Type-safe success or failure value:
  • Ok<TransactionReceipt> - Transaction receipt
  • Err<E> - Error executing the transaction

Where E is one of:

• CancelError
• SigningError
• TimeoutError
• TransactionError
• UnexpectedError

useSetUserSuppliesAsCollateral

Imperative transaction hook to enable or disable assets as collateral.

import { useSetUserSuppliesAsCollateral } from "@aave/react";

const [execute, state] = useSetUserSuppliesAsCollateral((transaction) =>
  sendTransaction(transaction),
);

const result = await execute(request);

Arguments:

• request.changes: UserSupplyAsCollateral[] - Array of collateral changes
  • changes[].reserve: ReserveId - Reserve ID
  • changes[].enableCollateral: boolean - Enable or disable as collateral
• request.sender: EvmAddress - User’s address

Returns:

• state.loading: boolean - Loading state
• state.error: E | undefined - Error executing the transaction
• state.called: boolean - Whether the hook has been called
• state.data: TransactionReceipt | undefined - Transaction receipt
• result: Result<TransactionReceipt, E> - Type-safe success or failure value:
  • Ok<TransactionReceipt> - Transaction receipt
  • Err<Error> - Error executing the transaction

Where E is one of:

• CancelError
• SigningError
• TimeoutError
• TransactionError
• UnexpectedError

useSignTypedData

Imperative transaction hook to sign EIP-712 typed data for ERC-20 permits and swap intents.

This hook provides a unified interface for signing all types of typed data in AaveKit React. It returns a raw signature that is automatically wrapped with deadline information by transaction hooks like useSupply, useRepay, and useTokenSwapOrder.

import { useSignTypedData } from "@aave/react/viem";
import { useWalletClient } from "wagmi";

const { data: walletClient } = useWalletClient();
const [execute, state] = useSignTypedData(walletClient);

const result = await execute(typedData);

import { useSignTypedData } from "@aave/react/ethers";
import { ethers } from "ethers";

const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();
const [execute, state] = useSignTypedData(signer);

const result = await execute(typedData);

import { useSignTypedData } from "@aave/react/privy";

const [execute, state] = useSignTypedData();

const result = await execute(typedData);

import { useSignTypedData } from "@aave/react/thirdweb";

const [execute, state] = useSignTypedData();

const result = await execute(typedData);

Arguments:

• typedData: TypedData - The EIP-712 typed data to sign.

Returns:

• state.loading: boolean - Loading state
• state.error: SignTypedDataError | undefined - Error signing the typed data
• state.called: boolean - Whether the hook has been called
• state.data: Signature | undefined - Raw signature (deadline wrapping is handled automatically by transaction hooks)
• result: Result<Signature, SignTypedDataError> - Type-safe success or failure value:
  • Ok<Signature> - Raw signature
  • Err<SignTypedDataError> - Error signing the typed data

useSpoke

Declarative hook to fetch a specific spoke by address and chain ID.