Aave V4 Assets

Assets represent ERC-20 tokens that can be supplied or borrowed within Aave V4.

Asset Data Structure

Asset data describes a specific token in the protocol:

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;
}

interface AssetSummary {
  __typename: "AssetSummary";
  totalSupplyCap: AssetAmountWithChange;
  totalSupplied: AssetAmountWithChange;
  totalSuppliable: AssetAmountWithChange;
  totalBorrowCap: AssetAmountWithChange;
  totalBorrowed: AssetAmountWithChange;
  totalBorrowable: AssetAmountWithChange;
  reservesCount: number;
  activeReservesCount: number;
  averageSupplyApy: PercentNumber;
  averageBorrowApy: PercentNumber;
}

interface Erc20Token {
  __typename: "Erc20Token";
  info: TokenInfo;
  address: EvmAddress;
  chain: Chain;
  isWrappedNativeToken: boolean;
}

interface DecimalNumberWithChange {
  __typename: "DecimalNumberWithChange";
  current: DecimalNumber;
  change: PercentNumber;
}

interface ExchangeAmountWithChange {
  __typename: "ExchangeAmountWithChange";
  current: ExchangeAmount;
  change: PercentNumber;
}

interface AssetAmountWithChange {
  __typename: "AssetAmountWithChange";
  amount: DecimalNumberWithChange;
  exchange: ExchangeAmountWithChange;
}

The following GraphQL fragments illustrate the core Asset types:

fragment Asset on Asset {
  __typename
  id
  token {
    ...Erc20Token
  }
  summary {
    ...AssetSummary
  }
  price {
    ...ExchangeAmountWithChange
  }
}

fragment AssetSummary on AssetSummary {
  __typename
  totalSupplyCap {
    ...AssetAmountWithChange
  }
  totalSupplied {
    ...AssetAmountWithChange
  }
  totalSuppliable {
    ...AssetAmountWithChange
  }
  totalBorrowCap {
    ...AssetAmountWithChange
  }
  totalBorrowed {
    ...AssetAmountWithChange
  }
  totalBorrowable {
    ...AssetAmountWithChange
  }
  reservesCount
  activeReservesCount
  averageSupplyApy: supplyApy(metric: AVERAGE) {
    ...PercentNumber
  }
  averageBorrowApy: borrowApy(metric: AVERAGE) {
    ...PercentNumber
  }
}

fragment Erc20Token on Erc20Token {
  __typename
  info {
    ...TokenInfo
  }
  address
  chain {
    ...Chain
  }
  isWrappedNativeToken
}

fragment AssetAmountWithChange on AssetAmountWithChange {
  __typename
  amount {
    ...DecimalNumberWithChange
  }
  exchange(currency: $currency) {
    ...ExchangeAmountWithChange
  }
}

fragment DecimalNumberWithChange on DecimalNumberWithChange {
  __typename
  current {
    ...DecimalNumber
  }
  change(window: $timeWindow) {
    ...PercentNumber
  }
}

fragment ExchangeAmountWithChange on ExchangeAmountWithChange {
  __typename
  current {
    ...ExchangeAmount
  }
  change(window: $timeWindow) {
    ...PercentNumber
  }
}

Fetching Asset Information

Query detailed information about a specific asset.

Use the useAsset hook in React, the asset action in TypeScript, or the asset query in GraphQL 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.info.name}</h3>
      <p>Chain: {data.token.chain.name}</p>
    </div>
  );
}

import { type AssetRequest, useAsset } from "@aave/react";

function AssetDetails({ request }: { request: AssetRequest }) {
  const { data } = useAsset({
    ...request,
    suspense: true,
  });

  if (!data) return <div>Asset not found</div>;

  return (
    <div>
      <h3>{data.token.info.name}</h3>
      <p>Chain: {data.token.chain.name}</p>
    </div>
  );
}

import { chainId, evmAddress } from "@aave/client";
import { asset } from "@aave/client/actions";

import { client } from "./client";

const result = await asset(client, {
  query: {
    token: {
      address: evmAddress("0x123…"),
      chainId: chainId(1),
    },
  },
});

if (result.isOk()) {
  console.log(result.value); // Asset | null - null if not found
} else {
  console.error(result.error);
}

import { type AssetId } from "@aave/client";
import { asset } from "@aave/client/actions";

import { client } from "./client";

// const assetId: AssetId = "SGVsbG8h";

const result = await asset(client, {
  query: {
    assetId,
  },
});

import { Currency } from "@aave/client";
import { asset } from "@aave/client/actions";

import { client } from "./client";

const result = await asset(
  client,
  {
    query: {
      // your query criteria
    },
  },
  {
    currency: Currency.Eur,
  },
);

query (
  $request: AssetRequest!
  $currency: Currency! = USD
  $timeWindow: TimeWindow! = LAST_DAY
) {
  value: asset(request: $request) {
    id
    token {
      ...Erc20Token
    }
    summary {
      ...AssetSummary
    }
    price(currency: $currency) {
      ...ExchangeAmountWithChange
    }
  }
}

fragment AssetSummary on AssetSummary {
  __typename
  totalSupplyCap {
    ...AssetAmountWithChange
  }
  totalSupplied {
    ...AssetAmountWithChange
  }
  totalSuppliable {
    ...AssetAmountWithChange
  }
  totalBorrowCap {
    ...AssetAmountWithChange
  }
  totalBorrowed {
    ...AssetAmountWithChange
  }
  totalBorrowable {
    ...AssetAmountWithChange
  }
  reservesCount
  activeReservesCount
  averageSupplyApy: supplyApy(metric: AVERAGE) {
    ...PercentNumber
  }
  averageBorrowApy: borrowApy(metric: AVERAGE) {
    ...PercentNumber
  }
}

fragment Erc20Token on Erc20Token {
  __typename
  info {
    ...TokenInfo
  }
  address
  chain {
    ...Chain
  }
  isWrappedNativeToken
}

fragment AssetAmountWithChange on AssetAmountWithChange {
  __typename
  amount {
    ...DecimalNumberWithChange
  }
  exchange(currency: $currency) {
    ...ExchangeAmountWithChange
  }
}

fragment DecimalNumberWithChange on DecimalNumberWithChange {
  __typename
  current {
    ...DecimalNumber
  }
  change(window: $timeWindow) {
    ...PercentNumber
  }
}

fragment ExchangeAmountWithChange on ExchangeAmountWithChange {
  __typename
  current {
    ...ExchangeAmount
  }
  change(window: $timeWindow) {
    ...PercentNumber
  }
}

fragment ExchangeAmount on ExchangeAmount {
  __typename
  value
  name
  symbol
  icon
  decimals
}

See below for examples of AssetRequest objects in React. In GraphQL, specify the asset ID or token address and chain ID.

import { chainId, evmAddress } from "@aave/react";

const request: AssetRequest = {
  query: {
    token: {
      address: evmAddress("0x123…"),
      chainId: chainId(1),
    },
  },
};

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

const request: AssetRequest = {
  query: {
    assetId: assetId(params.id), // AssetId - typically from URL params
  },
};

{
  "request": {
    "query": {
      "token": {
        "address": "0x6B175474E89094C44Da98b954EedeAC495271d0F",
        "chainId": 1
      }
    }
  }
}

{
  "request": {
    "query": {
      "assetId": "SGVsbG8h"
    }
  }
}

{
  "request": {
    "query": {
      // your query criteria
    }
  },
  "currency": "EUR"
}

Finally, in React and TypeScript, 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,
});

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

// …

const { data, loading, error } = useAsset({
  query: {
    // your query criteria
  },
  currency: Currency.Eur,
});

Custom Time Window

import { TimeWindow } from "@aave/client";
import { asset } from "@aave/client/actions";

import { client } from "./client";

const result = await asset(
  client,
  {
    query: {
      /* … */
    },
  },
  { 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;
}

interface MultichainAssetSummary {
  __typename: "MultichainAssetSummary";
  totalSupplied: ExchangeAmount;
  totalBorrowed: ExchangeAmount;
  totalSupplyCap: ExchangeAmount;
  totalBorrowCap: ExchangeAmount;
  totalAvailableLiquidity: ExchangeAmount;
  utilizationRate: PercentNumber;
  highestSupplyApy: PercentNumber;
  lowestSupplyApy: PercentNumber;
  averageSupplyApy: PercentNumber;
  highestBorrowApy: PercentNumber;
  lowestBorrowApy: PercentNumber;
  averageBorrowApy: PercentNumber;
  chainCount: number;
  reservesCount: number;
  activeReservesCount: number;
}

The following GraphQL fragments illustrate the core multichain asset types:

fragment MultichainAsset on MultichainAsset {
  __typename
  assets {
    ...Asset
  }
  summary {
    ...MultichainAssetSummary
  }
}

fragment MultichainAssetSummary on MultichainAssetSummary {
  __typename
  totalSupplied {
    ...ExchangeAmount
  }
  totalBorrowed {
    ...ExchangeAmount
  }
  totalSupplyCap {
    ...ExchangeAmount
  }
  totalBorrowCap {
    ...ExchangeAmount
  }
  totalAvailableLiquidity {
    ...ExchangeAmount
  }
  utilizationRate {
    ...PercentNumber
  }
  highestSupplyApy {
    ...PercentNumber
  }
  lowestSupplyApy {
    ...PercentNumber
  }
  averageSupplyApy {
    ...PercentNumber
  }
  highestBorrowApy {
    ...PercentNumber
  }
  lowestBorrowApy {
    ...PercentNumber
  }
  averageBorrowApy {
    ...PercentNumber
  }
  chainCount
  reservesCount
  activeReservesCount
}

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 in React, the multichainAsset action in TypeScript, or the multichainAsset query in GraphQL 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>
  );
}

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

function MultichainAssetSummary() {
  const { data } = useMultichainAsset({
    query: { symbol: "USDC" },
    suspense: true,
  });

  return <p>Deployed on {data.summary.chainCount} chains</p>;
}

import { multichainAsset } from "@aave/client/actions";

import { client } from "./client";

const result = await multichainAsset(client, {
  query: { symbol: "USDC" },
});

if (result.isOk()) {
  console.log(result.value); // MultichainAsset
} else {
  console.error(result.error);
}

import { chainId } from "@aave/client";
import { multichainAsset } from "@aave/client/actions";

import { client } from "./client";

const result = await multichainAsset(client, {
  query: { symbol: "USDC" },
  chainIds: [chainId(1), chainId(43114)],
});

Query

query (
  $request: MultichainAssetRequest!
  $currency: Currency! = USD
  $timeWindow: TimeWindow! = LAST_DAY
) {
  value: multichainAsset(request: $request) {
    ...MultichainAsset
  }
}

See below for examples of MultichainAssetRequest objects in React. In GraphQL, provide exactly one of symbol or tokenInfo in query, and optionally restrict the result with chainIds.

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

const request: MultichainAssetRequest = {
  query: {
    tokenInfo: tokenInfo.id, // tokenInfo: TokenInfo
  },
};

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

const request: MultichainAssetRequest = {
  query: {
    symbol: "USDC",
  },
  chainIds: [chainId(1), chainId(43114)],
};

{
  "request": {
    "query": {
      "symbol": "USDC"
    }
  }
}

{
  "request": {
    "query": {
      "symbol": "USDC"
    },
    "chainIds": [1, 43114]
  }
}

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

Protocol APYs Only

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

Protocol APYs Only

import { multichainAsset } from "@aave/client/actions";

import { client } from "./client";

const result = await multichainAsset(client, {
  query: { symbol: "USDC" },
  includeRewards: false,
});

Protocol APYs Only

{
  "request": {
    "query": {
      "symbol": "USDC"
    },
    "includeRewards": false
  }
}

Asset Price History

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

Use the useAssetPriceHistory hook in React, the assetPriceHistory action in TypeScript, or the assetPriceHistory query in GraphQL 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>
  );
}

import {
  type AssetPriceHistoryRequest,
  useAssetPriceHistory,
} from "@aave/react";

function AssetPrice({ request }: { request: AssetPriceHistoryRequest }) {
  const { data } = useAssetPriceHistory({
    ...request,
    suspense: true,
  });

  return (
    <div>
      {data.map((sample) => (
        <div key={sample.date.toString()}>
          <p>
            <small>{sample.date.toLocaleDateString()}</small>$
            {sample.price.toFixed(2)}
          </p>
        </div>
      ))}
    </div>
  );
}

import { Currency, TimeWindow } from "@aave/client";
import { assetPriceHistory } from "@aave/client/actions";

import { client } from "./client";

const result = await assetPriceHistory(client, {
  query: {
    assetId: asset.id,
  },
  currency: Currency.Usd,
  window: TimeWindow.LastWeek,
});

import { chainId, evmAddress, Currency, TimeWindow } from "@aave/client";
import { assetPriceHistory } from "@aave/client/actions";

import { client } from "./client";

const result = await assetPriceHistory(client, {
  query: {
    token: {
      address: evmAddress("0x123…"),
      chainId: chainId(1),
    },
  },
  currency: Currency.Usd,
  window: TimeWindow.LastWeek,
});

Query

query ($request: AssetPriceHistoryRequest!) {
  value: assetPriceHistory(request: $request) {
    date
    price
  }
}

See below for examples of AssetPriceHistoryRequest objects in React. In GraphQL, specify the asset ID or token, currency, and time window.

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

import { chainId, evmAddress } from "@aave/react";

const request: AssetPriceHistoryRequest = {
  query: {
    token: {
      address: evmAddress("0x123…"),
      chainId: chainId(1),
    },
  },
};

{
  "request": {
    "query": {
      "assetId": "SGVsbG8h"
    },
    "currency": "USD",
    "window": "LAST_WEEK"
  }
}

{
  "request": {
    "query": {
      "token": {
        "address": "0x6B175474E89094C44Da98b954EedeAC495271d0F",
        "chainId": 1
      }
    },
    "currency": "USD",
    "window": "LAST_WEEK"
  }
}

Finally, in React, 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,
});

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

const { data, error, loading } = useAssetPriceHistory({
  query: {
    // your query criteria
  },
  window: TimeWindow.LastMonth,
});

Asset Supply History

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

Use the useAssetSupplyHistory hook in React, the assetSupplyHistory action in TypeScript, or the assetSupplyHistory query in GraphQL 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)}
          </p>
        </div>
      ))}
    </div>
  );
}

import {
  type AssetSupplyHistoryRequest,
  useAssetSupplyHistory,
} from "@aave/react";

function AssetSupply({ request }: { request: AssetSupplyHistoryRequest }) {
  const { data } = useAssetSupplyHistory({
    ...request,
    suspense: true,
  });

  return (
    <div>
      {data.map((sample) => (
        <div key={sample.date.toString()}>
          <p>
            <small>{sample.date.toLocaleDateString()}</small>
            {sample.amount.value.toDisplayString(2)}
          </p>
        </div>
      ))}
    </div>
  );
}

import { TimeWindow } from "@aave/client";
import { assetSupplyHistory } from "@aave/client/actions";

import { client } from "./client";

const result = await assetSupplyHistory(client, {
  query: {
    assetId: asset.id,
  },
  window: TimeWindow.LastWeek,
});

import { chainId, evmAddress, TimeWindow } from "@aave/client";
import { assetSupplyHistory } from "@aave/client/actions";

import { client } from "./client";

const result = await assetSupplyHistory(client, {
  query: {
    token: {
      address: evmAddress("0x123…"),
      chainId: chainId(1),
    },
  },
  window: TimeWindow.LastWeek,
});

query ($request: AssetSupplyHistoryRequest!) {
  value: assetSupplyHistory(request: $request) {
    date
    amount {
      ...DecimalNumber
    }
    highestApy {
      ...PercentNumber
    }
    lowestApy {
      ...PercentNumber
    }
    averageApy {
      ...PercentNumber
    }
    breakdown {
      ...AssetSampleBreakdown
    }
  }
}

fragment AssetSampleBreakdown on AssetSampleBreakdown {
  __typename
  amount {
    ...DecimalNumber
  }
  apy {
    ...PercentNumber
  }
  hub {
    ...Hub
  }
}

fragment Hub on Hub {
  __typename
  id
  address
  chain {
    ...Chain
  }
  name
}

See below for examples of AssetSupplyHistoryRequest objects in React. In GraphQL, specify the asset ID or token and time window.

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

import { chainId, evmAddress } from "@aave/react";

const request: AssetSupplyHistoryRequest = {
  query: {
    token: {
      address: evmAddress("0x123…"),
      chainId: chainId(1),
    },
  },
};

{
  "request": {
    "query": {
      "assetId": "SGVsbG8h"
    },
    "window": "LAST_WEEK"
  }
}

{
  "request": {
    "query": {
      "token": {
        "address": "0x6B175474E89094C44Da98b954EedeAC495271d0F",
        "chainId": 1
      }
    },
    "window": "LAST_WEEK"
  }
}

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

Custom Time Window

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 in React, the assetBorrowHistory action in TypeScript, or the assetBorrowHistory query in GraphQL 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)}
          </p>
        </div>
      ))}
    </div>
  );
}

import {
  type AssetBorrowHistoryRequest,
  useAssetBorrowHistory,
} from "@aave/react";

function AssetBorrow({ request }: { request: AssetBorrowHistoryRequest }) {
  const { data } = useAssetBorrowHistory({
    ...request,
    suspense: true,
  });

  return (
    <div>
      {data.map((sample) => (
        <div key={sample.date.toString()}>
          <p>
            <small>{sample.date.toLocaleDateString()}</small>
            {sample.amount.value.toDisplayString(2)}
          </p>
        </div>
      ))}
    </div>
  );
}

import { TimeWindow } from "@aave/client";
import { assetBorrowHistory } from "@aave/client/actions";

import { client } from "./client";

const result = await assetBorrowHistory(client, {
  query: {
    assetId: asset.id,
  },
  window: TimeWindow.LastWeek,
});

import { chainId, evmAddress, TimeWindow } from "@aave/client";
import { assetBorrowHistory } from "@aave/client/actions";

import { client } from "./client";

const result = await assetBorrowHistory(client, {
  query: {
    token: {
      address: evmAddress("0x123…"),
      chainId: chainId(1),
    },
  },
  window: TimeWindow.LastWeek,
});

query ($request: AssetBorrowHistoryRequest!) {
  value: assetBorrowHistory(request: $request) {
    date
    amount {
      ...DecimalNumber
    }
    highestApy {
      ...PercentNumber
    }
    lowestApy {
      ...PercentNumber
    }
    averageApy {
      ...PercentNumber
    }
    breakdown {
      ...AssetSampleBreakdown
    }
  }
}

fragment AssetSampleBreakdown on AssetSampleBreakdown {
  __typename
  amount {
    ...DecimalNumber
  }
  apy {
    ...PercentNumber
  }
  hub {
    ...Hub
  }
}

fragment Hub on Hub {
  __typename
  id
  address
  chain {
    ...Chain
  }
  name
}

See below for examples of AssetBorrowHistoryRequest objects in React. In GraphQL, specify the asset ID or token and time window.

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

import { chainId, evmAddress } from "@aave/react";

const request: AssetBorrowHistoryRequest = {
  query: {
    token: {
      address: evmAddress("0x123…"),
      chainId: chainId(1),
    },
  },
};

{
  "request": {
    "query": {
      "assetId": "SGVsbG8h"
    },
    "window": "LAST_WEEK"
  }
}

{
  "request": {
    "query": {
      "token": {
        "address": "0x6B175474E89094C44Da98b954EedeAC495271d0F",
        "chainId": 1
      }
    },
    "window": "LAST_WEEK"
  }
}

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

Custom Time Window

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 in React, the protocolHistory action in TypeScript, or the protocolHistory query in GraphQL 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>
  );
}

import { type ProtocolHistoryRequest, useProtocolHistory } from "@aave/react";

function ProtocolHistory({ request }: { request: ProtocolHistoryRequest }) {
  const { data } = useProtocolHistory({
    ...request,
    suspense: true,
  });

  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>
  );
}

Protocol History

import { chainId, Currency, TimeWindow } from "@aave/client";
import { protocolHistory } from "@aave/client/actions";

import { client } from "./client";

const result = await protocolHistory(client, {
  currency: Currency.Usd,
  window: TimeWindow.LastWeek,
  chainIds: [chainId(1), chainId(43114)],
});

if (result.isOk()) {
  console.log(result.value); // ProtocolHistorySample[]
} else {
  console.error(result.error);
}

query ($request: ProtocolHistoryRequest!) {
  value: protocolHistory(request: $request) {
    date
    deposits {
      ...ExchangeAmount
    }
    borrows {
      ...ExchangeAmount
    }
  }
}

fragment ExchangeAmount on ExchangeAmount {
  __typename
  value
  name
  symbol
  icon
  decimals
}

In GraphQL, specify currency and time window.

Protocol History Request

{
  "request": {
    "currency": "USD",
    "window": "LAST_WEEK",
    "chainIds": [1, 43114]
  }
}