TypeScript#Copy

Get started with AaveKit TypeScript

AaveKit TypeScript for Aave v4 provides a type-safe, low-level API client for interacting with Aave Protocol v4. It offers a lightweight abstraction over the GraphQL API and is ideal for server-to-server communication.

Built with a modular, functional approach inspired by the viem client-actions architecture, the SDK structures functionality into distinct, reusable actions focused on specific protocol features like lending, borrowing, and data retrieval.

To get started, follow the steps below.

npm install @aave/client@next

import { AaveClient } from "@aave/client";
export const client = AaveClient.create();

import { AaveClient, ChainsFilter } from "@aave/client";import { chains } from "@aave/client/actions";
import { client } from "./client.ts";
// Fetch all chains supported by Aaveconst result = await chains(client, {  query: { filter: ChainsFilter.ALL },});
if (result.isOk()) {  console.log("Chains:", result.value);} else {  console.error("Error:", result.error);}

AaveClient supports SSR hand-off through the ssr option. Create a server-side client, run your queries, serialize client.extractData(), then hydrate a browser client with that snapshot.

import { AaveClient, type SSRData, ChainsFilter } from "@aave/client";import { chains } from "@aave/client/actions";
const client = AaveClient.create({  ssr: { isServer: true },});
const result = await chains(client, {  query: { filter: ChainsFilter.ALL },});
const initialState: SSRData = client.extractData();

If the snapshot arrives after the client is created, call client.restoreData(initialState) to hydrate the cache later.

The optional display config transforms how assets are presented across queries. Transforms are applied after the cache, so the cache always stores untransformed data.

import { AaveClient } from "@aave/client";
export const client = AaveClient.create({  display: {    // Show wrapped native tokens (e.g. WETH) as the native asset (e.g. ETH)    showWrappedNativeReserveAsNative: true,    // Per-asset overrides, keyed by chain ID and address    assetOverrides: [      {        chainId: 1,        address: "0xAeBf0Bb9f57E89260d57f31AF34eB58657d96Ce0",        display: { name: "PT USDe (May 2026)", symbol: "PT USDe", icon: "https://…" },      },    ],  },});

AaveKit uses a functional approach to error handling, it's based on Result<T, E> that represents one of two states:

import { ok, err, Result } from "@aave/client";
function parseId(s: string): Result<number, Error> {  if (/^\d+$/.test(s)) {    return ok(Number(s));  }  return err(new Error("ID must be a number"));}

With a Result<T, E>, you can use the convenient isOk() and isErr() methods to check the outcome and narrow the type.

const result: Result<number, Error> = parseId("123");
if (result.isOk()) {  console.log(result.value); // 123} else {  console.error(result.error); // Error}

This approach avoids reliance on try/catch blocks and promotes predictable, type-safe code by ensuring errors are handled explicitly.

ResultAsync<T, E> is the async, thenable variant of Result<T, E>. Awaiting it resolves to a Result<T, E>.

import { ResultAsync } from "@aave/client";
function fetchUser(id: number): ResultAsync<{ name: string }, Error> {  return ResultAsync.fromPromise(    fetch(`/api/users/${id}`).then((r) => r.json()),    () => new Error("Not found"),  );}
const result = await fetchUser(1);
if (result.isOk()) {  console.log(result.value); // { name: "John" }} else {  console.error(result.error); // Error}

Result objects can be chained:

function divide(a: number, b: number): Result<number, string> {  return b === 0 ? err("Division by zero") : ok(a / b);}
const result = parseNumber("42").andThen((num) => divide(num, 2));
if (result.isOk()) {  console.log("Result:", result.value);} else {  console.error("Error:", result.error);}

You can also provide a default value if the result is an error:

const value = parseNumber("invalid").unwrapOr(0); // 0

NeverThrow also provides a ResultAsync type for handling asynchronous operations. This is a thenable object that can be awaited, and/or chained with other operations:

const result = await ResultAsync.fromPromise(  fetch("https://api.example.com/data"),)  .map((response) => response.json())  .mapErr((error) => `Failed to fetch data: ${error}`);
if (result.isOk()) {  console.log("Data:", result.value);} else {  console.error("Error:", result.error);}

See the NeverThrow documentation for more information.

AaveKit TypeScript includes first-class support for viem, ethers v6, Privy, thirdweb and Turnkey wallets.

npm install viem@2

Among the actions provided by AaveKit TypeScript, some are specifically designed to handle protocol interactions such as supplying, borrowing, withdrawing, repaying, and more.

There are two main types of transaction actions:

To send transactions, follow the steps below.

import { sendWith } from "@aave/client/viem";

import { foobar } from "@aave/client/actions";import { client } from "./client";
const result = foobar(client);

import { foobar } from "@aave/client/actions";import { sendWith } from "@aave/client/viem";import { createWalletClient, http } from "viem";import { privateKeyToAccount } from "viem/accounts";
import { client } from "./client";
const wallet = createWalletClient({  account: privateKeyToAccount("<PRIVATE_KEY>"),  transport: http(),});
const result = foobar(client)  .andThen(sendWith(wallet))  .andThen(client.waitForTransaction);

if (result.isErr()) {  switch (result.error.name) {    case "CancelError":      // The user cancelled the operation      return;
    case "SigningError":      // Most likely the user rejected the transaction      console.error(`Failed to sign the transaction: ${result.error.message}`);      break;
    case "TimeoutError":      console.error(`Transaction timed out: ${result.error.message}`);      break;
    case "TransactionError":      console.error(`Transaction failed: ${result.error.message}`);      break;
    case "ValidationError":      console.error(        "Insufficient balance:",        `required: ${result.error.cause.required.value.toDisplayString(2)}`,        `available: ${result.error.cause.available.value.toDisplayString(2)}`,      );      break;
    case "UnexpectedError":      console.error(result.error.message);      break;  }  return;} else {  console.log(result.value.txHash); // TxHash}

Some Aave operations require EIP-712 typed data signatures for the following:

import { signTypedDataWith, permitWith } from "@aave/client/viem";

Then, use them as described in the specific operation guide.