Aave V3 Incentives on Aptos

Reference for the incentives modules in sources/aave-periphery of the aave-pool package.

The fee collector, coin migration and UI pool data provider modules are on the Periphery page.

Incentives

The incentives system in Aave allows for distributing rewards to users who supply or borrow assets in the protocol. The system is managed through several key modules that work together to configure, track, and distribute rewards.

RewardsController

The rewards_controller module is the main component for managing incentives in the Aave protocol. It handles the distribution of rewards to protocol participants who hold incentivized assets (aTokens or variableDebtTokens).

Users accrue rewards automatically when they hold these tokens without needing to stake or lock their assets. The rewards can be claimed through various functions that provide flexibility in how rewards are collected.

Key Structures

struct RewardsConfigInput has store, drop {
    emission_per_second: u128,
    total_supply: u256,
    distribution_end: u32,
    asset: address,
    reward: address,
    pull_rewards_transfer_strategy: Object<PullRewardsTransferStrategy>
}

This structure defines the configuration for a reward emission, including:

• emission_per_second: The rate at which rewards are distributed

• total_supply: The total supply of the asset being incentivized

• distribution_end: When the reward distribution ends

• asset: The address of the asset being incentivized (aToken or variableDebtToken)

• reward: The address of the reward token

• pull_rewards_transfer_strategy: The strategy for transferring rewards

Write Methods

claim_rewards

public fun claim_rewards(
    caller: &signer,
    assets: vector<address>,
    amount: u256,
    to: address,
    reward: address,
    rewards_controller_address: address
): u256

Claims rewards of one reward token for the caller on specific assets, with the rewards sent to a designated address.

Input Parameters:

Return Values:

rewards_distributor also exposes claim_rewards_on_behalf, which takes an extra user: address and requires the caller to be an authorized claimer for that user, and claim_rewards_to_self, which omits to and sends the rewards to the caller.

claim_all_rewards

public fun claim_all_rewards(
    caller: &signer,
    assets: vector<address>,
    to: address,
    rewards_controller_address: address
): (vector<address>, vector<u256>)

Claims all available rewards for the caller across specified assets, returning the list of reward tokens and amounts claimed.

Input Parameters:

Return Values:

rewards_distributor also exposes claim_all_rewards_on_behalf, which takes an extra user: address, and claim_all_rewards_to_self, which omits to.

Friend Functions

Callable only by friend modules (emission_manager, pool logic); integrators use the emission_manager entry functions.

configure_assets

public(friend) fun configure_assets(
    config_inputs: vector<RewardsConfigInput>,
    rewards_controller_address: address
)

Configures assets to incentivize with an emission of rewards per second until the end of distribution.

Input Parameters:

set_pull_rewards_transfer_strategy

public(friend) fun set_pull_rewards_transfer_strategy(
    reward: address,
    strategy: Object<PullRewardsTransferStrategy>,
    rewards_controller_address: address
)

Sets a transfer strategy for a specific reward token that determines how rewards are transferred to users.

Input Parameters:

handle_action

// This function is called when users perform actions like supply, withdraw,
// transfer, etc. to update reward calculations
public(friend) fun handle_action(
    asset: address,
    user: address,
    total_supply: u256,
    user_balance: u256,
    rewards_controller_address: address
)

Called when a user performs an action that affects their balance of an incentivized asset, updating the rewards distribution accordingly.

Input Parameters:

View Methods

get_pull_rewards_transfer_strategy

#[view]
public fun get_pull_rewards_transfer_strategy(
    reward: address,
    rewards_controller_address: address
): Option<Object<PullRewardsTransferStrategy>>

Returns the pull rewards transfer strategy for a reward, if one is set.

Input Parameters:

Return Values:

get_rewards_data

#[view]
public fun get_rewards_data(
    asset: address,
    reward: address,
    rewards_controller_address: address
): (u256, u256, u256, u256)

Returns reward data for a specific asset and reward token, including emission rates and distribution end time.

Input Parameters:

Return Values:

get_user_asset_index

// Used to get the user's index for a specific asset and reward
#[view]
public fun get_user_asset_index(
    user: address,
    asset: address,
    reward: address,
    rewards_controller_address: address
): u256

Returns the user’s index for a specific asset and reward, used for calculating accrued rewards.

Input Parameters:

Return Values:

get_user_accrued_rewards

// Used to get the user's accrued rewards for a specific reward token
#[view]
public fun get_user_accrued_rewards(
    user: address,
    reward: address,
    rewards_controller_address: address
): u256

Returns the amount of rewards accrued by a user for a specific reward token.

Input Parameters:

Return Values:

EmissionManager

The emission_manager module manages the configuration of reward emissions and acts as an administrative layer above the rewards_controller.

Key Functions

configure_assets

public entry fun configure_assets(
    account: &signer,
    emissions_per_second: vector<u128>,
    total_supplies: vector<u256>,
    distribution_ends: vector<u32>,
    assets: vector<address>,
    rewards: vector<address>,
    pull_rewards_transfer_strategies: vector<Object<PullRewardsTransferStrategy>>
)

Configures assets for incentives, creating reward configurations and passing them to the rewards controller.

Input Parameters:

set_pull_rewards_transfer_strategy

public entry fun set_pull_rewards_transfer_strategy(
    caller: &signer,
    reward: address,
    pull_rewards_transfer_strategy: Object<PullRewardsTransferStrategy>
)

Sets the transfer strategy for a specific reward token.

Input Parameters:

set_distribution_end

public entry fun set_distribution_end(
    caller: &signer,
    asset: address,
    reward: address,
    new_distribution_end: u32
)

Updates the end time for a reward distribution on a specific asset.

Input Parameters:

set_emission_admin

// Sets the admin for a specific reward token
public entry fun set_emission_admin(
    account: &signer,
    reward: address,
    new_admin: address
)

Sets the address that has permission to configure emissions for a specific reward token.

Input Parameters:

View Methods

get_rewards_controller

#[view]
public fun get_rewards_controller(): address

Returns the address of the rewards controller.

Return Values:

get_emission_admin

#[view]
public fun get_emission_admin(reward: address): address

Returns the admin address for a specific reward token.

Input Parameters:

Return Values:

TransferStrategy

The transfer_strategy module defines how rewards are transferred to users when they claim them.

PullRewardsTransferStrategy

struct PullRewardsTransferStrategy has key {
    rewards_admin: address,
    incentives_controller: address,
    rewards_vault: SignerCapability
}

This strategy pulls rewards from a vault resource account to the recipient address.

Key Functions

pull_rewards_transfer_strategy_perform_transfer

public(friend) fun pull_rewards_transfer_strategy_perform_transfer(
    incentives_controller: address,
    to: address,
    reward: address,
    amount: u256,
    strategy: Object<PullRewardsTransferStrategy>
): bool

Transfers rewards from the vault to the recipient.

Input Parameters:

Return Values:

View Methods

pull_rewards_transfer_strategy_get_incentives_controller

public fun pull_rewards_transfer_strategy_get_incentives_controller(
    strategy: Object<PullRewardsTransferStrategy>
): address

Returns the incentives controller address associated with the strategy.

Input Parameters:

Return Values:

pull_rewards_transfer_strategy_get_rewards_admin

public fun pull_rewards_transfer_strategy_get_rewards_admin(
    strategy: Object<PullRewardsTransferStrategy>
): address

Returns the rewards admin address for the strategy.

Input Parameters:

Return Values:

pull_rewards_transfer_strategy_get_rewards_vault

public fun pull_rewards_transfer_strategy_get_rewards_vault(
    strategy: Object<PullRewardsTransferStrategy>
): address

Returns the address of the rewards vault.

Input Parameters:

Return Values:

UI Incentive Data Provider

The ui_incentive_data_provider_v3 module provides view functions to query incentive data for UI display.

Key Structures

struct AggregatedReserveIncentiveData has store, drop {
    underlying_asset: address,
    a_incentive_data: IncentiveData,
    v_incentive_data: IncentiveData
}

struct IncentiveData has store, drop {
    token_address: address,
    incentive_controller_address: address,
    rewards_token_information: vector<RewardInfo>
}

struct RewardInfo has store, drop {
    reward_token_symbol: String,
    reward_token_address: address,
    emission_per_second: u256,
    // Additional fields…
}

View Methods

get_reserves_incentives_data

#[view]
public fun get_reserves_incentives_data(): vector<AggregatedReserveIncentiveData>

Returns incentive data for all reserves in the protocol, including information about reward tokens, emission rates, and other parameters.

Return Values:

get_user_reserves_incentives_data

#[view]
public fun get_user_reserves_incentives_data(user: address): vector<UserReserveIncentiveData>

Returns incentive data specific to a user, including their accrued rewards and other user-specific incentive information.

Input Parameters:

Return Values: