Incentive Programs#Copy

Learn how to discover and claim incentive rewards on Aave v4.

Aave v4 reserves may offer additional incentives beyond base lending rates. These incentives are distributed through Merkl, a decentralized incentive distribution platform, or through Points programs that reward users with points multipliers.

Potential rewards are available in the rewards array of the Reserve Summary.

interface Reserve {  // …  summary: {    rewards: Reward[];    // …  };}
type Reward =  | MerklSupplyReward  | MerklBorrowReward  | SupplyPointsReward  | BorrowPointsReward;

Supply rewards can be present on suppliable reserves.

Merkl supply rewards represent an extra APY on top of the base reserve supply APY. The accrued extra interest is paid in the specified payout token when the incentive campaign reaches its maturity.

interface MerklSupplyReward {  __typename: "MerklSupplyReward";  id: string;  startDate: Date;  endDate: Date;  extraApy: PercentNumber;  payoutToken: Erc20Token;  criteria: MerklCriteria[];  userEligible: boolean;}

Where:

Some reserves participate in Points programs. Users who supply into these reserves accrue points over time proportional to their position size.

interface SupplyPointsReward {  __typename: "SupplyPointsReward";  id: string;  program: PointsProgram;  name: string;  startDate: Date;  endDate: Date | null;  multiplier: number;  criteria: PointsCriteria[];  userEligible: boolean;}

Where:

Borrow rewards can be present on borrowable reserves.

Merkl borrow rewards represent an APY discount on the user's borrow rate (which includes their Risk Premium). The accrued interest discount is paid in the specified payout token when the incentive campaign reaches its maturity.

interface MerklBorrowReward {  __typename: "MerklBorrowReward";  id: string;  startDate: Date;  endDate: Date;  discountApy: PercentNumber;  payoutToken: Erc20Token;  criteria: MerklCriteria[];  userEligible: boolean;}

Where:

Similarly, borrowing from certain reserves can accrue points in a Points program.

interface BorrowPointsReward {  __typename: "BorrowPointsReward";  id: string;  program: PointsProgram;  name: string;  startDate: Date;  endDate: Date | null;  multiplier: number;  criteria: PointsCriteria[];  userEligible: boolean;}

Where:

A PointsProgram represents a loyalty or incentive system. Users accumulate points over time based on their supply or borrow position. The externalUrl links to the program's website where users can view their accumulated points.

interface PointsProgram {  __typename: "PointsProgram";  id: string;  name: string;  externalUrl: string | null;  iconUrl: string | null;}

Each reward may have eligibility criteria that users must meet. Both Merkl and Points criteria share the same shape (id, text, userPassed) but use distinct GraphQL types.

// Merkl rewards use MerklCriteriainterface MerklCriteria {  __typename: "MerklGenericCriteria";  id: string;  text: string;  userPassed: boolean;}
// Points rewards use PointsCriteriainterface PointsCriteria {  __typename: "PointsGenericCriteria";  id: string;  text: string;  userPassed: boolean;}

Rewards become claimable when their incentive campaign reaches maturity. Campaigns are often renewed upon reaching their end date, so users should check for new reward opportunities periodically.

Fetch the user's matured rewards that are ready to claim.

import {  chainId,  useUserClaimableRewards,  type EvmAddress,} from "@aave/react";
function ClaimableRewards({ user }: { user: EvmAddress }) {  const { data, loading, error } = useUserClaimableRewards({    user,    chainId: chainId(1),  });
  if (loading) return <div>Loading…</div>;
  if (error) return <div>Error: {error.message}</div>;
  if (data.length === 0) return <div>No claimable rewards</div>;
  return (    <div>      {data.map((reward) => (        <div key={reward.id}>          <p>Amount: {reward.claimable.amount.value.toDecimalPlaces(2)}</p>          <p>Claim until: {reward.claimUntil.toLocaleDateString()}</p>        </div>      ))}    </div>  );}

The UserMerklClaimableReward type contains details about each claimable reward:

interface UserMerklClaimableReward {  __typename: "UserMerklClaimableReward";  id: string;  claimable: Erc20Amount;  startDate: Date;  endDate: Date;  claimUntil: Date;}

Where:

Once you have claimable rewards, collect them individually or all at once in a single transaction.

import { useWalletClient } from "wagmi";import { useSendTransaction } from "@aave/react/viem";
// …
const { data: wallet } = useWalletClient();const [sendTransaction] = useSendTransaction(wallet);

import { useClaimRewards } from "@aave/react";
const [claim, { loading, error }] = useClaimRewards((transaction) =>  sendTransaction(transaction),);

import {  chainId,  useUserClaimableRewards,  rewardId,  evmAddress,} from "@aave/react";
const { data: claimableRewards } = useUserClaimableRewards({  user: evmAddress(wallet.account.address),  chainId: chainId(1),  suspense: true,});
const execute = async () => {  if (claimableRewards.length > 0) {    const result = await claim({      ids: claimableRewards.map((reward) => rewardId(reward.id)),      user: evmAddress(wallet.account.address),      chainId: chainId(1),    });
    // …  }};

const execute = async () => {  const result = await claim(/* … */);
  if (result.isErr()) {    switch (result.error.name) {      case "CancelError":        // The user cancelled the operation        return;
      case "SigningError":        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 "UnexpectedError":        console.error(result.error.message);        break;    }    return;  }
  console.log("Rewards claimed successfully with hash:", result.value.txHash);};