mirror of
https://github.com/Instadapp/aave-protocol-v2.git
synced 2024-07-29 21:47:30 +00:00
462 lines
19 KiB
Solidity
462 lines
19 KiB
Solidity
// SPDX-License-Identifier: agpl-3.0
|
|
pragma solidity 0.6.12;
|
|
pragma experimental ABIEncoderV2;
|
|
|
|
import {ILendingPoolAddressesProvider} from './ILendingPoolAddressesProvider.sol';
|
|
import {DataTypes} from '../protocol/libraries/types/DataTypes.sol';
|
|
|
|
interface ILendingPool {
|
|
/**
|
|
* @dev Emitted on deposit()
|
|
* @param reserve The address of the underlying asset of the reserve
|
|
* @param user The address initiating the deposit
|
|
* @param onBehalfOf The beneficiary of the deposit, receiving the aTokens
|
|
* @param amount The amount deposited
|
|
* @param referral The referral code used
|
|
**/
|
|
event Deposit(
|
|
address indexed reserve,
|
|
address user,
|
|
address indexed onBehalfOf,
|
|
uint256 amount,
|
|
uint16 indexed referral
|
|
);
|
|
|
|
/**
|
|
* @dev Emitted on withdraw()
|
|
* @param reserve The address of the underlyng asset being withdrawn
|
|
* @param user The address initiating the withdrawal, owner of aTokens
|
|
* @param to Address that will receive the underlying
|
|
* @param amount The amount to be withdrawn
|
|
**/
|
|
event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount);
|
|
|
|
/**
|
|
* @dev Emitted on borrow() and flashLoan() when debt needs to be opened
|
|
* @param reserve The address of the underlying asset being borrowed
|
|
* @param user The address of the user initiating the borrow(), receiving the funds on borrow() or just
|
|
* initiator of the transaction on flashLoan()
|
|
* @param onBehalfOf The address that will be getting the debt
|
|
* @param amount The amount borrowed out
|
|
* @param borrowRateMode The rate mode: 1 for Stable, 2 for Variable
|
|
* @param borrowRate The numeric rate at which the user has borrowed
|
|
* @param referral The referral code used
|
|
**/
|
|
event Borrow(
|
|
address indexed reserve,
|
|
address user,
|
|
address indexed onBehalfOf,
|
|
uint256 amount,
|
|
uint256 borrowRateMode,
|
|
uint256 borrowRate,
|
|
uint16 indexed referral
|
|
);
|
|
|
|
/**
|
|
* @dev Emitted on repay()
|
|
* @param reserve The address of the underlying asset of the reserve
|
|
* @param user The beneficiary of the repayment, getting his debt reduced
|
|
* @param repayer The address of the user initiating the repay(), providing the funds
|
|
* @param amount The amount repaid
|
|
**/
|
|
event Repay(
|
|
address indexed reserve,
|
|
address indexed user,
|
|
address indexed repayer,
|
|
uint256 amount
|
|
);
|
|
|
|
/**
|
|
* @dev Emitted on swapBorrowRateMode()
|
|
* @param reserve The address of the underlying asset of the reserve
|
|
* @param user The address of the user swapping his rate mode
|
|
* @param rateMode The rate mode that the user wants to swap to
|
|
**/
|
|
event Swap(address indexed reserve, address indexed user, uint256 rateMode);
|
|
|
|
/**
|
|
* @dev Emitted on setUserUseReserveAsCollateral()
|
|
* @param reserve The address of the underlying asset of the reserve
|
|
* @param user The address of the user enabling the usage as collateral
|
|
**/
|
|
event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user);
|
|
|
|
/**
|
|
* @dev Emitted on setUserUseReserveAsCollateral()
|
|
* @param reserve The address of the underlying asset of the reserve
|
|
* @param user The address of the user enabling the usage as collateral
|
|
**/
|
|
event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user);
|
|
|
|
/**
|
|
* @dev Emitted on rebalanceStableBorrowRate()
|
|
* @param reserve The address of the underlying asset of the reserve
|
|
* @param user The address of the user for which the rebalance has been executed
|
|
**/
|
|
event RebalanceStableBorrowRate(address indexed reserve, address indexed user);
|
|
|
|
/**
|
|
* @dev Emitted on flashLoan()
|
|
* @param target The address of the flash loan receiver contract
|
|
* @param initiator The address initiating the flash loan
|
|
* @param asset The address of the asset being flash borrowed
|
|
* @param amount The amount flash borrowed
|
|
* @param premium The fee flash borrowed
|
|
* @param referralCode The referral code used
|
|
**/
|
|
event FlashLoan(
|
|
address indexed target,
|
|
address indexed initiator,
|
|
address indexed asset,
|
|
uint256 amount,
|
|
uint256 premium,
|
|
uint16 referralCode
|
|
);
|
|
|
|
/**
|
|
* @dev Emitted when the pause is triggered.
|
|
*/
|
|
event Paused();
|
|
|
|
/**
|
|
* @dev Emitted when the pause is lifted.
|
|
*/
|
|
event Unpaused();
|
|
|
|
/**
|
|
* @dev Emitted when a borrower is liquidated. This event is emitted by the LendingPool via
|
|
* LendingPoolCollateral manager using a DELEGATECALL
|
|
* This allows to have the events in the generated ABI for LendingPool.
|
|
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
|
|
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
|
|
* @param user The address of the borrower getting liquidated
|
|
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
|
|
* @param liquidatedCollateralAmount The amount of collateral received by the liiquidator
|
|
* @param liquidator The address of the liquidator
|
|
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
|
|
* to receive the underlying collateral asset directly
|
|
**/
|
|
event LiquidationCall(
|
|
address indexed collateralAsset,
|
|
address indexed debtAsset,
|
|
address indexed user,
|
|
uint256 debtToCover,
|
|
uint256 liquidatedCollateralAmount,
|
|
address liquidator,
|
|
bool receiveAToken
|
|
);
|
|
|
|
/**
|
|
* @dev Emitted when the state of a reserve is updated. NOTE: This event is actually declared
|
|
* in the ReserveLogic library and emitted in the updateInterestRates() function. Since the function is internal,
|
|
* the event will actually be fired by the LendingPool contract. The event is therefore replicated here so it
|
|
* gets added to the LendingPool ABI
|
|
* @param reserve The address of the underlying asset of the reserve
|
|
* @param liquidityRate The new liquidity rate
|
|
* @param stableBorrowRate The new stable borrow rate
|
|
* @param variableBorrowRate The new variable borrow rate
|
|
* @param liquidityIndex The new liquidity index
|
|
* @param variableBorrowIndex The new variable borrow index
|
|
**/
|
|
event ReserveDataUpdated(
|
|
address indexed reserve,
|
|
uint256 liquidityRate,
|
|
uint256 stableBorrowRate,
|
|
uint256 variableBorrowRate,
|
|
uint256 liquidityIndex,
|
|
uint256 variableBorrowIndex
|
|
);
|
|
|
|
/**
|
|
* @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
|
|
* - E.g. User deposits 100 USDC and gets in return 100 aUSDC
|
|
* @param asset The address of the underlying asset to deposit
|
|
* @param amount The amount to be deposited
|
|
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
|
|
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
|
|
* is a different wallet
|
|
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
|
|
* 0 if the action is executed directly by the user, without any middle-man
|
|
**/
|
|
function deposit(
|
|
address asset,
|
|
uint256 amount,
|
|
address onBehalfOf,
|
|
uint16 referralCode
|
|
) external;
|
|
|
|
/**
|
|
* @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
|
|
* E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
|
|
* @param asset The address of the underlying asset to withdraw
|
|
* @param amount The underlying amount to be withdrawn
|
|
* - Send the value type(uint256).max in order to withdraw the whole aToken balance
|
|
* @param to Address that will receive the underlying, same as msg.sender if the user
|
|
* wants to receive it on his own wallet, or a different address if the beneficiary is a
|
|
* different wallet
|
|
* @return The final amount withdrawn
|
|
**/
|
|
function withdraw(
|
|
address asset,
|
|
uint256 amount,
|
|
address to
|
|
) external returns (uint256);
|
|
|
|
/**
|
|
* @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
|
|
* already deposited enough collateral, or he was given enough allowance by a credit delegator on the
|
|
* corresponding debt token (StableDebtToken or VariableDebtToken)
|
|
* - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
|
|
* and 100 stable/variable debt tokens, depending on the `interestRateMode`
|
|
* @param asset The address of the underlying asset to borrow
|
|
* @param amount The amount to be borrowed
|
|
* @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
|
|
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
|
|
* 0 if the action is executed directly by the user, without any middle-man
|
|
* @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
|
|
* calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
|
|
* if he has been given credit delegation allowance
|
|
**/
|
|
function borrow(
|
|
address asset,
|
|
uint256 amount,
|
|
uint256 interestRateMode,
|
|
uint16 referralCode,
|
|
address onBehalfOf
|
|
) external;
|
|
|
|
/**
|
|
* @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
|
|
* - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
|
|
* @param asset The address of the borrowed underlying asset previously borrowed
|
|
* @param amount The amount to repay
|
|
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
|
|
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
|
|
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
|
|
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
|
|
* other borrower whose debt should be removed
|
|
* @return The final amount repaid
|
|
**/
|
|
function repay(
|
|
address asset,
|
|
uint256 amount,
|
|
uint256 rateMode,
|
|
address onBehalfOf
|
|
) external returns (uint256);
|
|
|
|
/**
|
|
* @notice Deposit with transfer approval of asset to be deposited done via permit function
|
|
* see: https://eips.ethereum.org/EIPS/eip-2612 and https://eips.ethereum.org/EIPS/eip-713
|
|
* @param asset The address of the underlying asset to deposit
|
|
* @param amount The amount to be deposited
|
|
* @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
|
|
* wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
|
|
* is a different wallet
|
|
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
|
|
* 0 if the action is executed directly by the user, without any middle-man
|
|
* @param permitV V parameter of ERC712 permit sig
|
|
* @param permitR R parameter of ERC712 permit sig
|
|
* @param permitS S parameter of ERC712 permit sig
|
|
**/
|
|
function depositWithPermit(
|
|
address asset,
|
|
uint256 amount,
|
|
address onBehalfOf,
|
|
uint16 referralCode,
|
|
uint256 deadline,
|
|
uint8 permitV,
|
|
bytes32 permitR,
|
|
bytes32 permitS
|
|
) external;
|
|
|
|
/**
|
|
* @notice Repay with transfer approval of asset to be repaid done via permit function
|
|
* see: https://eips.ethereum.org/EIPS/eip-2612 and https://eips.ethereum.org/EIPS/eip-713
|
|
* @param asset The address of the borrowed underlying asset previously borrowed
|
|
* @param amount The amount to repay
|
|
* - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
|
|
* @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
|
|
* @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
|
|
* user calling the function if he wants to reduce/remove his own debt, or the address of any other
|
|
* other borrower whose debt should be removed
|
|
* @param permitV V parameter of ERC712 permit sig
|
|
* @param permitR R parameter of ERC712 permit sig
|
|
* @param permitS S parameter of ERC712 permit sig
|
|
* @return The final amount repaid
|
|
**/
|
|
function repayWithPermit(
|
|
address asset,
|
|
uint256 amount,
|
|
uint256 rateMode,
|
|
address onBehalfOf,
|
|
uint256 deadline,
|
|
uint8 permitV,
|
|
bytes32 permitR,
|
|
bytes32 permitS
|
|
) external returns (uint256);
|
|
|
|
/**
|
|
* @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa
|
|
* @param asset The address of the underlying asset borrowed
|
|
* @param rateMode The rate mode that the user wants to swap to
|
|
**/
|
|
function swapBorrowRateMode(address asset, uint256 rateMode) external;
|
|
|
|
/**
|
|
* @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
|
|
* - Users can be rebalanced if the following conditions are satisfied:
|
|
* 1. Usage ratio is above 95%
|
|
* 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been
|
|
* borrowed at a stable rate and depositors are not earning enough
|
|
* @param asset The address of the underlying asset borrowed
|
|
* @param user The address of the user to be rebalanced
|
|
**/
|
|
function rebalanceStableBorrowRate(address asset, address user) external;
|
|
|
|
/**
|
|
* @dev Allows depositors to enable/disable a specific deposited asset as collateral
|
|
* @param asset The address of the underlying asset deposited
|
|
* @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise
|
|
**/
|
|
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external;
|
|
|
|
/**
|
|
* @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
|
|
* - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
|
|
* a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
|
|
* @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
|
|
* @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
|
|
* @param user The address of the borrower getting liquidated
|
|
* @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
|
|
* @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants
|
|
* to receive the underlying collateral asset directly
|
|
**/
|
|
function liquidationCall(
|
|
address collateralAsset,
|
|
address debtAsset,
|
|
address user,
|
|
uint256 debtToCover,
|
|
bool receiveAToken
|
|
) external;
|
|
|
|
/**
|
|
* @dev Allows smartcontracts to access the liquidity of the pool within one transaction,
|
|
* as long as the amount taken plus a fee is returned.
|
|
* IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration.
|
|
* For further details please visit https://developers.aave.com
|
|
* @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface
|
|
* @param assets The addresses of the assets being flash-borrowed
|
|
* @param amounts The amounts amounts being flash-borrowed
|
|
* @param modes Types of the debt to open if the flash loan is not returned:
|
|
* 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
|
|
* 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
|
|
* 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
|
|
* @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2
|
|
* @param params Variadic packed params to pass to the receiver as extra information
|
|
* @param referralCode Code used to register the integrator originating the operation, for potential rewards.
|
|
* 0 if the action is executed directly by the user, without any middle-man
|
|
**/
|
|
function flashLoan(
|
|
address receiverAddress,
|
|
address[] calldata assets,
|
|
uint256[] calldata amounts,
|
|
uint256[] calldata modes,
|
|
address onBehalfOf,
|
|
bytes calldata params,
|
|
uint16 referralCode
|
|
) external;
|
|
|
|
/**
|
|
* @dev Returns the user account data across all the reserves
|
|
* @param user The address of the user
|
|
* @return totalCollateralETH the total collateral in ETH of the user
|
|
* @return totalDebtETH the total debt in ETH of the user
|
|
* @return availableBorrowsETH the borrowing power left of the user
|
|
* @return currentLiquidationThreshold the liquidation threshold of the user
|
|
* @return ltv the loan to value of the user
|
|
* @return healthFactor the current health factor of the user
|
|
**/
|
|
function getUserAccountData(address user)
|
|
external
|
|
view
|
|
returns (
|
|
uint256 totalCollateralETH,
|
|
uint256 totalDebtETH,
|
|
uint256 availableBorrowsETH,
|
|
uint256 currentLiquidationThreshold,
|
|
uint256 ltv,
|
|
uint256 healthFactor
|
|
);
|
|
|
|
function initReserve(
|
|
address reserve,
|
|
address aTokenAddress,
|
|
address stableDebtAddress,
|
|
address variableDebtAddress,
|
|
address interestRateStrategyAddress
|
|
) external;
|
|
|
|
function setReserveInterestRateStrategyAddress(address reserve, address rateStrategyAddress)
|
|
external;
|
|
|
|
function setConfiguration(address reserve, uint256 configuration) external;
|
|
|
|
/**
|
|
* @dev Returns the configuration of the reserve
|
|
* @param asset The address of the underlying asset of the reserve
|
|
* @return The configuration of the reserve
|
|
**/
|
|
function getConfiguration(address asset)
|
|
external
|
|
view
|
|
returns (DataTypes.ReserveConfigurationMap memory);
|
|
|
|
/**
|
|
* @dev Returns the configuration of the user across all the reserves
|
|
* @param user The user address
|
|
* @return The configuration of the user
|
|
**/
|
|
function getUserConfiguration(address user)
|
|
external
|
|
view
|
|
returns (DataTypes.UserConfigurationMap memory);
|
|
|
|
/**
|
|
* @dev Returns the normalized income normalized income of the reserve
|
|
* @param asset The address of the underlying asset of the reserve
|
|
* @return The reserve's normalized income
|
|
*/
|
|
function getReserveNormalizedIncome(address asset) external view returns (uint256);
|
|
|
|
/**
|
|
* @dev Returns the normalized variable debt per unit of asset
|
|
* @param asset The address of the underlying asset of the reserve
|
|
* @return The reserve normalized variable debt
|
|
*/
|
|
function getReserveNormalizedVariableDebt(address asset) external view returns (uint256);
|
|
|
|
/**
|
|
* @dev Returns the state and configuration of the reserve
|
|
* @param asset The address of the underlying asset of the reserve
|
|
* @return The state of the reserve
|
|
**/
|
|
function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);
|
|
|
|
function finalizeTransfer(
|
|
address asset,
|
|
address from,
|
|
address to,
|
|
uint256 amount,
|
|
uint256 balanceFromAfter,
|
|
uint256 balanceToBefore
|
|
) external;
|
|
|
|
function getReservesList() external view returns (address[] memory);
|
|
|
|
function getAddressesProvider() external view returns (ILendingPoolAddressesProvider);
|
|
|
|
function setPause(bool val) external;
|
|
|
|
function paused() external view returns (bool);
|
|
}
|