TypeScript

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, evmAddress, chainId } from "@aave/client";import { chains } from "@aave/client/actions";
import { client } from "./client.ts";
// Fetch all chains supported by Aaveconst result = await chains(client);
if (result.isOk()) {  console.log("Chains:", result.value);} else {  console.error("Error:", result.error);}

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, and thirdweb 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: ${result.error.cause.required.value} required.`      );      break;
    case "UnexpectedError":      console.error(result.error.message);      break;  }  return;} else {  console.log(result.value); // TxHash}

Some Aave operations support permit functionality using EIP-2612 signatures to authorize ERC-20 token transfers within the same transaction. The permit approach has a few benefits:

As with sendWith, import the provider-specific signERC20PermitWith helper to sign ERC-20 permits.

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

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