Liquidations
The health of the Aave Protocol is dependant on the 'health' of the loans within the system, also known as the 'health factor'. When the 'health factor' of an account's total loans is below 1, anyone can make a liquidationCall()
to the LendingPool
contract, paying back part of the debt owed and receiving discounted collateral in return (also known as the liquidation bonus as listed here).
This incentivises third parties to participate in the health of the overall protocol, by acting in their own interest (to receive the discounted collateral) and as a result, ensure loans are sufficiently collateralised.
There are multiple ways to participate in liquidations:
By using the Liquidations module in the Aave app: https://app.aave.com/liquidations.
By calling the
liquidationCall()
directly in the LendingPool contract.By creating your own automated bot or system to liquidate loans.
This section will focus on (2) and (3).
For liquidation calls to be profitable, you must take into account the gas cost involved in liquidating the loan. If a high gas price is used, then the liquidation may be unprofitable for you. See the 'Calculating profitability vs gas cost' section for more details.
0. Prerequisites
When making a liquidationCall()
, you must:
Know the account (i.e. the ethereum address:
_user
) whose health factor is below 1.Know the valid debt amount (
_purchaseAmount
) and debt asset (_reserve
) that can be paid.The close factor is 0.5, which means that only a maximum of 50% of the debt can be liquidated per valid
liquidationCall()
.As mentioned here, you can set the
_purchaseAmount
touint(-1)
and the protocol will proceed with the highest possible liquidation allowed by the close factor.You must already have a sufficient balance of the debt asset, which will be used by the
liquidationCall()
to pay back the debts.
Know the collateral asset (
_collateral
) you are closing. I.e. the collateral asset that the user has 'backing' their outstanding loan that you will partly receive as a 'bonus'.Whether you want to receive aTokens or the underlying asset (
_receiveaToken
) after a successfulliquidationCall()
.
1. Getting accounts to liquidate
Only user accounts that have a health factor below 1 can be liquidated. There are multiple ways you can get the health factor, with most of them involving 'user account data'.
"Users" in the Aave Protocol refer to a single ethereum address that has interacted with the protocol. This can be an externally owned account or contract.
On-chain
To gather user account data from on-chain data, one way would be to monitor emitted events from the protocol and keep an up to date index of user data locally.
Events are emitted each time a user interacts with the protocol (deposit, repay, borrow, etc). A list of these events can be found in the Emitted Events section.
When you have the user's address, you can simply call
getUserAccountData()
to read the user's currenthealthFactor
. If thehealthFactor
is below 1, then the account can be liquidated.
Our API
The liquidations endpoint (both app and API) are currently being reworked.
The liquidations interface in the app will return soon. The liquidations API data should be double checked via getUserAccountData
on LendingPool.
We have a limited API that powers app.aave.com/liquidations, that is also publicly available. Note that there is a small delay on the API due to Redis caching to prevent server overload. The server data is fetched every 20 seconds.
To access this API, send a GET request to
https://protocol-api.aave.com/liquidations?get=proto
for the main Aave market, orhttps://protocol-api.aave.com/liquidations?get=uniswap
for the Uniswap market.Data for all the user accounts that can be liquidated (i.e. health factor < 1) will be returned as JSON. An example is below:
GraphQL
Similarly to the sections above, you will need to gather user account data and keep an index of the user data locally.
Since GraphQL does not provide real time calculated user data such as the
healthFactor
, you will need to compute this yourself. The easiest way is to use the Aave.js package, which has methods to compute summary user data.The data you will need to pass into the Aave.js method's can be fetched from our subgraph, namely the
UserReserve
objects.
2. Executing the liquidation call
Once you have the account(s) to liquidate, you will need to calculate the amount of collateral that can be liquidated:
Use
getUserReserveData()
(for Solidity) or theUserReserve
object (for GraphQL) with the relevant parameters.For reserves that have
usageAsCollateralEnabled
astrue
, thecurrentATokenBalance
multiplied by the current close factor is the amount that can be liquidated.For example, if the current close factor is 0.5 and the aToken balance is 1e18 tokens, then the maximum amount that can be liquidated is 5e17.
You can also pass in
uint(-1)
as the_purchaseAmount
inliquidationCall()
to liquidate the maximum amount allowed.
In Aave V1, flash loans within the protocol are not available due to reentrancy protections, therefore cannot be used in liquidation calls.
Solidity
Below is an example contract. When making the liquidationCall()
to the LendingPool contract, your contract must already have at least _purchaseAmount
of _reserve
.
Javascript
A similar call can be made with a package such as Web3.js. The account making the call must already have at least the _purchaseAmount
of _reserve
.
3. Setting up a bot
Depending on your environment, preferred programming tools and languages, your bot should:
Ensure it has enough (or access to enough) funds when liquidating.
Calculate the profitability of liquidating loans vs gas costs, taking into account the most lucrative collateral to liquidate.
Ensure it has access to the latest protocol user data.
Have the usual fail safes and security you'd expect for any production service.
Calculating profitability vs gas cost
One way to calculate the profitability is the following:
Store and retrieve each collateral's relevant details such as address, decimals used, and liquidation bonus as listed here.
Get the user's collateral balance (
aTokenBalance
).Get the asset's price according to the Aave's oracle contract (
getAssetPrice()
).The maximum collateral bonus you can receive will be the collateral balance (2) multiplied by the liquidation bonus (1) multiplied by the collateral asset's price in ETH (3). Note that for assets such as USDC, the number of decimals are different from other assets.
The maximum cost of your transaction will be your gas price multiplied by the amount of gas used. You should be able to get a good estimation of the gas amount used by calling
estimateGas
via your web3 provider.Your approximate profit will be the value of the collateral bonus (4) minus the cost of your transaction (5).
Appendix
How is health factor calculated?
The health factor is calculated from: the user's collateral balance (in ETH) multiplied by the current liquidation threshold for all the user's outstanding assets, divided by 100, divided by the user's borrow balance and fees (in ETH). More info here.
This can be both calculated off-chain and on-chain, see Aave.js and the LendingPoolDataProvider contract, respectively.
How is liquidation bonus determined?
At the moment, liquidation bonuses are evaluated and determined by the risk team based on liquidity risk and updated here.
This will change in the future with Aave Protocol Governance.
Price oracles
Aave Protocol uses Chainlink as a price oracle, with a backup oracle in case of a Chainlink malfunction. See our Price Oracle section for more details.
The health factor of accounts is determined by the user's account data and the price of relevant assets, as last updated by the Price Oracle.
Last updated