Assets

Learn how to query and monitor asset information across Aave v4.

Assets represent ERC20 tokens that can be supplied, borrowed, or traded within the Aave protocol.

Asset Data Structure

Asset data provides comprehensive information about a specific token in the protocol, including:

  • Token identification: id, address, symbol, name, decimals

  • Aggregate metrics: total supplied, total borrowed, caps, and available amounts

  • Reserve coverage: total number of reserves and how many are active

  • Current price: exchange valuation for a specific currency

The following TypeScript interfaces illustrate the core Asset types:

interface Asset {  __typename: "Asset";  id: AssetId;  token: Erc20Token;  summary: AssetSummary;  price: ExchangeAmountWithChange;}

Fetching Asset Information

Query detailed information about a specific asset.

Use the useAsset hook to fetch asset information.

import { type AssetRequest, useAsset } from "@aave/react";
function AssetDetails({ request }: { request: AssetRequest }) {  const { data, loading, error } = useAsset(request);
  if (loading) return <div>Loading…</div>;
  if (error) return <div>Error: {error.message}</div>;
  if (!data) return <div>Asset not found</div>;
  return (    <div>      <h3>{data.token.name}</h3>      <p>Chain: {data.token.chain.name}</p>    </div>  );}

See below for examples of AssetRequest objects.

import { chainId, evmAddress } from "@aave/react";
const request: AssetRequest = {  query: {    token: {      address: evmAddress("0x123…"),      chainId: chainId(1),    },  },};

Finally, you can specify a different time window or currency for the data.

import { TimeWindow } from "@aave/react";
// …
const { data, loading, error } = useAsset({  query: {    // your query criteria  },  timeWindow: TimeWindow.LastWeek,});

Multichain Asset

A multichain asset aggregates a single token across every chain where it is listed as a hub asset. Tokens are grouped by their canonical symbol—the case-insensitive, alias-resolved symbol that identifies the same asset across chains—so you can show protocol-wide totals and APY ranges without querying each chain separately.

Data Structure

A multichain asset exposes the per-chain Asset list alongside an aggregated summary.

The following TypeScript interfaces illustrate the core multichain asset types:

interface MultichainAsset {  __typename: "MultichainAsset";  assets: Asset[];  summary: MultichainAssetSummary;}

Fetching a Multichain Asset

Select the token with exactly one of symbol or tokenInfo. Omit chainIds to aggregate across all chains, or pass a list to restrict the result.

Use the useMultichainAsset hook to fetch an asset aggregated across chains.

import { useMultichainAsset } from "@aave/react";
function MultichainAssetSummary() {  const { data, loading, error } = useMultichainAsset({    query: { symbol: "USDC" },  });
  if (loading) return <div>Loading…</div>;
  if (error) return <div>Error: {error.message}</div>;
  return (    <div>      <p>Deployed on {data.summary.chainCount} chains</p>      <p>        Total supplied: {data.summary.totalSupplied.value.toDisplayString(2)}{" "}        {data.summary.totalSupplied.symbol}      </p>    </div>  );}

See below for examples of MultichainAssetRequest objects.

const request: MultichainAssetRequest = {  query: {    symbol: "USDC",  },};

By default, Merkl rewards are included in the APY range. Pass includeRewards: false for protocol base rates only.

const request: MultichainAssetRequest = {  query: { symbol: "USDC" },  includeRewards: false,};

Asset Price History

Asset price history data provides time-series price information for an asset.

Use the useAssetPriceHistory hook to fetch historical price data.

import {  type AssetPriceHistoryRequest,  useAssetPriceHistory,} from "@aave/react";
function AssetPrice({ request }: { request: AssetPriceHistoryRequest }) {  const { data, loading, error } = useAssetPriceHistory(request);
  if (loading) return <div>Loading…</div>;
  if (error) return <div>Error: {error.message}</div>;
  return (    <div>      {data.map((sample) => (        <div key={sample.date.toString()}>          <p>            <small>{sample.date.toLocaleDateString()}</small>$            {sample.price.toFixed(2)}          </p>        </div>      ))}    </div>  );}

See below for examples of AssetPriceHistoryRequest objects.

const request: AssetPriceHistoryRequest = {  query: {    assetId: asset.id,  },};

Finally, you can specify a different currency or time window for the data.

import { Currency } from "@aave/react";
const { data, error, loading } = useAssetPriceHistory({  query: {    // your query criteria  },  currency: Currency.Eur,});

Asset Supply History

Asset supply history data provides time-series total supply information for an asset.

Use the useAssetSupplyHistory hook to fetch historical supply data.

import {  type AssetSupplyHistoryRequest,  useAssetSupplyHistory,} from "@aave/react";
function AssetSupply({ request }: { request: AssetSupplyHistoryRequest }) {  const { data, loading, error } = useAssetSupplyHistory(request);
  if (loading) return <div>Loading…</div>;
  if (error) return <div>Error: {error.message}</div>;
  return (    <div>      {data.map((sample) => (        <div key={sample.date.toString()}>          <p>            <small>{sample.date.toLocaleDateString()}</small>            {sample.amount.value.toDisplayString(2)} {sample.amount.symbol}          </p>        </div>      ))}    </div>  );}

See below for examples of AssetSupplyHistoryRequest objects.

const request: AssetSupplyHistoryRequest = {  query: {    assetId: asset.id,  },};

Finally, you can specify a different time window for the data.

import { TimeWindow } from "@aave/react";
const { data, error, loading } = useAssetSupplyHistory({  query: {    // your query criteria  },  window: TimeWindow.LastMonth,});

Asset Borrow History

Asset borrow history data provides time-series total borrow information for an asset.

Use the useAssetBorrowHistory hook to fetch historical borrow data.

import {  type AssetBorrowHistoryRequest,  useAssetBorrowHistory,} from "@aave/react";
function AssetBorrow({ request }: { request: AssetBorrowHistoryRequest }) {  const { data, loading, error } = useAssetBorrowHistory(request);
  if (loading) return <div>Loading…</div>;
  if (error) return <div>Error: {error.message}</div>;
  return (    <div>      {data.map((sample) => (        <div key={sample.date.toString()}>          <p>            <small>{sample.date.toLocaleDateString()}</small>            {sample.amount.value.toDisplayString(2)} {sample.amount.symbol}          </p>        </div>      ))}    </div>  );}

See below for examples of AssetBorrowHistoryRequest objects.

const request: AssetBorrowHistoryRequest = {  query: {    assetId: asset.id,  },};

Finally, you can specify a different time window for the data.

import { TimeWindow } from "@aave/react";
const { data, error, loading } = useAssetBorrowHistory({  query: {    // your query criteria  },  window: TimeWindow.LastMonth,});

Protocol History

Fetch protocol-wide historical data (deposits, borrows). Pass chainIds to scope the history to specific chains, or omit it to aggregate across all of them.

Use the useProtocolHistory hook to fetch protocol-wide historical data.

import { type ProtocolHistoryRequest, useProtocolHistory } from "@aave/react";
function ProtocolHistory({ request }: { request: ProtocolHistoryRequest }) {  const { data, loading, error } = useProtocolHistory(request);
  if (loading) return <div>Loading…</div>;
  if (error) return <div>Error: {error.message}</div>;
  return (    <div>      {data.map((sample) => (        <p key={sample.date.toString()}>          <small>{sample.date.toLocaleDateString()}</small>          <span>            <strong>Deposits</strong>            {sample.deposits.symbol}            {sample.deposits.value.toDisplayString(2)}          </span>          <span>            <strong>Borrows</strong>            {sample.borrows.symbol}            {sample.borrows.value.toDisplayString(2)}          </span>        </p>      ))}    </div>  );}
Previous
Reserves
Next
Chains