Instadapp/aave-protocol-v2
1
0
Fork 0
mirror of https://github.com/Instadapp/aave-protocol-v2.git synced 2024-07-29 21:47:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge changes

Browse Source
This commit is contained in:
David Racero 2020-09-09 21:26:52 +02:00
commit 53112c0982
47 changed files with 4289 additions and 984 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.prettierrc
View File

@ -3,6 +3,7 @@
"trailingComma": "es5",
"semi": true,
"singleQuote": true,
"tabWidth": 2,
"overrides": [
{
"files": "*.sol",

3
contracts/configuration/LendingPoolAddressesProviderRegistry.sol
View File

@ -5,6 +5,7 @@ import {Ownable} from '@openzeppelin/contracts/access/Ownable.sol';
import {
ILendingPoolAddressesProviderRegistry
} from '../interfaces/ILendingPoolAddressesProviderRegistry.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
/**
* @title LendingPoolAddressesProviderRegistry contract
@ -63,7 +64,7 @@ contract LendingPoolAddressesProviderRegistry is Ownable, ILendingPoolAddressesP
* @param provider the pool address to be unregistered
**/
function unregisterAddressesProvider(address provider) external override onlyOwner {
require(addressesProviders[provider] > 0, 'Provider is not registered');
require(addressesProviders[provider] > 0, Errors.PROVIDER_NOT_REGISTERED);
addressesProviders[provider] = 0;
emit AddressesProviderUnregistered(provider);
}

20
contracts/flashloan/base/FlashLoanReceiverBase.sol
View File

@ -12,27 +12,11 @@ abstract contract FlashLoanReceiverBase is IFlashLoanReceiver {
using SafeERC20 for IERC20;
using SafeMath for uint256;
ILendingPoolAddressesProvider public addressesProvider;
ILendingPoolAddressesProvider internal _addressesProvider;
constructor(ILendingPoolAddressesProvider provider) public {
addressesProvider = provider;
_addressesProvider = provider;
}
receive() external payable {}
function _transferFundsBack(
address reserve,
address destination,
uint256 amount
) internal {
transferInternal(destination, reserve, amount);
}
function transferInternal(
address destination,
address reserve,
uint256 amount
) internal {
IERC20(reserve).safeTransfer(destination, amount);
}
}

1
contracts/flashloan/interfaces/IFlashLoanReceiver.sol
View File

@ -10,7 +10,6 @@ pragma solidity ^0.6.8;
interface IFlashLoanReceiver {
function executeOperation(
address reserve,
address destination,
uint256 amount,
uint256 fee,
bytes calldata params

80
contracts/interfaces/IERC20.sol Normal file
View File

@ -0,0 +1,80 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.8;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}

2
contracts/interfaces/IERC20Detailed.sol
View File

@ -1,7 +1,7 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.8;
import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import {IERC20} from './IERC20.sol';
interface IERC20Detailed is IERC20 {
function name() external view returns (string memory);

29
contracts/interfaces/ILendingPool.sol
View File

@ -63,7 +63,7 @@ interface ILendingPool {
* @param reserve the address of the reserve
* @param user the address of the user executing the swap
**/
event Swap(address indexed reserve, address indexed user, uint256 timestamp);
event Swap(address indexed reserve, address indexed user);
/**
* @dev emitted when a user enables a reserve as collateral
@ -90,13 +90,15 @@ interface ILendingPool {
* @param target the address of the flashLoanReceiver
* @param reserve the address of the reserve
* @param amount the amount requested
* @param totalFee the total fee on the amount
* @param totalPremium the total fee on the amount
* @param referralCode the referral code of the caller
**/
event FlashLoan(
address indexed target,
address indexed reserve,
uint256 amount,
uint256 totalFee
uint256 totalPremium,
uint16 referralCode
);
/**
* @dev these events are not emitted directly by the LendingPool
@ -105,21 +107,6 @@ interface ILendingPool {
* This allows to have the events in the generated ABI for LendingPool.
**/
/**
* @dev emitted when a borrow fee is liquidated
* @param collateral the address of the collateral being liquidated
* @param reserve the address of the reserve
* @param user the address of the user being liquidated
* @param feeLiquidated the total fee liquidated
* @param liquidatedCollateralForFee the amount of collateral received by the protocol in exchange for the fee
**/
event OriginationFeeLiquidated(
address indexed collateral,
address indexed reserve,
address indexed user,
uint256 feeLiquidated,
uint256 liquidatedCollateralForFee
);
/**
* @dev emitted when a borrower is liquidated
* @param collateral the address of the collateral being liquidated
@ -259,12 +246,16 @@ interface ILendingPool {
* @param receiver The address of the contract receiving the funds. The receiver should implement the IFlashLoanReceiver interface.
* @param reserve the address of the principal reserve
* @param amount the amount requested for this flashloan
* @param params a bytes array to be sent to the flashloan executor
* @param referralCode the referral code of the caller
**/
function flashLoan(
address receiver,
address reserve,
uint256 amount,
bytes calldata params
uint256 debtType,
bytes calldata params,
uint16 referralCode
) external;
/**

290
contracts/lendingpool/LendingPool.sol
View File

@ -3,7 +3,6 @@ pragma solidity ^0.6.8;
pragma experimental ABIEncoderV2;
import {SafeMath} from '@openzeppelin/contracts/math/SafeMath.sol';
import {ReentrancyGuard} from '@openzeppelin/contracts/utils/ReentrancyGuard.sol';
import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import {
VersionedInitializable
@ -11,6 +10,7 @@ import {
import {ILendingPoolAddressesProvider} from '../interfaces/ILendingPoolAddressesProvider.sol';
import {IAToken} from '../tokenization/interfaces/IAToken.sol';
import {Helpers} from '../libraries/helpers/Helpers.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {WadRayMath} from '../libraries/math/WadRayMath.sol';
import {ReserveLogic} from '../libraries/logic/ReserveLogic.sol';
import {GenericLogic} from '../libraries/logic/GenericLogic.sol';
@ -31,7 +31,7 @@ import {ILendingPool} from '../interfaces/ILendingPool.sol';
* @author Aave
**/
contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
contract LendingPool is VersionedInitializable, ILendingPool {
using SafeMath for uint256;
using WadRayMath for uint256;
using ReserveLogic for ReserveLogic.ReserveData;
@ -42,7 +42,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
//main configuration parameters
uint256 public constant REBALANCE_DOWN_RATE_DELTA = (1e27) / 5;
uint256 public constant MAX_STABLE_RATE_BORROW_SIZE_PERCENT = 25;
uint256 public constant FLASHLOAN_FEE_TOTAL = 9;
uint256 public constant FLASHLOAN_PREMIUM_TOTAL = 9;
ILendingPoolAddressesProvider internal _addressesProvider;
@ -57,7 +57,10 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
* @dev only lending pools configurator can use functions affected by this modifier
**/
modifier onlyLendingPoolConfigurator {
require(_addressesProvider.getLendingPoolConfigurator() == msg.sender, '30');
require(
_addressesProvider.getLendingPoolConfigurator() == msg.sender,
Errors.CALLER_NOT_LENDING_POOL_CONFIGURATOR
);
_;
}
@ -89,7 +92,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
address asset,
uint256 amount,
uint16 referralCode
) external override nonReentrant {
) external override {
ReserveLogic.ReserveData storage reserve = _reserves[asset];
ValidationLogic.validateDeposit(reserve, amount);
@ -110,7 +113,6 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
//transfer to the aToken contract
IERC20(asset).safeTransferFrom(msg.sender, aToken, amount);
//solium-disable-next-line
emit Deposit(asset, msg.sender, amount, referralCode);
}
@ -119,7 +121,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
* @param asset the address of the reserve
* @param amount the underlying amount to be redeemed
**/
function withdraw(address asset, uint256 amount) external override nonReentrant {
function withdraw(address asset, uint256 amount) external override {
ReserveLogic.ReserveData storage reserve = _reserves[asset];
address aToken = reserve.aTokenAddress;
@ -154,7 +156,6 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
IAToken(aToken).burn(msg.sender, msg.sender, amountToWithdraw);
//solium-disable-next-line
emit Withdraw(asset, msg.sender, amount);
}
@ -164,65 +165,24 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
* @param asset the address of the reserve
* @param amount the amount to be borrowed
* @param interestRateMode the interest rate mode at which the user wants to borrow. Can be 0 (STABLE) or 1 (VARIABLE)
* @param referralCode a referral code for integrators
**/
function borrow(
address asset,
uint256 amount,
uint256 interestRateMode,
uint16 referralCode
) external override nonReentrant {
ReserveLogic.ReserveData storage reserve = _reserves[asset];
UserConfiguration.Map storage userConfig = _usersConfig[msg.sender];
uint256 amountInETH = IPriceOracleGetter(_addressesProvider.getPriceOracle())
.getAssetPrice(asset)
.mul(amount)
.div(10**reserve.configuration.getDecimals()); //price is in ether
ValidationLogic.validateBorrow(
reserve,
asset,
amount,
amountInETH,
interestRateMode,
MAX_STABLE_RATE_BORROW_SIZE_PERCENT,
_reserves,
_usersConfig[msg.sender],
_reservesList,
_addressesProvider.getPriceOracle()
);
//caching the current stable borrow rate
uint256 userStableRate = reserve.currentStableBorrowRate;
reserve.updateCumulativeIndexesAndTimestamp();
if (ReserveLogic.InterestRateMode(interestRateMode) == ReserveLogic.InterestRateMode.STABLE) {
IStableDebtToken(reserve.stableDebtTokenAddress).mint(msg.sender, amount, userStableRate);
} else {
IVariableDebtToken(reserve.variableDebtTokenAddress).mint(msg.sender, amount);
}
address aToken = reserve.aTokenAddress;
reserve.updateInterestRates(asset, aToken, 0, amount);
uint256 reserveIndex = reserve.index;
if (!userConfig.isBorrowing(reserveIndex)) {
userConfig.setBorrowing(reserveIndex, true);
}
//if we reached this point, we can transfer
IAToken(aToken).transferUnderlyingTo(msg.sender, amount);
emit Borrow(
asset,
msg.sender,
amount,
interestRateMode,
ReserveLogic.InterestRateMode(interestRateMode) == ReserveLogic.InterestRateMode.STABLE
? userStableRate
: reserve.currentVariableBorrowRate,
referralCode
) external override {
_executeBorrow(
ExecuteBorrowParams(
asset,
msg.sender,
amount,
interestRateMode,
_reserves[asset].aTokenAddress,
referralCode,
true
)
);
}
@ -239,7 +199,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
uint256 amount,
uint256 rateMode,
address onBehalfOf
) external override nonReentrant {
) external override {
_executeRepay(asset, msg.sender, amount, rateMode, onBehalfOf);
}
@ -300,7 +260,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
* @param asset the address of the reserve on which the user borrowed
* @param rateMode the rate mode that the user wants to swap
**/
function swapBorrowRateMode(address asset, uint256 rateMode) external override nonReentrant {
function swapBorrowRateMode(address asset, uint256 rateMode) external override {
ReserveLogic.ReserveData storage reserve = _reserves[asset];
(uint256 stableDebt, uint256 variableDebt) = Helpers.getUserCurrentDebt(msg.sender, reserve);
@ -333,12 +293,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
reserve.updateInterestRates(asset, reserve.aTokenAddress, 0, 0);
emit Swap(
asset,
msg.sender,
//solium-disable-next-line
block.timestamp
);
emit Swap(asset, msg.sender);
}
/**
@ -348,7 +303,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
* @param asset the address of the reserve
* @param user the address of the user to be rebalanced
**/
function rebalanceStableBorrowRate(address asset, address user) external override nonReentrant {
function rebalanceStableBorrowRate(address asset, address user) external override {
ReserveLogic.ReserveData storage reserve = _reserves[asset];
IStableDebtToken stableDebtToken = IStableDebtToken(reserve.stableDebtTokenAddress);
@ -356,10 +311,10 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
uint256 stableBorrowBalance = IERC20(address(stableDebtToken)).balanceOf(user);
// user must be borrowing on asset at a stable rate
require(stableBorrowBalance > 0, 'User does not have any stable rate loan for this reserve');
require(stableBorrowBalance > 0, Errors.NOT_ENOUGH_STABLE_BORROW_BALANCE);
uint256 rebalanceDownRateThreshold = reserve.currentStableBorrowRate.rayMul(
WadRayMath.ray().add(REBALANCE_DOWN_RATE_DELTA)
uint256 rebalanceDownRateThreshold = WadRayMath.ray().add(REBALANCE_DOWN_RATE_DELTA).rayMul(
reserve.currentStableBorrowRate
);
//1. user stable borrow rate is below the current liquidity rate. The loan needs to be rebalanced,
@ -371,7 +326,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
require(
userStableRate < reserve.currentLiquidityRate || userStableRate > rebalanceDownRateThreshold,
'Interest rate rebalance conditions were not met'
Errors.INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET
);
//burn old debt tokens, mint new ones
@ -393,11 +348,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
* @param asset the address of the reserve
* @param useAsCollateral true if the user wants to user the deposit as collateral, false otherwise.
**/
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral)
external
override
nonReentrant
{
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external override {
ReserveLogic.ReserveData storage reserve = _reserves[asset];
ValidationLogic.validateSetUseReserveAsCollateral(
@ -433,7 +384,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
address user,
uint256 purchaseAmount,
bool receiveAToken
) external override nonReentrant {
) external override {
address liquidationManager = _addressesProvider.getLendingPoolLiquidationManager();
//solium-disable-next-line
@ -447,7 +398,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
receiveAToken
)
);
require(success, 'Liquidation call failed');
require(success, Errors.LIQUIDATION_CALL_FAILED);
(uint256 returnCode, string memory returnMessage) = abi.decode(result, (uint256, string));
@ -457,6 +408,19 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
}
}
struct FlashLoanLocalVars {
uint256 premium;
uint256 amountPlusPremium;
uint256 amountPlusPremiumInETH;
uint256 receiverBalance;
uint256 receiverAllowance;
uint256 availableBalance;
uint256 assetPrice;
IFlashLoanReceiver receiver;
address aTokenAddress;
address oracle;
}
/**
* @dev flashes the underlying collateral on an user to swap for the owed asset and repay
* - Both the owner of the position and other liquidators can execute it
@ -477,7 +441,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
address receiver,
bytes calldata params
) external override {
require(!_flashLiquidationLocked, "REENTRANCY_NOT_ALLOWED");
require(!_flashLiquidationLocked, Errors.REENTRANCY_NOT_ALLOWED);
_flashLiquidationLocked = true;
address liquidationManager = _addressesProvider.getLendingPoolLiquidationManager();
@ -494,7 +458,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
params
)
);
require(success, 'FAILED_REPAY_WITH_COLLATERAL');
require(success, Errors.FAILED_REPAY_WITH_COLLATERAL);
(uint256 returnCode, string memory returnMessage) = abi.decode(result, (uint256, string));
@ -510,63 +474,63 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
* as long as the amount taken plus a fee is returned. NOTE 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. The receiver should implement the IFlashLoanReceiver interface.
* @param asset the address of the principal reserve
* @param amount the amount requested for this flashloan
* @param asset The address of the principal reserve
* @param amount The amount requested for this flashloan
* @param mode Type of the debt to open if the flash loan is not returned. 0 -> Don't open any debt, just revert, 1 -> stable, 2 -> variable
* @param params Variadic packed params to pass to the receiver as extra information
* @param referralCode Referral code of the flash loan
**/
function flashLoan(
address receiverAddress,
address asset,
uint256 amount,
bytes calldata params
) external override nonReentrant {
uint256 mode,
bytes calldata params,
uint16 referralCode
) external override {
ReserveLogic.ReserveData storage reserve = _reserves[asset];
FlashLoanLocalVars memory vars;
address aTokenAddress = reserve.aTokenAddress;
vars.aTokenAddress = reserve.aTokenAddress;
//check that the reserve has enough available liquidity
uint256 availableLiquidityBefore = IERC20(asset).balanceOf(aTokenAddress);
vars.premium = amount.mul(FLASHLOAN_PREMIUM_TOTAL).div(10000);
//calculate amount fee
uint256 amountFee = amount.mul(FLASHLOAN_FEE_TOTAL).div(10000);
ValidationLogic.validateFlashloan(mode, vars.premium);
require(
availableLiquidityBefore >= amount,
'There is not enough liquidity available to borrow'
);
require(amountFee > 0, 'The requested amount is too small for a FlashLoan.');
ReserveLogic.InterestRateMode debtMode = ReserveLogic.InterestRateMode(mode);
//get the FlashLoanReceiver instance
IFlashLoanReceiver receiver = IFlashLoanReceiver(receiverAddress);
vars.receiver = IFlashLoanReceiver(receiverAddress);
//transfer funds to the receiver
IAToken(aTokenAddress).transferUnderlyingTo(receiverAddress, amount);
IAToken(vars.aTokenAddress).transferUnderlyingTo(receiverAddress, amount);
//execute action of the receiver
receiver.executeOperation(asset, aTokenAddress, amount, amountFee, params);
vars.receiver.executeOperation(asset, amount, vars.premium, params);
//check that the actual balance of the core contract includes the returned amount
uint256 availableLiquidityAfter = IERC20(asset).balanceOf(aTokenAddress);
vars.amountPlusPremium = amount.add(vars.premium);
require(
availableLiquidityAfter == availableLiquidityBefore.add(amountFee),
'The actual balance of the protocol is inconsistent'
);
if (debtMode == ReserveLogic.InterestRateMode.NONE) {
IERC20(asset).transferFrom(receiverAddress, vars.aTokenAddress, vars.amountPlusPremium);
//compounding the cumulated interest
reserve.updateCumulativeIndexesAndTimestamp();
reserve.updateCumulativeIndexesAndTimestamp();
reserve.cumulateToLiquidityIndex(IERC20(vars.aTokenAddress).totalSupply(), vars.premium);
reserve.updateInterestRates(asset, vars.aTokenAddress, vars.premium, 0);
uint256 totalLiquidityBefore = availableLiquidityBefore
.add(IERC20(reserve.variableDebtTokenAddress).totalSupply())
.add(IERC20(reserve.stableDebtTokenAddress).totalSupply());
//compounding the received fee into the reserve
reserve.cumulateToLiquidityIndex(totalLiquidityBefore, amountFee);
//refresh interest rates
reserve.updateInterestRates(asset, aTokenAddress, amountFee, 0);
//solium-disable-next-line
emit FlashLoan(receiverAddress, asset, amount, amountFee);
emit FlashLoan(receiverAddress, asset, amount, vars.premium, referralCode);
} else {
// If the transfer didn't succeed, the receiver either didn't return the funds, or didn't approve the transfer.
_executeBorrow(
ExecuteBorrowParams(
asset,
msg.sender,
vars.amountPlusPremium.sub(vars.availableBalance),
mode,
vars.aTokenAddress,
referralCode,
false
)
);
}
}
/**
@ -783,9 +747,91 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable, ILendingPool {
return _reserves[asset].configuration;
}
// internal functions
struct ExecuteBorrowParams {
address asset;
address user;
uint256 amount;
uint256 interestRateMode;
address aTokenAddress;
uint16 referralCode;
bool releaseUnderlying;
}
/**
* @notice internal functions
* @dev Internal function to execute a borrowing action, allowing to transfer or not the underlying
* @param vars Input struct for the borrowing action, in order to avoid STD errors
**/
function _executeBorrow(ExecuteBorrowParams memory vars) internal {
ReserveLogic.ReserveData storage reserve = _reserves[vars.asset];
UserConfiguration.Map storage userConfig = _usersConfig[msg.sender];
address oracle = _addressesProvider.getPriceOracle();
uint256 amountInETH = IPriceOracleGetter(oracle).getAssetPrice(vars.asset).mul(vars.amount).div(
10**reserve.configuration.getDecimals()
);
ValidationLogic.validateBorrow(
reserve,
vars.asset,
vars.amount,
amountInETH,
vars.interestRateMode,
MAX_STABLE_RATE_BORROW_SIZE_PERCENT,
_reserves,
userConfig,
_reservesList,
oracle
);
uint256 reserveIndex = reserve.index;
if (!userConfig.isBorrowing(reserveIndex)) {
userConfig.setBorrowing(reserveIndex, true);
}
reserve.updateCumulativeIndexesAndTimestamp();
//caching the current stable borrow rate
uint256 currentStableRate = 0;
if (
ReserveLogic.InterestRateMode(vars.interestRateMode) == ReserveLogic.InterestRateMode.STABLE
) {
currentStableRate = reserve.currentStableBorrowRate;
IStableDebtToken(reserve.stableDebtTokenAddress).mint(
vars.user,
vars.amount,
currentStableRate
);
} else {
IVariableDebtToken(reserve.variableDebtTokenAddress).mint(vars.user, vars.amount);
}
reserve.updateInterestRates(
vars.asset,
vars.aTokenAddress,
0,
vars.releaseUnderlying ? vars.amount : 0
);
if (vars.releaseUnderlying) {
IAToken(vars.aTokenAddress).transferUnderlyingTo(msg.sender, vars.amount);
}
emit Borrow(
vars.asset,
msg.sender,
vars.amount,
vars.interestRateMode,
ReserveLogic.InterestRateMode(vars.interestRateMode) == ReserveLogic.InterestRateMode.STABLE
? currentStableRate
: reserve.currentVariableBorrowRate,
vars.referralCode
);
}
/**
* @dev adds a reserve to the array of the _reserves address

5
contracts/lendingpool/LendingPoolConfigurator.sol
View File

@ -13,6 +13,7 @@ import {ReserveConfiguration} from '../libraries/configuration/ReserveConfigurat
import {ILendingPoolAddressesProvider} from '../interfaces/ILendingPoolAddressesProvider.sol';
import {ILendingPool} from '../interfaces/ILendingPool.sol';
import {IERC20Detailed} from '../interfaces/IERC20Detailed.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
/**
* @title LendingPoolConfigurator contract
@ -178,7 +179,7 @@ contract LendingPoolConfigurator is VersionedInitializable {
modifier onlyLendingPoolManager {
require(
addressesProvider.getLendingPoolManager() == msg.sender,
'The caller must be a lending pool manager'
Errors.CALLER_NOT_LENDING_POOL_MANAGER
);
_;
}
@ -425,7 +426,7 @@ contract LendingPoolConfigurator is VersionedInitializable {
) = pool.getReserveData(asset);
require(
availableLiquidity == 0 && totalBorrowsStable == 0 && totalBorrowsVariable == 0,
'The liquidity of the reserve needs to be 0'
Errors.RESERVE_LIQUIDITY_NOT_0
);
ReserveConfiguration.Map memory currentConfig = pool.getConfiguration(asset);

57
contracts/lendingpool/LendingPoolLiquidationManager.sol
View File

@ -3,8 +3,6 @@ pragma solidity ^0.6.8;
import {SafeMath} from '@openzeppelin/contracts/math/SafeMath.sol';
import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import {ReentrancyGuard} from '@openzeppelin/contracts/utils/ReentrancyGuard.sol';
import {ReentrancyGuard} from '@openzeppelin/contracts/utils/ReentrancyGuard.sol';
import {
VersionedInitializable
} from '../libraries/openzeppelin-upgradeability/VersionedInitializable.sol';
@ -22,13 +20,14 @@ import {WadRayMath} from '../libraries/math/WadRayMath.sol';
import {PercentageMath} from '../libraries/math/PercentageMath.sol';
import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';
import {ISwapAdapter} from '../interfaces/ISwapAdapter.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
/**
* @title LendingPoolLiquidationManager contract
* @author Aave
* @notice Implements the liquidation function.
**/
contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializable {
contract LendingPoolLiquidationManager is VersionedInitializable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
using WadRayMath for uint256;
@ -156,7 +155,7 @@ contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializabl
if (vars.healthFactor >= GenericLogic.HEALTH_FACTOR_LIQUIDATION_THRESHOLD) {
return (
uint256(LiquidationErrors.HEALTH_FACTOR_ABOVE_THRESHOLD),
'Health factor is not below the threshold'
Errors.HEALTH_FACTOR_NOT_BELOW_THRESHOLD
);
}
@ -172,7 +171,7 @@ contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializabl
if (!vars.isCollateralEnabled) {
return (
uint256(LiquidationErrors.COLLATERAL_CANNOT_BE_LIQUIDATED),
'The collateral chosen cannot be liquidated'
Errors.COLLATERAL_CANNOT_BE_LIQUIDATED
);
}
@ -185,7 +184,7 @@ contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializabl
if (vars.userStableDebt == 0 && vars.userVariableDebt == 0) {
return (
uint256(LiquidationErrors.CURRRENCY_NOT_BORROWED),
'User did not borrow the specified currency'
Errors.SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER
);
}
@ -226,7 +225,7 @@ contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializabl
if (currentAvailableCollateral < vars.maxCollateralToLiquidate) {
return (
uint256(LiquidationErrors.NOT_ENOUGH_LIQUIDITY),
"There isn't enough liquidity available to liquidate"
Errors.NOT_ENOUGH_LIQUIDITY_TO_LIQUIDATE
);
}
}
@ -292,7 +291,7 @@ contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializabl
receiveAToken
);
return (uint256(LiquidationErrors.NO_ERROR), 'No errors');
return (uint256(LiquidationErrors.NO_ERROR), Errors.NO_ERRORS);
}
/**
@ -330,44 +329,45 @@ contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializabl
addressesProvider.getPriceOracle()
);
if (msg.sender != user && vars.healthFactor >= GenericLogic.HEALTH_FACTOR_LIQUIDATION_THRESHOLD) {
if (
msg.sender != user && vars.healthFactor >= GenericLogic.HEALTH_FACTOR_LIQUIDATION_THRESHOLD
) {
return (
uint256(LiquidationErrors.HEALTH_FACTOR_ABOVE_THRESHOLD),
'HEALTH_FACTOR_ABOVE_THRESHOLD'
Errors.HEALTH_FACTOR_NOT_BELOW_THRESHOLD
);
}
if (msg.sender != user) {
vars.isCollateralEnabled = collateralReserve.configuration.getLiquidationThreshold() > 0 &&
vars.isCollateralEnabled =
collateralReserve.configuration.getLiquidationThreshold() > 0 &&
userConfig.isUsingAsCollateral(collateralReserve.index);
//if collateral isn't enabled as collateral by user, it cannot be liquidated
if (!vars.isCollateralEnabled) {
return (
uint256(LiquidationErrors.COLLATERAL_CANNOT_BE_LIQUIDATED),
'COLLATERAL_CANNOT_BE_LIQUIDATED'
Errors.COLLATERAL_CANNOT_BE_LIQUIDATED
);
}
}
}
(vars.userStableDebt, vars.userVariableDebt) = Helpers.getUserCurrentDebt(
user,
debtReserve
);
(vars.userStableDebt, vars.userVariableDebt) = Helpers.getUserCurrentDebt(user, debtReserve);
if (vars.userStableDebt == 0 && vars.userVariableDebt == 0) {
return (
uint256(LiquidationErrors.CURRRENCY_NOT_BORROWED),
'CURRRENCY_NOT_BORROWED'
Errors.SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER
);
}
if (msg.sender == user || vars.healthFactor < GenericLogic.HEALTH_FACTOR_CRITICAL_THRESHOLD) {
vars.maxPrincipalAmountToLiquidate = vars.userStableDebt.add(vars.userVariableDebt);
} else {
vars.maxPrincipalAmountToLiquidate = vars.userStableDebt.add(vars.userVariableDebt).percentMul(
LIQUIDATION_CLOSE_FACTOR_PERCENT
);
vars.maxPrincipalAmountToLiquidate = vars
.userStableDebt
.add(vars.userVariableDebt)
.percentMul(LIQUIDATION_CLOSE_FACTOR_PERCENT);
}
vars.actualAmountToLiquidate = principalAmount > vars.maxPrincipalAmountToLiquidate
@ -415,12 +415,7 @@ contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializabl
//updating debt reserve
debtReserve.updateCumulativeIndexesAndTimestamp();
debtReserve.updateInterestRates(
principal,
principalAToken,
vars.actualAmountToLiquidate,
0
);
debtReserve.updateInterestRates(principal, principalAToken, vars.actualAmountToLiquidate, 0);
IERC20(principal).transferFrom(receiver, principalAToken, vars.actualAmountToLiquidate);
if (vars.userVariableDebt >= vars.actualAmountToLiquidate) {
@ -429,17 +424,13 @@ contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializabl
vars.actualAmountToLiquidate
);
} else {
IVariableDebtToken(debtReserve.variableDebtTokenAddress).burn(
user,
vars.userVariableDebt
);
IVariableDebtToken(debtReserve.variableDebtTokenAddress).burn(user, vars.userVariableDebt);
IStableDebtToken(debtReserve.stableDebtTokenAddress).burn(
user,
vars.actualAmountToLiquidate.sub(vars.userVariableDebt)
);
}
//updating collateral reserve
collateralReserve.updateCumulativeIndexesAndTimestamp();
collateralReserve.updateInterestRates(
@ -458,7 +449,7 @@ contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializabl
vars.maxCollateralToLiquidate
);
return (uint256(LiquidationErrors.NO_ERROR), 'SUCCESS');
return (uint256(LiquidationErrors.NO_ERROR), Errors.NO_ERRORS);
}
struct AvailableCollateralToLiquidateLocalVars {

78
contracts/libraries/helpers/Errors.sol Normal file
View File

@ -0,0 +1,78 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.8;
/**
* @title Errors library
* @author Aave
* @notice Implements error messages.
*/
library Errors {
// require error messages - ValidationLogic
string public constant AMOUNT_NOT_GREATER_THAN_0 = '1'; // 'Amount must be greater than 0'
string public constant NO_ACTIVE_RESERVE = '2'; // 'Action requires an active reserve'
string public constant NO_UNFREEZED_RESERVE = '3'; // 'Action requires an unfreezed reserve'
string public constant CURRENT_AVAILABLE_LIQUIDITY_NOT_ENOUGH = '4'; // 'The current liquidity is not enough'
string public constant NOT_ENOUGH_AVAILABLE_USER_BALANCE = '5'; // 'User cannot withdraw more than the available balance'
string public constant TRANSFER_NOT_ALLOWED = '6'; // 'Transfer cannot be allowed.'
string public constant BORROWING_NOT_ENABLED = '7'; // 'Borrowing is not enabled'
string public constant INVALID_INTEREST_RATE_MODE_SELECTED = '8'; // 'Invalid interest rate mode selected'
string public constant COLLATERAL_BALANCE_IS_0 = '9'; // 'The collateral balance is 0'
string public constant HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD = '10'; // 'Health factor is lesser than the liquidation threshold'
string public constant COLLATERAL_CANNOT_COVER_NEW_BORROW = '11'; // 'There is not enough collateral to cover a new borrow'
string public constant STABLE_BORROWING_NOT_ENABLED = '12'; // stable borrowing not enabled
string public constant CALLATERAL_SAME_AS_BORROWING_CURRENCY = '13'; // collateral is (mostly) the same currency that is being borrowed
string public constant AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE = '14'; // 'The requested amount is greater than the max loan size in stable rate mode
string public constant NO_DEBT_OF_SELECTED_TYPE = '15'; // 'for repayment of stable debt, the user needs to have stable debt, otherwise, he needs to have variable debt'
string public constant NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF = '16'; // 'To repay on behalf of an user an explicit amount to repay is needed'
string public constant NO_STABLE_RATE_LOAN_IN_RESERVE = '17'; // 'User does not have a stable rate loan in progress on this reserve'
string public constant NO_VARIABLE_RATE_LOAN_IN_RESERVE = '18'; // 'User does not have a variable rate loan in progress on this reserve'
string public constant UNDERLYING_BALANCE_NOT_GREATER_THAN_0 = '19'; // 'The underlying balance needs to be greater than 0'
string public constant DEPOSIT_ALREADY_IN_USE = '20'; // 'User deposit is already being used as collateral'
// require error messages - LendingPool
string public constant NOT_ENOUGH_STABLE_BORROW_BALANCE = '21'; // 'User does not have any stable rate loan for this reserve'
string public constant INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET = '22'; // 'Interest rate rebalance conditions were not met'
string public constant LIQUIDATION_CALL_FAILED = '23'; // 'Liquidation call failed'
string public constant NOT_ENOUGH_LIQUIDITY_TO_BORROW = '24'; // 'There is not enough liquidity available to borrow'
string public constant REQUESTED_AMOUNT_TOO_SMALL = '25'; // 'The requested amount is too small for a FlashLoan.'
string public constant INCONSISTENT_PROTOCOL_ACTUAL_BALANCE = '26'; // 'The actual balance of the protocol is inconsistent'
string public constant CALLER_NOT_LENDING_POOL_CONFIGURATOR = '27'; // 'The actual balance of the protocol is inconsistent'
string public constant INVALID_FLASHLOAN_MODE = '43'; //Invalid flashloan mode selected
string public constant REENTRANCY_NOT_ALLOWED = '52';
string public constant FAILED_REPAY_WITH_COLLATERAL = '53';
// require error messages - aToken
string public constant CALLER_MUST_BE_LENDING_POOL = '28'; // 'The caller of this function must be a lending pool'
string public constant INTEREST_REDIRECTION_NOT_ALLOWED = '29'; // 'Caller is not allowed to redirect the interest of the user'
string public constant CANNOT_GIVE_ALLOWANCE_TO_HIMSELF = '30'; // 'User cannot give allowance to himself'
string public constant TRANSFER_AMOUNT_NOT_GT_0 = '31'; // 'Transferred amount needs to be greater than zero'
string public constant INTEREST_ALREADY_REDIRECTED = '32'; // 'Interest is already redirected to the user'
string public constant NO_VALID_BALANCE_FOR_REDIRECTION = '33'; // 'Interest stream can only be redirected if there is a valid balance'
// require error messages - ReserveLogic
string public constant RESERVE_ALREADY_INITIALIZED = '34'; // 'Reserve has already been initialized'
string public constant LIQUIDITY_INDEX_OVERFLOW = '47'; // Liquidity index overflows uint128
string public constant VARIABLE_BORROW_INDEX_OVERFLOW = '48'; // Variable borrow index overflows uint128
string public constant LIQUIDITY_RATE_OVERFLOW = '49'; // Liquidity rate overflows uint128
string public constant VARIABLE_BORROW_RATE_OVERFLOW = '50'; // Variable borrow rate overflows uint128
string public constant STABLE_BORROW_RATE_OVERFLOW = '51'; // Stable borrow rate overflows uint128
//require error messages - LendingPoolConfiguration
string public constant CALLER_NOT_LENDING_POOL_MANAGER = '35'; // 'The caller must be a lending pool manager'
string public constant RESERVE_LIQUIDITY_NOT_0 = '36'; // 'The liquidity of the reserve needs to be 0'
//require error messages - LendingPoolAddressesProviderRegistry
string public constant PROVIDER_NOT_REGISTERED = '37'; // 'Provider is not registered'
//return error messages - LendingPoolLiquidationManager
string public constant HEALTH_FACTOR_NOT_BELOW_THRESHOLD = '38'; // 'Health factor is not below the threshold'
string public constant COLLATERAL_CANNOT_BE_LIQUIDATED = '39'; // 'The collateral chosen cannot be liquidated'
string public constant SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER = '40'; // 'User did not borrow the specified currency'
string public constant NOT_ENOUGH_LIQUIDITY_TO_LIQUIDATE = '41'; // "There isn't enough liquidity available to liquidate"
string public constant NO_ERRORS = '42'; // 'No errors'
//require error messages - Math libraries
string public constant MULTIPLICATION_OVERFLOW = '44';
string public constant ADDITION_OVERFLOW = '45';
string public constant DIVISION_BY_ZERO = '46';
}

110
contracts/libraries/logic/ReserveLogic.sol
View File

@ -10,6 +10,7 @@ import {IStableDebtToken} from '../../tokenization/interfaces/IStableDebtToken.s
import {ReserveConfiguration} from '../configuration/ReserveConfiguration.sol';
import {IReserveInterestRateStrategy} from '../../interfaces/IReserveInterestRateStrategy.sol';
import {WadRayMath} from '../math/WadRayMath.sol';
import {Errors} from '../helpers/Errors.sol';
/**
* @title ReserveLogic library
@ -48,22 +49,22 @@ library ReserveLogic {
// refer to the whitepaper, section 1.1 basic concepts for a formal description of these properties.
struct ReserveData {
//the liquidity index. Expressed in ray
uint256 lastLiquidityIndex;
//the current supply rate. Expressed in ray
uint256 currentLiquidityRate;
//the current variable borrow rate. Expressed in ray
uint256 currentVariableBorrowRate;
//the current stable borrow rate. Expressed in ray
uint256 currentStableBorrowRate;
//variable borrow index. Expressed in ray
uint256 lastVariableBorrowIndex;
//stores the reserve configuration
ReserveConfiguration.Map configuration;
address aTokenAddress;
address stableDebtTokenAddress;
address variableDebtTokenAddress;
address interestRateStrategyAddress;
//the liquidity index. Expressed in ray
uint128 lastLiquidityIndex;
//the current supply rate. Expressed in ray
uint128 currentLiquidityRate;
//the current variable borrow rate. Expressed in ray
uint128 currentVariableBorrowRate;
//the current stable borrow rate. Expressed in ray
uint128 currentStableBorrowRate;
//variable borrow index. Expressed in ray
uint128 lastVariableBorrowIndex;
uint40 lastUpdateTimestamp;
//the index of the reserve in the list of the active reserves
uint8 index;
@ -121,27 +122,31 @@ library ReserveLogic {
* @param reserve the reserve object
**/
function updateCumulativeIndexesAndTimestamp(ReserveData storage reserve) internal {
uint256 currentLiquidityRate = reserve.currentLiquidityRate;
//only cumulating if there is any income being produced
if (
IERC20(reserve.variableDebtTokenAddress).totalSupply() > 0 ||
IERC20(reserve.stableDebtTokenAddress).totalSupply() > 0
) {
if (currentLiquidityRate > 0) {
uint40 lastUpdateTimestamp = reserve.lastUpdateTimestamp;
uint256 cumulatedLiquidityInterest = MathUtils.calculateLinearInterest(
reserve.currentLiquidityRate,
currentLiquidityRate,
lastUpdateTimestamp
);
uint256 index = cumulatedLiquidityInterest.rayMul(reserve.lastLiquidityIndex);
require(index < (1 << 128), Errors.LIQUIDITY_INDEX_OVERFLOW);
reserve.lastLiquidityIndex = cumulatedLiquidityInterest.rayMul(reserve.lastLiquidityIndex);
reserve.lastLiquidityIndex = uint128(index);
uint256 cumulatedVariableBorrowInterest = MathUtils.calculateCompoundedInterest(
reserve.currentVariableBorrowRate,
lastUpdateTimestamp
);
reserve.lastVariableBorrowIndex = cumulatedVariableBorrowInterest.rayMul(
reserve.lastVariableBorrowIndex
);
//as the liquidity rate might come only from stable rate loans, we need to ensure
//that there is actual variable debt before accumulating
if (IERC20(reserve.variableDebtTokenAddress).totalSupply() > 0) {
uint256 cumulatedVariableBorrowInterest = MathUtils.calculateCompoundedInterest(
reserve.currentVariableBorrowRate,
lastUpdateTimestamp
);
index = cumulatedVariableBorrowInterest.rayMul(reserve.lastVariableBorrowIndex);
require(index < (1 << 128), Errors.VARIABLE_BORROW_INDEX_OVERFLOW);
reserve.lastVariableBorrowIndex = uint128(index);
}
}
//solium-disable-next-line
@ -162,9 +167,12 @@ library ReserveLogic {
) internal {
uint256 amountToLiquidityRatio = amount.wadToRay().rayDiv(totalLiquidity.wadToRay());
uint256 cumulatedLiquidity = amountToLiquidityRatio.add(WadRayMath.ray());
uint256 result = amountToLiquidityRatio.add(WadRayMath.ray());
reserve.lastLiquidityIndex = cumulatedLiquidity.rayMul(reserve.lastLiquidityIndex);
result = result.rayMul(reserve.lastLiquidityIndex);
require(result < (1 << 128), Errors.LIQUIDITY_INDEX_OVERFLOW);
reserve.lastLiquidityIndex = uint128(result);
}
/**
@ -180,14 +188,14 @@ library ReserveLogic {
address variableDebtTokenAddress,
address interestRateStrategyAddress
) external {
require(reserve.aTokenAddress == address(0), 'Reserve has already been initialized');
require(reserve.aTokenAddress == address(0), Errors.RESERVE_ALREADY_INITIALIZED);
if (reserve.lastLiquidityIndex == 0) {
//if the reserve has not been initialized yet
reserve.lastLiquidityIndex = WadRayMath.ray();
reserve.lastLiquidityIndex = uint128(WadRayMath.ray());
}
if (reserve.lastVariableBorrowIndex == 0) {
reserve.lastVariableBorrowIndex = WadRayMath.ray();
reserve.lastVariableBorrowIndex = uint128(WadRayMath.ray());
}
reserve.aTokenAddress = aTokenAddress;
@ -196,6 +204,15 @@ library ReserveLogic {
reserve.interestRateStrategyAddress = interestRateStrategyAddress;
}
struct UpdateInterestRatesLocalVars {
uint256 currentAvgStableRate;
uint256 availableLiquidity;
address stableDebtTokenAddress;
uint256 newLiquidityRate;
uint256 newStableRate;
uint256 newVariableRate;
}
/**
* @dev Updates the reserve current stable borrow rate Rf, the current variable borrow rate Rv and the current liquidity rate Rl.
* Also updates the lastUpdateTimestamp value. Please refer to the whitepaper for further information.
@ -210,31 +227,38 @@ library ReserveLogic {
uint256 liquidityAdded,
uint256 liquidityTaken
) internal {
uint256 currentAvgStableRate = IStableDebtToken(reserve.stableDebtTokenAddress)
UpdateInterestRatesLocalVars memory vars;
vars.stableDebtTokenAddress = reserve.stableDebtTokenAddress;
vars.currentAvgStableRate = IStableDebtToken(vars.stableDebtTokenAddress)
.getAverageStableRate();
vars.availableLiquidity = IERC20(reserveAddress).balanceOf(aTokenAddress);
(
uint256 newLiquidityRate,
uint256 newStableRate,
uint256 newVariableRate
vars.newLiquidityRate,
vars.newStableRate,
vars.newVariableRate
) = IReserveInterestRateStrategy(reserve.interestRateStrategyAddress).calculateInterestRates(
reserveAddress,
IERC20(reserveAddress).balanceOf(aTokenAddress).add(liquidityAdded).sub(liquidityTaken),
IERC20(reserve.stableDebtTokenAddress).totalSupply(),
vars.availableLiquidity.add(liquidityAdded).sub(liquidityTaken),
IERC20(vars.stableDebtTokenAddress).totalSupply(),
IERC20(reserve.variableDebtTokenAddress).totalSupply(),
currentAvgStableRate
vars.currentAvgStableRate
);
require(vars.newLiquidityRate < (1 << 128), 'ReserveLogic: Liquidity rate overflow');
require(vars.newStableRate < (1 << 128), 'ReserveLogic: Stable borrow rate overflow');
require(vars.newVariableRate < (1 << 128), 'ReserveLogic: Variable borrow rate overflow');
reserve.currentLiquidityRate = newLiquidityRate;
reserve.currentStableBorrowRate = newStableRate;
reserve.currentVariableBorrowRate = newVariableRate;
reserve.currentLiquidityRate = uint128(vars.newLiquidityRate);
reserve.currentStableBorrowRate = uint128(vars.newStableRate);
reserve.currentVariableBorrowRate = uint128(vars.newVariableRate);
emit ReserveDataUpdated(
reserveAddress,
newLiquidityRate,
newStableRate,
currentAvgStableRate,
newVariableRate,
vars.newLiquidityRate,
vars.newStableRate,
vars.currentAvgStableRate,
vars.newVariableRate,
reserve.lastLiquidityIndex,
reserve.lastVariableBorrowIndex
);

92
contracts/libraries/logic/ValidationLogic.sol
View File

@ -12,6 +12,7 @@ import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';
import {ReserveConfiguration} from '../configuration/ReserveConfiguration.sol';
import {UserConfiguration} from '../configuration/UserConfiguration.sol';
import {IPriceOracleGetter} from '../../interfaces/IPriceOracleGetter.sol';
import {Errors} from '../helpers/Errors.sol';
/**
* @title ReserveLogic library
@ -32,15 +33,12 @@ library ValidationLogic {
* @param reserve the reserve state on which the user is depositing
* @param amount the amount to be deposited
*/
function validateDeposit(ReserveLogic.ReserveData storage reserve, uint256 amount)
internal
view
{
function validateDeposit(ReserveLogic.ReserveData storage reserve, uint256 amount) internal view {
(bool isActive, bool isFreezed, , ) = reserve.configuration.getFlags();
require(amount > 0, 'Amount must be greater than 0');
require(isActive, 'Action requires an active reserve');
require(!isFreezed, 'Action requires an unfreezed reserve');
require(amount > 0, Errors.AMOUNT_NOT_GREATER_THAN_0);
require(isActive, Errors.NO_ACTIVE_RESERVE);
require(!isFreezed, Errors.NO_UNFREEZED_RESERVE);
}
/**
@ -60,13 +58,9 @@ library ValidationLogic {
address[] calldata reserves,
address oracle
) external view {
require(amount > 0, 'Amount must be greater than 0');
require(amount > 0, Errors.AMOUNT_NOT_GREATER_THAN_0);
uint256 currentAvailableLiquidity = IERC20(reserveAddress).balanceOf(address(aTokenAddress));
require(currentAvailableLiquidity >= amount, '4');
require(amount <= userBalance, 'User cannot withdraw more than the available balance');
require(amount <= userBalance, Errors.NOT_ENOUGH_AVAILABLE_USER_BALANCE);
require(
GenericLogic.balanceDecreaseAllowed(
@ -78,7 +72,7 @@ library ValidationLogic {
reserves,
oracle
),
'Transfer cannot be allowed.'
Errors.TRANSFER_NOT_ALLOWED
);
}
@ -138,23 +132,18 @@ library ValidationLogic {
vars.stableRateBorrowingEnabled
) = reserve.configuration.getFlags();
require(vars.isActive, 'Action requires an active reserve');
require(!vars.isFreezed, 'Action requires an unfreezed reserve');
require(vars.isActive, Errors.NO_ACTIVE_RESERVE);
require(!vars.isFreezed, Errors.NO_UNFREEZED_RESERVE);
require(vars.borrowingEnabled, '5');
require(vars.borrowingEnabled, Errors.BORROWING_NOT_ENABLED);
//validate interest rate mode
require(
uint256(ReserveLogic.InterestRateMode.VARIABLE) == interestRateMode ||
uint256(ReserveLogic.InterestRateMode.STABLE) == interestRateMode,
'Invalid interest rate mode selected'
Errors.INVALID_INTEREST_RATE_MODE_SELECTED
);
//check that the amount is available in the reserve
vars.availableLiquidity = IERC20(reserveAddress).balanceOf(address(reserve.aTokenAddress));
require(vars.availableLiquidity >= amount, '7');
(
vars.userCollateralBalanceETH,
vars.userBorrowBalanceETH,
@ -169,9 +158,12 @@ library ValidationLogic {
oracle
);
require(vars.userCollateralBalanceETH > 0, 'The collateral balance is 0');
require(vars.userCollateralBalanceETH > 0, Errors.COLLATERAL_BALANCE_IS_0);
require(vars.healthFactor > GenericLogic.HEALTH_FACTOR_LIQUIDATION_THRESHOLD, '8');
require(
vars.healthFactor > GenericLogic.HEALTH_FACTOR_LIQUIDATION_THRESHOLD,
Errors.HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD
);
//add the current already borrowed amount to the amount requested to calculate the total collateral needed.
vars.amountOfCollateralNeededETH = vars.userBorrowBalanceETH.add(amountInETH).percentDiv(
@ -180,7 +172,7 @@ library ValidationLogic {
require(
vars.amountOfCollateralNeededETH <= vars.userCollateralBalanceETH,
'There is not enough collateral to cover a new borrow'
Errors.COLLATERAL_CANNOT_COVER_NEW_BORROW
);
/**
@ -195,20 +187,20 @@ library ValidationLogic {
if (vars.rateMode == ReserveLogic.InterestRateMode.STABLE) {
//check if the borrow mode is stable and if stable rate borrowing is enabled on this reserve
require(vars.stableRateBorrowingEnabled, '11');
require(vars.stableRateBorrowingEnabled, Errors.STABLE_BORROWING_NOT_ENABLED);
require(
!userConfig.isUsingAsCollateral(reserve.index) ||
reserve.configuration.getLtv() == 0 ||
amount > IERC20(reserve.aTokenAddress).balanceOf(msg.sender),
'12'
Errors.CALLATERAL_SAME_AS_BORROWING_CURRENCY
);
//calculate the max available loan size in stable rate mode as a percentage of the
//available liquidity
uint256 maxLoanSizeStable = vars.availableLiquidity.percentMul(maxStableLoanPercent);
require(amount <= maxLoanSizeStable, '13');
require(amount <= maxLoanSizeStable, Errors.AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE);
}
}
@ -230,21 +222,21 @@ library ValidationLogic {
) external view {
bool isActive = reserve.configuration.getActive();
require(isActive, 'Action requires an active reserve');
require(isActive, Errors.NO_ACTIVE_RESERVE);
require(amountSent > 0, 'Amount must be greater than 0');
require(amountSent > 0, Errors.AMOUNT_NOT_GREATER_THAN_0);
require(
(stableDebt > 0 &&
ReserveLogic.InterestRateMode(rateMode) == ReserveLogic.InterestRateMode.STABLE) ||
(variableDebt > 0 &&
ReserveLogic.InterestRateMode(rateMode) == ReserveLogic.InterestRateMode.VARIABLE),
'16'
Errors.NO_DEBT_OF_SELECTED_TYPE
);
require(
amountSent != uint256(-1) || msg.sender == onBehalfOf,
'To repay on behalf of an user an explicit amount to repay is needed'
Errors.NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF
);
}
@ -265,19 +257,13 @@ library ValidationLogic {
) external view {
(bool isActive, bool isFreezed, , bool stableRateEnabled) = reserve.configuration.getFlags();
require(isActive, 'Action requires an active reserve');
require(!isFreezed, 'Action requires an unfreezed reserve');
require(isActive, Errors.NO_ACTIVE_RESERVE);
require(!isFreezed, Errors.NO_UNFREEZED_RESERVE);
if (currentRateMode == ReserveLogic.InterestRateMode.STABLE) {
require(
stableBorrowBalance > 0,
'User does not have a stable rate loan in progress on this reserve'
);
require(stableBorrowBalance > 0, Errors.NO_STABLE_RATE_LOAN_IN_RESERVE);
} else if (currentRateMode == ReserveLogic.InterestRateMode.VARIABLE) {
require(
variableBorrowBalance > 0,
'User does not have a variable rate loan in progress on this reserve'
);
require(variableBorrowBalance > 0, Errors.NO_VARIABLE_RATE_LOAN_IN_RESERVE);
/**
* user wants to swap to stable, before swapping we need to ensure that
* 1. stable borrow rate is enabled on the reserve
@ -285,17 +271,17 @@ library ValidationLogic {
* more collateral than he is borrowing, artificially lowering
* the interest rate, borrowing at variable, and switching to stable
**/
require(stableRateEnabled, '11');
require(stableRateEnabled, Errors.STABLE_BORROWING_NOT_ENABLED);
require(
!userConfig.isUsingAsCollateral(reserve.index) ||
reserve.configuration.getLtv() == 0 ||
stableBorrowBalance.add(variableBorrowBalance) >
IERC20(reserve.aTokenAddress).balanceOf(msg.sender),
'12'
Errors.CALLATERAL_SAME_AS_BORROWING_CURRENCY
);
} else {
revert('Invalid interest rate mode selected');
revert(Errors.INVALID_INTEREST_RATE_MODE_SELECTED);
}
}
@ -318,7 +304,7 @@ library ValidationLogic {
) external view {
uint256 underlyingBalance = IERC20(reserve.aTokenAddress).balanceOf(msg.sender);
require(underlyingBalance > 0, '22');
require(underlyingBalance > 0, Errors.UNDERLYING_BALANCE_NOT_GREATER_THAN_0);
require(
GenericLogic.balanceDecreaseAllowed(
@ -330,7 +316,17 @@ library ValidationLogic {
reserves,
oracle
),
'User deposit is already being used as collateral'
Errors.DEPOSIT_ALREADY_IN_USE
);
}
/**
* @dev validates a flashloan action
* @param mode the flashloan mode (0 = classic flashloan, 1 = open a stable rate loan, 2 = open a variable rate loan)
* @param premium the premium paid on the flashloan
**/
function validateFlashloan(uint256 mode, uint256 premium) internal pure {
require(premium > 0, Errors.REQUESTED_AMOUNT_TOO_SMALL);
require(mode <= uint256(ReserveLogic.InterestRateMode.VARIABLE), Errors.INVALID_FLASHLOAN_MODE);
}
}

10
contracts/libraries/math/MathUtils.sol
View File

@ -55,17 +55,17 @@ library MathUtils {
return WadRayMath.ray();
}
uint256 expMinusOne = exp.sub(1);
uint256 expMinusOne = exp - 1;
uint256 expMinusTwo = exp > 2 ? exp.sub(2) : 0;
uint256 expMinusTwo = exp > 2 ? exp - 2 : 0;
uint256 ratePerSecond = rate.div(31536000);
uint256 ratePerSecond = rate / SECONDS_PER_YEAR;
uint256 basePowerTwo = ratePerSecond.rayMul(ratePerSecond);
uint256 basePowerThree = basePowerTwo.rayMul(ratePerSecond);
uint256 secondTerm = exp.mul(expMinusOne).mul(basePowerTwo).div(2);
uint256 thirdTerm = exp.mul(expMinusOne).mul(expMinusTwo).mul(basePowerThree).div(6);
uint256 secondTerm = exp.mul(expMinusOne).mul(basePowerTwo) / 2;
uint256 thirdTerm = exp.mul(expMinusOne).mul(expMinusTwo).mul(basePowerThree) / 6;
return WadRayMath.ray().add(ratePerSecond.mul(exp)).add(secondTerm).add(thirdTerm);
}

29
contracts/libraries/math/PercentageMath.sol
View File

@ -1,7 +1,7 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.8;
import {SafeMath} from '@openzeppelin/contracts/math/SafeMath.sol';
import {Errors} from '../helpers/Errors.sol';
/**
* @title PercentageMath library
@ -12,8 +12,6 @@ import {SafeMath} from '@openzeppelin/contracts/math/SafeMath.sol';
**/
library PercentageMath {
using SafeMath for uint256;
uint256 constant PERCENTAGE_FACTOR = 1e4; //percentage plus two decimals
uint256 constant HALF_PERCENT = PERCENTAGE_FACTOR / 2;
@ -24,7 +22,19 @@ library PercentageMath {
* @return the percentage of value
**/
function percentMul(uint256 value, uint256 percentage) internal pure returns (uint256) {
return HALF_PERCENT.add(value.mul(percentage)).div(PERCENTAGE_FACTOR);
if (value == 0) {
return 0;
}
uint256 result = value * percentage;
require(result / value == percentage, Errors.MULTIPLICATION_OVERFLOW);
result += HALF_PERCENT;
require(result >= HALF_PERCENT, Errors.ADDITION_OVERFLOW);
return result / PERCENTAGE_FACTOR;
}
/**
@ -34,8 +44,17 @@ library PercentageMath {
* @return the value divided the percentage
**/
function percentDiv(uint256 value, uint256 percentage) internal pure returns (uint256) {
require(percentage != 0, Errors.DIVISION_BY_ZERO);
uint256 halfPercentage = percentage / 2;
return halfPercentage.add(value.mul(PERCENTAGE_FACTOR)).div(percentage);
uint256 result = value * PERCENTAGE_FACTOR;
require(result / PERCENTAGE_FACTOR == value, Errors.MULTIPLICATION_OVERFLOW);
result += halfPercentage;
require(result >= halfPercentage, Errors.ADDITION_OVERFLOW);
return result / percentage;
}
}

163
contracts/libraries/math/SafeMath.sol Normal file
View File

@ -0,0 +1,163 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.8;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}

64
contracts/libraries/math/WadRayMath.sol
View File

@ -1,7 +1,7 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.8;
import {SafeMath} from '@openzeppelin/contracts/math/SafeMath.sol';
import {Errors} from '../helpers/Errors.sol';
/**
* @title WadRayMath library
@ -10,8 +10,6 @@ import {SafeMath} from '@openzeppelin/contracts/math/SafeMath.sol';
**/
library WadRayMath {
using SafeMath for uint256;
uint256 internal constant WAD = 1e18;
uint256 internal constant halfWAD = WAD / 2;
@ -56,7 +54,19 @@ library WadRayMath {
* @return the result of a*b, in wad
**/
function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
return halfWAD.add(a.mul(b)).div(WAD);
if (a == 0) {
return 0;
}
uint256 result = a * b;
require(result / a == b, Errors.MULTIPLICATION_OVERFLOW);
result += halfWAD;
require(result >= halfWAD, Errors.ADDITION_OVERFLOW);
return result / WAD;
}
/**
@ -66,9 +76,19 @@ library WadRayMath {
* @return the result of a/b, in wad
**/
function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, Errors.DIVISION_BY_ZERO);
uint256 halfB = b / 2;
return halfB.add(a.mul(WAD)).div(b);
uint256 result = a * WAD;
require(result / WAD == a, Errors.MULTIPLICATION_OVERFLOW);
result += halfB;
require(result >= halfB, Errors.ADDITION_OVERFLOW);
return result / b;
}
/**
@ -78,7 +98,19 @@ library WadRayMath {
* @return the result of a*b, in ray
**/
function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
return halfRAY.add(a.mul(b)).div(RAY);
if (a == 0) {
return 0;
}
uint256 result = a * b;
require(result / a == b, Errors.MULTIPLICATION_OVERFLOW);
result += halfRAY;
require(result >= halfRAY, Errors.ADDITION_OVERFLOW);
return result / RAY;
}
/**
@ -88,9 +120,19 @@ library WadRayMath {
* @return the result of a/b, in ray
**/
function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, Errors.DIVISION_BY_ZERO);
uint256 halfB = b / 2;
return halfB.add(a.mul(RAY)).div(b);
uint256 result = a * RAY;
require(result / RAY == a, Errors.MULTIPLICATION_OVERFLOW);
result += halfB;
require(result >= halfB, Errors.ADDITION_OVERFLOW);
return result / b;
}
/**
@ -100,8 +142,10 @@ library WadRayMath {
**/
function rayToWad(uint256 a) internal pure returns (uint256) {
uint256 halfRatio = WAD_RAY_RATIO / 2;
uint256 result = halfRatio + a;
require(result >= halfRatio, Errors.ADDITION_OVERFLOW);
return halfRatio.add(a).div(WAD_RAY_RATIO);
return result / WAD_RAY_RATIO;
}
/**
@ -110,6 +154,8 @@ library WadRayMath {
* @return a converted in ray
**/
function wadToRay(uint256 a) internal pure returns (uint256) {
return a.mul(WAD_RAY_RATIO);
uint256 result = a * WAD_RAY_RATIO;
require(result / WAD_RAY_RATIO == a, Errors.MULTIPLICATION_OVERFLOW);
return result;
}
}

61
contracts/misc/Address.sol Normal file
View File

@ -0,0 +1,61 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.6.8;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*/
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
}

23
contracts/misc/Context.sol Normal file
View File

@ -0,0 +1,23 @@
// SPDX-License-Identifier: MIT
pragma solidity 0.6.8;
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal virtual view returns (address payable) {
return msg.sender;
}
function _msgData() internal virtual view returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}

64
contracts/misc/SafeERC20.sol Normal file
View File

@ -0,0 +1,64 @@
// SPDX-License-Identifier: MIT
pragma solidity 0.6.8;
import {IERC20} from '../interfaces/IERC20.sol';
import {SafeMath} from '../libraries/math/SafeMath.sol';
import {Address} from './Address.sol';
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
'SafeERC20: approve from non-zero to non-zero allowance'
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), 'SafeERC20: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, 'SafeERC20: low-level call failed');
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), 'SafeERC20: ERC20 operation did not succeed');
}
}
}

48
contracts/mocks/flashloan/MockFlashLoanReceiver.sol
View File

@ -13,46 +13,54 @@ contract MockFlashLoanReceiver is FlashLoanReceiverBase {
using SafeMath for uint256;
using SafeERC20 for IERC20;
ILendingPoolAddressesProvider internal _provider;
event ExecutedWithFail(address _reserve, uint256 _amount, uint256 _fee);
event ExecutedWithSuccess(address _reserve, uint256 _amount, uint256 _fee);
bool failExecution = false;
bool _failExecution;
uint256 _amountToApprove;
constructor(ILendingPoolAddressesProvider _provider) public FlashLoanReceiverBase(_provider) {}
constructor(ILendingPoolAddressesProvider provider) public FlashLoanReceiverBase(provider) {}
function setFailExecutionTransfer(bool _fail) public {
failExecution = _fail;
function setFailExecutionTransfer(bool fail) public {
_failExecution = fail;
}
function setAmountToApprove(uint256 amountToApprove) public {
_amountToApprove = amountToApprove;
}
function amountToApprove() public view returns (uint256) {
return _amountToApprove;
}
function executeOperation(
address _reserve,
address _destination,
uint256 _amount,
uint256 _fee,
bytes memory _params
address reserve,
uint256 amount,
uint256 fee,
bytes memory params
) public override {
//mint to this contract the specific amount
MintableERC20 token = MintableERC20(_reserve);
MintableERC20 token = MintableERC20(reserve);
//check the contract has the specified balance
require(
_amount <= IERC20(_reserve).balanceOf(address(this)),
'Invalid balance for the contract'
);
require(amount <= IERC20(reserve).balanceOf(address(this)), 'Invalid balance for the contract');
if (failExecution) {
emit ExecutedWithFail(_reserve, _amount, _fee);
uint256 amountToReturn = (_amountToApprove != 0) ? _amountToApprove : amount.add(fee);
if (_failExecution) {
emit ExecutedWithFail(reserve, amount, fee);
return;
}
//execution does not fail - mint tokens and return them to the _destination
//note: if the reserve is eth, the mock contract must receive at least _fee ETH before calling executeOperation
token.mint(_fee);
token.mint(fee);
//returning amount + fee to the destination
_transferFundsBack(_reserve, _destination, _amount.add(_fee));
IERC20(reserve).approve(_addressesProvider.getLendingPool(), amountToReturn);
emit ExecutedWithSuccess(_reserve, _amount, _fee);
emit ExecutedWithSuccess(reserve, amount, fee);
}
}

7
contracts/mocks/upgradeability/MockAToken.sol
View File

@ -3,7 +3,6 @@ pragma solidity ^0.6.8;
import {AToken} from '../../tokenization/AToken.sol';
import {LendingPool} from '../../lendingpool/LendingPool.sol';
import '@nomiclabs/buidler/console.sol';
contract MockAToken is AToken {
constructor(
@ -22,8 +21,8 @@ contract MockAToken is AToken {
string calldata _tokenName,
string calldata _tokenSymbol
) external virtual override initializer {
_name = _tokenName;
_symbol = _tokenSymbol;
_setupDecimals(_underlyingAssetDecimals);
_setName(_tokenName);
_setSymbol(_tokenSymbol);
_setDecimals(_underlyingAssetDecimals);
}
}

1
contracts/mocks/upgradeability/MockStableDebtToken.sol
View File

@ -3,7 +3,6 @@ pragma solidity ^0.6.8;
import {StableDebtToken} from '../../tokenization/StableDebtToken.sol';
import {LendingPool} from '../../lendingpool/LendingPool.sol';
import '@nomiclabs/buidler/console.sol';
contract MockStableDebtToken is StableDebtToken {
constructor(

1
contracts/mocks/upgradeability/MockVariableDebtToken.sol
View File

@ -3,7 +3,6 @@ pragma solidity ^0.6.8;
import {VariableDebtToken} from '../../tokenization/VariableDebtToken.sol';
import {LendingPool} from '../../lendingpool/LendingPool.sol';
import '@nomiclabs/buidler/console.sol';
contract MockVariableDebtToken is VariableDebtToken {
constructor(

37
contracts/tokenization/AToken.sol
View File

@ -4,11 +4,13 @@ pragma solidity ^0.6.8;
import {ERC20} from './ERC20.sol';
import {LendingPool} from '../lendingpool/LendingPool.sol';
import {WadRayMath} from '../libraries/math/WadRayMath.sol';
import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {
VersionedInitializable
} from '../libraries/openzeppelin-upgradeability/VersionedInitializable.sol';
import {IAToken, IERC20} from './interfaces/IAToken.sol';
import {IAToken} from './interfaces/IAToken.sol';
import {IERC20} from '../interfaces/IERC20.sol';
import {SafeERC20} from '../misc/SafeERC20.sol';
/**
* @title Aave ERC20 AToken
@ -34,12 +36,12 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
uint256 public constant ATOKEN_REVISION = 0x1;
modifier onlyLendingPool {
require(msg.sender == address(_pool), 'The caller of this function must be a lending pool');
require(msg.sender == address(_pool), Errors.CALLER_MUST_BE_LENDING_POOL);
_;
}
modifier whenTransferAllowed(address from, uint256 amount) {
require(isTransferAllowed(from, amount), 'Transfer cannot be allowed.');
require(isTransferAllowed(from, amount), Errors.TRANSFER_NOT_ALLOWED);
_;
}
@ -48,7 +50,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
address underlyingAssetAddress,
string memory tokenName,
string memory tokenSymbol
) public ERC20(tokenName, tokenSymbol) {
) public ERC20(tokenName, tokenSymbol, 18) {
_pool = pool;
UNDERLYING_ASSET_ADDRESS = underlyingAssetAddress;
}
@ -62,9 +64,9 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
string calldata tokenName,
string calldata tokenSymbol
) external virtual initializer {
_name = tokenName;
_symbol = tokenSymbol;
_setupDecimals(underlyingAssetDecimals);
_setName(tokenName);
_setSymbol(tokenSymbol);
_setDecimals(underlyingAssetDecimals);
}
/**
@ -100,7 +102,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
function redirectInterestStreamOf(address from, address to) external override {
require(
msg.sender == _interestRedirectionAllowances[from],
'Caller is not allowed to redirect the interest of the user'
Errors.INTEREST_REDIRECTION_NOT_ALLOWED
);
_redirectInterestStream(from, to);
}
@ -112,7 +114,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
* the allowance.
**/
function allowInterestRedirectionTo(address to) external override {
require(to != msg.sender, 'User cannot give allowance to himself');
require(to != msg.sender, Errors.CANNOT_GIVE_ALLOWANCE_TO_HIMSELF);
_interestRedirectionAllowances[msg.sender] = to;
emit InterestRedirectionAllowanceChanged(msg.sender, to);
}
@ -434,15 +436,12 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
address to,
uint256 value
) internal {
require(value > 0, 'Transferred amount needs to be greater than zero');
require(value > 0, Errors.TRANSFER_AMOUNT_NOT_GT_0);
//cumulate the balance of the sender
(
,
uint256 fromBalance,
uint256 fromBalanceIncrease,
uint256 fromIndex
) = _cumulateBalance(from);
(, uint256 fromBalance, uint256 fromBalanceIncrease, uint256 fromIndex) = _cumulateBalance(
from
);
//cumulate the balance of the receiver
(, , uint256 toBalanceIncrease, uint256 toIndex) = _cumulateBalance(to);
@ -486,7 +485,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
function _redirectInterestStream(address from, address to) internal {
address currentRedirectionAddress = _interestRedirectionAddresses[from];
require(to != currentRedirectionAddress, 'Interest is already redirected to the user');
require(to != currentRedirectionAddress, Errors.INTEREST_ALREADY_REDIRECTED);
//accumulates the accrued interest to the principal
(
@ -496,7 +495,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
uint256 fromIndex
) = _cumulateBalance(from);
require(fromBalance > 0, 'Interest stream can only be redirected if there is a valid balance');
require(fromBalance > 0, Errors.NO_VALID_BALANCE_FOR_REDIRECTION);
//if the user is already redirecting the interest to someone, before changing
//the redirection address we substract the redirected balance of the previous

259
contracts/tokenization/ERC20.sol
View File

@ -1,124 +1,88 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.8;
pragma solidity 0.6.8;
import {Context} from '@openzeppelin/contracts/GSN/Context.sol';
import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import {SafeMath} from '@openzeppelin/contracts/math/SafeMath.sol';
import {Context} from '../misc/Context.sol';
import {IERC20} from '../interfaces/IERC20.sol';
import {IERC20Detailed} from '../interfaces/IERC20Detailed.sol';
import {SafeMath} from '../libraries/math/SafeMath.sol';
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20MinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20 {
* @title ERC20
* @notice Basic ERC20 implementation
* @author Aave
**/
contract ERC20 is Context, IERC20, IERC20Detailed {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string internal _name;
string internal _symbol;
string private _name;
string private _symbol;
uint8 private _decimals;
/**
* @dev Sets the values for {name} and {symbol}, initializes {decimals} with
* a default value of 18.
*
* To select a different value for {decimals}, use {_setupDecimals}.
*
* All three of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name, string memory symbol) public {
constructor(
string memory name,
string memory symbol,
uint8 decimals
) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_decimals = decimals;
}
/**
* @dev Returns the name of the token.
*/
function name() public view returns (string memory) {
* @return the name of the token
**/
function name() public override view returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view returns (string memory) {
* @return the symbol of the token
**/
function symbol() public override view returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
* called.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view returns (uint8) {
* @return the decimals of the token
**/
function decimals() public override view returns (uint8) {
return _decimals;
}
/**
* @dev See {IERC20-totalSupply}.
*/
* @return the total supply of the token
**/
function totalSupply() public virtual override view returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
* @return the balance of the token
**/
function balanceOf(address account) public virtual override view returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
* @dev executes a transfer of tokens from msg.sender to recipient
* @param recipient the recipient of the tokens
* @param amount the amount of tokens being transferred
* @return true if the transfer succeeds, false otherwise
**/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
* @dev returns the allowance of spender on the tokens owned by owner
* @param owner the owner of the tokens
* @param spender the user allowed to spend the owner's tokens
* @return the amount of owner's tokens spender is allowed to spend
**/
function allowance(address owner, address spender)
public
virtual
@ -130,29 +94,22 @@ contract ERC20 is Context, IERC20 {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
* @dev allows spender to spend the tokens owned by msg.sender
* @param spender the user allowed to spend msg.sender tokens
* @return true
**/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
* @dev executes a transfer of token from sender to recipient, if msg.sender is allowed to do so
* @param sender the owner of the tokens
* @param recipient the recipient of the tokens
* @param amount the amount of tokens being transferred
* @return true if the transfer succeeds, false otherwise
**/
function transferFrom(
address sender,
address recipient,
@ -168,36 +125,22 @@ contract ERC20 is Context, IERC20 {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
* @dev increases the allowance of spender to spend msg.sender tokens
* @param spender the user allowed to spend on behalf of msg.sender
* @param addedValue the amount being added to the allowance
* @return true
**/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
* @dev decreases the allowance of spender to spend msg.sender tokens
* @param spender the user allowed to spend on behalf of msg.sender
* @param subtractedValue the amount being subtracted to the allowance
* @return true
**/
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
@ -214,20 +157,6 @@ contract ERC20 is Context, IERC20 {
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(
address sender,
address recipient,
@ -243,15 +172,6 @@ contract ERC20 is Context, IERC20 {
emit Transfer(sender, recipient, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), 'ERC20: mint to the zero address');
@ -262,17 +182,6 @@ contract ERC20 is Context, IERC20 {
emit Transfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), 'ERC20: burn from the zero address');
@ -283,19 +192,6 @@ contract ERC20 is Context, IERC20 {
emit Transfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
@ -308,31 +204,18 @@ contract ERC20 is Context, IERC20 {
emit Approval(owner, spender, amount);
}
/**
* @dev Sets {decimals} to a value other than the default one of 18.
*
* WARNING: This function should only be called from the constructor. Most
* applications that interact with token contracts will not expect
* {decimals} to ever change, and may work incorrectly if it does.
*/
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
function _setName(string memory newName) internal {
_name = newName;
}
function _setSymbol(string memory newSymbol) internal {
_symbol = newSymbol;
}
function _setDecimals(uint8 newDecimals) internal {
_decimals = newDecimals;
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,

57
contracts/tokenization/StableDebtToken.sol
View File

@ -11,27 +11,16 @@ import {IStableDebtToken} from './interfaces/IStableDebtToken.sol';
/**
* @title contract StableDebtToken
*
* @notice defines the interface for the stable debt token
*
* @dev it does not inherit from IERC20 to save in code size
*
* @notice Implements a stable debt token to track the user positions
* @author Aave
*
**/
contract StableDebtToken is IStableDebtToken, DebtTokenBase {
using SafeMath for uint256;
using WadRayMath for uint256;
uint256 public constant DEBT_TOKEN_REVISION = 0x1;
struct UserData {
uint256 currentRate;
uint40 lastUpdateTimestamp;
}
uint256 private avgStableRate;
mapping(address => UserData) private _usersData;
uint256 private _avgStableRate;
mapping(address => uint40) _timestamps;
constructor(
address pool,
@ -53,7 +42,7 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
* @return the average stable rate
**/
function getAverageStableRate() external virtual override view returns (uint256) {
return avgStableRate;
return _avgStableRate;
}
/**
@ -61,7 +50,7 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
* @return the last update timestamp
**/
function getUserLastUpdated(address user) external virtual override view returns (uint40) {
return _usersData[user].lastUpdateTimestamp;
return _timestamps[user];
}
/**
@ -70,7 +59,7 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
* @return the stable rate of user
**/
function getUserStableRate(address user) external virtual override view returns (uint256) {
return _usersData[user].currentRate;
return _usersData[user];
}
/**
@ -78,16 +67,14 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
* @return the accumulated debt of the user
**/
function balanceOf(address account) public virtual override view returns (uint256) {
uint256 accountBalance = _balances[account];
uint256 accountBalance = principalBalanceOf(account);
uint256 stableRate = _usersData[account];
if (accountBalance == 0) {
return 0;
}
UserData storage userData = _usersData[account];
uint256 cumulatedInterest = MathUtils.calculateCompoundedInterest(
userData.currentRate,
userData.lastUpdateTimestamp
stableRate,
_timestamps[account]
);
return accountBalance.wadToRay().rayMul(cumulatedInterest).rayToWad();
}
@ -120,25 +107,25 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
uint256 balanceIncrease
) = _calculateBalanceIncrease(user);
vars.supplyBeforeMint = _totalSupply.add(balanceIncrease);
vars.supplyBeforeMint = totalSupply().add(balanceIncrease);
vars.supplyAfterMint = vars.supplyBeforeMint.add(amount);
vars.amountInRay = amount.wadToRay();
//calculates the new stable rate for the user
vars.newStableRate = _usersData[user]
.currentRate
.rayMul(currentBalance.wadToRay())
.add(vars.amountInRay.rayMul(rate))
.rayDiv(currentBalance.add(amount).wadToRay());
_usersData[user].currentRate = vars.newStableRate;
require(vars.newStableRate < (1 << 128), 'Debt token: stable rate overflow');
_usersData[user] = vars.newStableRate;
//solium-disable-next-line
_usersData[user].lastUpdateTimestamp = uint40(block.timestamp);
_timestamps[user] = uint40(block.timestamp);
//calculates the updated average stable rate
avgStableRate = avgStableRate
_avgStableRate = _avgStableRate
.rayMul(vars.supplyBeforeMint.wadToRay())
.add(rate.rayMul(vars.amountInRay))
.rayDiv(vars.supplyAfterMint.wadToRay());
@ -167,24 +154,24 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
uint256 balanceIncrease
) = _calculateBalanceIncrease(user);
uint256 supplyBeforeBurn = _totalSupply.add(balanceIncrease);
uint256 supplyBeforeBurn = totalSupply().add(balanceIncrease);
uint256 supplyAfterBurn = supplyBeforeBurn.sub(amount);
if (supplyAfterBurn == 0) {
avgStableRate = 0;
_avgStableRate = 0;
} else {
avgStableRate = avgStableRate
_avgStableRate = _avgStableRate
.rayMul(supplyBeforeBurn.wadToRay())
.sub(_usersData[user].currentRate.rayMul(amount.wadToRay()))
.sub(_usersData[user].rayMul(amount.wadToRay()))
.rayDiv(supplyAfterBurn.wadToRay());
}
if (amount == currentBalance) {
_usersData[user].currentRate = 0;
_usersData[user].lastUpdateTimestamp = 0;
_usersData[user] = 0;
_timestamps[user] = 0;
} else {
//solium-disable-next-line
_usersData[user].lastUpdateTimestamp = uint40(block.timestamp);
_timestamps[user] = uint40(block.timestamp);
}
if (balanceIncrease > amount) {

27
contracts/tokenization/VariableDebtToken.sol
View File

@ -9,19 +9,15 @@ import {WadRayMath} from '../libraries/math/WadRayMath.sol';
import {IVariableDebtToken} from './interfaces/IVariableDebtToken.sol';
/**
* @title interface IVariableDebtToken
* @title contract VariableDebtToken
* @notice Implements a variable debt token to track the user positions
* @author Aave
* @notice defines the basic interface for a variable debt token.
* @dev does not inherit from IERC20 to save in contract size
**/
contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
using SafeMath for uint256;
using WadRayMath for uint256;
uint256 public constant DEBT_TOKEN_REVISION = 0x1;
mapping(address => uint256) private _userIndexes;
constructor(
address pool,
address underlyingAsset,
@ -42,7 +38,8 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
* @return the debt balance of the user
**/
function balanceOf(address user) public virtual override view returns (uint256) {
uint256 userBalance = _balances[user];
uint256 userBalance = principalBalanceOf(user);
uint256 index = _usersData[user];
if (userBalance == 0) {
return 0;
}
@ -50,8 +47,8 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
return
userBalance
.wadToRay()
.rayMul(_pool.getReserveNormalizedVariableDebt(_underlyingAssetAddress))
.rayDiv(_userIndexes[user])
.rayMul(POOL.getReserveNormalizedVariableDebt(UNDERLYING_ASSET))
.rayDiv(index)
.rayToWad();
}
@ -61,7 +58,7 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
**/
function getUserIndex(address user) external virtual override view returns (uint256) {
return _userIndexes[user];
return _usersData[user];
}
/**
@ -78,8 +75,9 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
_mint(user, amount.add(balanceIncrease));
uint256 newUserIndex = _pool.getReserveNormalizedVariableDebt(_underlyingAssetAddress);
_userIndexes[user] = newUserIndex;
uint256 newUserIndex = POOL.getReserveNormalizedVariableDebt(UNDERLYING_ASSET);
require(newUserIndex < (1 << 128), 'Debt token: Index overflow');
_usersData[user] = newUserIndex;
emit MintDebt(user, amount, previousBalance, currentBalance, balanceIncrease, newUserIndex);
}
@ -105,9 +103,10 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
uint256 newUserIndex = 0;
//if user not repaid everything
if (currentBalance != amount) {
newUserIndex = _pool.getReserveNormalizedVariableDebt(_underlyingAssetAddress);
newUserIndex = POOL.getReserveNormalizedVariableDebt(UNDERLYING_ASSET);
require(newUserIndex < (1 << 128), 'Debt token: Index overflow');
}
_userIndexes[user] = newUserIndex;
_usersData[user] = newUserIndex;
emit BurnDebt(user, amount, previousBalance, currentBalance, balanceIncrease, newUserIndex);
}

146
contracts/tokenization/base/DebtTokenBase.sol
View File

@ -8,136 +8,95 @@ import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {
VersionedInitializable
} from '../../libraries/openzeppelin-upgradeability/VersionedInitializable.sol';
import {IERC20Detailed} from '../../interfaces/IERC20Detailed.sol';
import {ERC20} from '../ERC20.sol';
import {Errors} from '../../libraries/helpers/Errors.sol';
/**
* @title contract DebtTokenBase
* @title DebtTokenBase
* @notice Base contract for different types of debt tokens, like StableDebtToken or VariableDebtToken
* @author Aave
* @notice base contract for StableDebtToken and VariableDebtToken
*/
abstract contract DebtTokenBase is IERC20Detailed, VersionedInitializable {
using SafeMath for uint256;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
address internal immutable _underlyingAssetAddress;
ILendingPool internal immutable _pool;
mapping(address => uint256) internal _balances;
abstract contract DebtTokenBase is ERC20, VersionedInitializable {
address internal immutable UNDERLYING_ASSET;
ILendingPool internal immutable POOL;
mapping(address => uint256) internal _usersData;
/**
* @dev only lending pool can call functions marked by this modifier
* @dev Only lending pool can call functions marked by this modifier
**/
modifier onlyLendingPool {
require(msg.sender == address(_pool), 'The caller of this function must be a lending pool');
require(msg.sender == address(POOL), Errors.CALLER_MUST_BE_LENDING_POOL);
_;
}
/**
* @dev The metadata of the token will be set on the proxy, that the reason of
* passing "NULL" and 0 as metadata
*/
constructor(
address pool,
address underlyingAssetAddress,
string memory name,
string memory symbol
) public {
_pool = ILendingPool(pool);
_underlyingAssetAddress = underlyingAssetAddress;
_name = name;
_symbol = symbol;
) public ERC20(name, symbol, 18) {
POOL = ILendingPool(pool);
UNDERLYING_ASSET = underlyingAssetAddress;
}
/**
* @dev initializes the debt token.
* @param name the name of the token
* @param symbol the symbol of the token
* @param decimals the decimals of the token
* @dev Initializes the debt token.
* @param name The name of the token
* @param symbol The symbol of the token
* @param decimals The decimals of the token
*/
function initialize(
uint8 decimals,
string memory name,
string memory symbol
) public initializer {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public override view returns (string memory) {
return _name;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
_setName(name);
_setSymbol(symbol);
_setDecimals(decimals);
}
function underlyingAssetAddress() public view returns (address) {
return _underlyingAssetAddress;
return UNDERLYING_ASSET;
}
/**
* @dev calculates the accumulated debt balance of the user
* @return the debt balance of the user
**/
function balanceOf(address user) public virtual override view returns (uint256);
/**
* @dev returns the principal debt balance of the user from
* @return the debt balance of the user since the last burn/mint action
* @dev Returns the principal debt balance of the user from
* @return The debt balance of the user since the last burn/mint action
**/
function principalBalanceOf(address user) public view returns (uint256) {
return _balances[user];
return super.balanceOf(user);
}
/**
* @dev basic accounting for the mint action
* @dev _user the target user of the minting action
* @dev _amount the amount to mint
**/
function _mint(address user, uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
_balances[user] = _balances[user].add(amount);
}
/**
* @dev basic accounting for the burn action
* @dev _user the target user of the burning action
* @dev _amount the amount to burn
**/
function _burn(address user, uint256 amount) internal {
_totalSupply = _totalSupply.sub(amount);
_balances[user] = _balances[user].sub(amount);
}
/**
* @dev being non transferrable, the debt token does not implement any of the
* @dev Being non transferrable, the debt token does not implement any of the
* standard ERC20 functions for transfer and allowance.
**/
function transfer(address recipient, uint256 amount) external virtual override returns (bool) {
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
recipient;
amount;
revert('TRANSFER_NOT_SUPPORTED');
}
function allowance(address owner, address spender)
external
public
virtual
override
view
returns (uint256)
{
owner;
spender;
revert('ALLOWANCE_NOT_SUPPORTED');
}
function approve(address spender, uint256 amount) external virtual override returns (bool) {
function approve(address spender, uint256 amount) public virtual override returns (bool) {
spender;
amount;
revert('APPROVAL_NOT_SUPPORTED');
}
@ -145,26 +104,39 @@ abstract contract DebtTokenBase is IERC20Detailed, VersionedInitializable {
address sender,
address recipient,
uint256 amount
) external virtual override returns (bool) {
) public virtual override returns (bool) {
sender;
recipient;
amount;
revert('TRANSFER_NOT_SUPPORTED');
}
function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) {
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
override
returns (bool)
{
spender;
addedValue;
revert('ALLOWANCE_NOT_SUPPORTED');
}
function decreaseAllowance(address spender, uint256 subtractedValue)
external
public
virtual
override
returns (bool)
{
spender;
subtractedValue;
revert('ALLOWANCE_NOT_SUPPORTED');
}
/**
* @dev calculates the increase in balance since the last user interaction
* @param user the address of the user for which the interest is being accumulated
* @return the previous principal balance, the new principal balance, the balance increase
* @dev Calculates the increase in balance since the last user interaction
* @param user The address of the user for which the interest is being accumulated
* @return The previous principal balance, the new principal balance, the balance increase
* and the new user index
**/
function _calculateBalanceIncrease(address user)
@ -176,13 +148,13 @@ abstract contract DebtTokenBase is IERC20Detailed, VersionedInitializable {
uint256
)
{
uint256 previousPrincipalBalance = _balances[user];
uint256 previousPrincipalBalance = principalBalanceOf(user);
if (previousPrincipalBalance == 0) {
return (0, 0, 0);
}
//calculate the accrued interest since the last accumulation
// Calculation of the accrued interest since the last accumulation
uint256 balanceIncrease = balanceOf(user).sub(previousPrincipalBalance);
return (

2
contracts/tokenization/interfaces/IAToken.sol
View File

@ -1,7 +1,7 @@
// SPDX-License-Identifier: agpl-3.0
pragma solidity ^0.6.8;
import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import {IERC20} from '../../interfaces/IERC20.sol';
interface IAToken is IERC20 {
/**

51
data.txt
View File

File diff suppressed because one or more lines are too long

86
deployed-contracts.json
View File

@ -5,7 +5,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x58F132FBB86E21545A4Bace3C19f1C05d86d7A22",
"address": "0xf8c6eB390cDc5C08717bC2268aa0c1169A9B5deE",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -15,7 +15,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0xa4bcDF64Cdd5451b6ac3743B414124A6299B65FF",
"address": "0x4a716924Dad0c0d0E558844F304548814e7089F1",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -25,7 +25,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x5A0773Ff307Bf7C71a832dBB5312237fD3437f9F",
"address": "0x798c5b4b62b1eA9D64955D6751B03075A003F123",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -53,7 +53,7 @@
"address": "0x6642B57e4265BAD868C17Fc1d1F4F88DBBA04Aa8"
},
"localhost": {
"address": "0x9EC0480CF106d6dc1c7849BA141a56F874170F97"
"address": "0x6642B57e4265BAD868C17Fc1d1F4F88DBBA04Aa8"
}
},
"LendingPoolDataProvider": {
@ -66,7 +66,7 @@
"address": "0xD9273d497eDBC967F39d419461CfcF382a0A822e"
},
"localhost": {
"address": "0x6642B57e4265BAD868C17Fc1d1F4F88DBBA04Aa8"
"address": "0xD9273d497eDBC967F39d419461CfcF382a0A822e"
}
},
"PriceOracle": {
@ -75,7 +75,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x099d9fF8F818290C8b5B7Db5bFca84CEebd2714c",
"address": "0x1750499D05Ed1674d822430FB960d5F6731fDf64",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -85,7 +85,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0xAF6BA11790D1942625C0c2dA07da19AB63845cfF",
"address": "0xEC1C93A9f6a9e18E97784c76aC52053587FcDB89",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -95,7 +95,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0xD83D2773a7873ae2b5f8Fb92097e20a8C64F691E",
"address": "0x7B6C3e5486D9e6959441ab554A889099eed76290",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -105,7 +105,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0xf91aC1098F3b154671Ce83290114aaE45ac0225f",
"address": "0xD83D2773a7873ae2b5f8Fb92097e20a8C64F691E",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -115,7 +115,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x830bceA96E56DBC1F8578f75fBaC0AF16B32A07d",
"address": "0x626FdE749F9d499d3777320CAf29484B624ab84a",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -169,7 +169,7 @@
"address": "0x2B681757d757fbB80cc51c6094cEF5eE75bF55aA"
},
"localhost": {
"address": "0x3bDA11B584dDff7F66E0cFe1da1562c92B45db60"
"address": "0x2B681757d757fbB80cc51c6094cEF5eE75bF55aA"
}
},
"WalletBalanceProvider": {
@ -178,7 +178,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x392E5355a0e88Bd394F717227c752670fb3a8020",
"address": "0xBEF0d4b9c089a5883741fC14cbA352055f35DDA2",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -188,7 +188,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x7c2C195CD6D34B8F845992d380aADB2730bB9C6F",
"address": "0x11df1AF606b85226Ab9a8B1FDa90395298e7494F",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -198,7 +198,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x8858eeB3DfffA017D4BCE9801D340D36Cf895CCf",
"address": "0x8f9A92c125FFEb83d8eC808Cd9f8cb80084c1E37",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -208,7 +208,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x0078371BDeDE8aAc7DeBfFf451B74c5EDB385Af7",
"address": "0xc4007844AE6bBe168cE8D692C86a7A4414FBcD26",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -218,7 +218,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0xf4e77E5Da47AC3125140c470c71cBca77B5c638c",
"address": "0xAb768C858C33DfcB6651d1174AFb750433a87Be0",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -228,7 +228,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x3619DbE27d7c1e7E91aA738697Ae7Bc5FC3eACA5",
"address": "0xA089557D64DAE4b4FcB65aB7C8A520AABb213e37",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -238,7 +238,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x038B86d9d8FAFdd0a02ebd1A476432877b0107C8",
"address": "0x20FAE2042b362E3FaB2806820b9A43CC116e2846",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -248,7 +248,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x1A1FEe7EeD918BD762173e4dc5EfDB8a78C924A8",
"address": "0x8880F314112f15C2AfF674c3B27f9a44Ca86e4d0",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -258,7 +258,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x500D1d6A4c7D8Ae28240b47c8FCde034D827fD5e",
"address": "0xDcb10C2e15110Db4B02C0a1df459768E680ce245",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -268,7 +268,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0xc4905364b78a742ccce7B890A89514061E47068D",
"address": "0xfD408ec64Da574b1859814F810564f73ea2Ff003",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -278,7 +278,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0xD6C850aeBFDC46D7F4c207e445cC0d6B0919BDBe",
"address": "0x0006F7c3542BEE76Dd887f54eD22405Ac4ae905a",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -288,7 +288,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x8B5B7a6055E54a36fF574bbE40cf2eA68d5554b3",
"address": "0x6ca94a51c644eca3F9CA315bcC41CbA6940A66Eb",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -298,7 +298,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0xEcc0a6dbC0bb4D51E4F84A315a9e5B0438cAD4f0",
"address": "0x6765291Cab755B980F377445eFd0F9F945CDA6C4",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -308,7 +308,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x20Ce94F404343aD2752A2D01b43fa407db9E0D00",
"address": "0xa7dB4d25Fc525d19Fbda4E74AAF447B88420FbcB",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -318,7 +318,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x1d80315fac6aBd3EfeEbE97dEc44461ba7556160",
"address": "0x273D60904A8DBa3Ae6B20505c59902644124fF0E",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -328,7 +328,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x2D8553F9ddA85A9B3259F6Bf26911364B85556F5",
"address": "0xfc37dE87C1Ee39cc856782BF96fEdcB6FA5c5A7f",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -338,7 +338,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x52d3b94181f8654db2530b0fEe1B19173f519C52",
"address": "0x049228dFFEdf91ff224e9F96247aEBA700e3590c",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -348,7 +348,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0xd15468525c35BDBC1eD8F2e09A00F8a173437f2f",
"address": "0xA410D1f3fEAF300842142Cd7AA1709D84944DCb7",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -358,7 +358,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x7e35Eaf7e8FBd7887ad538D4A38Df5BbD073814a",
"address": "0x835973768750b3ED2D5c3EF5AdcD5eDb44d12aD4",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -368,7 +368,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x5bcb88A0d20426e451332eE6C4324b0e663c50E0",
"address": "0x1181FC27dbF04B5105243E60BB1936c002e9d5C8",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -378,7 +378,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x3521eF8AaB0323004A6dD8b03CE890F4Ea3A13f5",
"address": "0x6F96975e2a0e1380b6e2e406BB33Ae96e4b6DB65",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -388,7 +388,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x53369fd4680FfE3DfF39Fc6DDa9CfbfD43daeA2E",
"address": "0xc032930653da193EDE295B4DcE3DD093a695c3b3",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -398,7 +398,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0xB00cC45B4a7d3e1FEE684cFc4417998A1c183e6d",
"address": "0xb3363f4349b1160DbA55ec4D82fDe874A4123A2a",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -408,7 +408,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x58F132FBB86E21545A4Bace3C19f1C05d86d7A22",
"address": "0xf8c6eB390cDc5C08717bC2268aa0c1169A9B5deE",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -417,7 +417,7 @@
"address": "0x2cfcA5785261fbC88EFFDd46fCFc04c22525F9e4"
},
"localhost": {
"address": "0x3b050AFb4ac4ACE646b31fF3639C1CD43aC31460"
"address": "0xDf73fC454FA018051D4a1509e63D11530A59DE10"
}
},
"StableDebtToken": {
@ -426,7 +426,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0xA0AB1cB92A4AF81f84dCd258155B5c25D247b54E",
"address": "0xB660Fdd109a95718cB9d20E3A89EE6cE342aDcB6",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -436,13 +436,13 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x5f7134cd38C826a7649f9Cc47dda24d834DD2967",
"address": "0x830bceA96E56DBC1F8578f75fBaC0AF16B32A07d",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
"AToken": {
"localhost": {
"address": "0xE91bBe8ee03560E3dda2786f95335F5399813Ca0",
"address": "0xA0AB1cB92A4AF81f84dCd258155B5c25D247b54E",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"buidlerevm": {
@ -456,7 +456,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x7f23223A2FAf869962B38f5eC4aAB7f37454A45e",
"address": "0x1203D1b97BF6E546c00C45Cda035D3010ACe1180",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -466,7 +466,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0xf784709d2317D872237C4bC22f867d1BAe2913AB",
"address": "0x2cc20bE530F92865c2ed8CeD0b020a11bFe62Fe7",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -476,7 +476,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x1203D1b97BF6E546c00C45Cda035D3010ACe1180",
"address": "0x8733AfE8174BA7c04c6CD694bD673294079b7E10",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},
@ -486,7 +486,7 @@
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
},
"localhost": {
"address": "0x8733AfE8174BA7c04c6CD694bD673294079b7E10",
"address": "0xA8083d78B6ABC328b4d3B714F76F384eCC7147e1",
"deployer": "0xc783df8a850f42e7F7e57013759C285caa701eB6"
}
},

73
helpers/types.ts
View File

@ -45,25 +45,74 @@ export enum eContractid {
}
export enum ProtocolErrors {
INVALID_CONFIGURATOR_CALLER_MSG = 'The caller must be a lending pool configurator contract',
INVALID_POOL_CALLER_MSG = 'The caller must be a lending pool contract',
INVALID_POOL_CALLER_MSG_1 = 'The caller of this function must be a lending pool',
INVALID_POOL_MANAGER_CALLER_MSG = 'The caller must be a lending pool manager',
// require error messages - ValidationLogic
AMOUNT_NOT_GREATER_THAN_0 = '1', // 'Amount must be greater than 0'
NO_ACTIVE_RESERVE = '2', // 'Action requires an active reserve'
NO_UNFREEZED_RESERVE = '3', // 'Action requires an unfreezed reserve'
CURRENT_AVAILABLE_LIQUIDITY_NOT_ENOUGH = '4', // 'The current liquidity is not enough'
NOT_ENOUGH_AVAILABLE_USER_BALANCE = '5', // 'User cannot withdraw more than the available balance'
TRANSFER_NOT_ALLOWED = '6', // 'Transfer cannot be allowed.'
BORROWING_NOT_ENABLED = '7', // 'Borrowing is not enabled'
INVALID_INTEREST_RATE_MODE_SELECTED = '8', // 'Invalid interest rate mode selected'
COLLATERAL_BALANCE_IS_0 = '9', // 'The collateral balance is 0'
HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD = '10', // 'Health factor is lesser than the liquidation threshold'
COLLATERAL_CANNOT_COVER_NEW_BORROW = '11', // 'There is not enough collateral to cover a new borrow'
STABLE_BORROWING_NOT_ENABLED = '12', // stable borrowing not enabled
CALLATERAL_SAME_AS_BORROWING_CURRENCY = '13', // collateral is (mostly) the same currency that is being borrowed
AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE = '14', // 'The requested amount is greater than the max loan size in stable rate mode
NO_DEBT_OF_SELECTED_TYPE = '15', // 'for repayment of stable debt, the user needs to have stable debt, otherwise, he needs to have variable debt'
NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF = '16', // 'To repay on behalf of an user an explicit amount to repay is needed'
NO_STABLE_RATE_LOAN_IN_RESERVE = '17', // 'User does not have a stable rate loan in progress on this reserve'
NO_VARIABLE_RATE_LOAN_IN_RESERVE = '18', // 'User does not have a variable rate loan in progress on this reserve'
UNDERLYING_BALANCE_NOT_GREATER_THAN_0 = '19', // 'The underlying balance needs to be greater than 0'
DEPOSIT_ALREADY_IN_USE = '20', // 'User deposit is already being used as collateral'
// require error messages - LendingPool
NOT_ENOUGH_STABLE_BORROW_BALANCE = '21', // 'User does not have any stable rate loan for this reserve'
INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET = '22', // 'Interest rate rebalance conditions were not met'
LIQUIDATION_CALL_FAILED = '23', // 'Liquidation call failed'
NOT_ENOUGH_LIQUIDITY_TO_BORROW = '24', // 'There is not enough liquidity available to borrow'
REQUESTED_AMOUNT_TOO_SMALL = '25', // 'The requested amount is too small for a FlashLoan.'
INCONSISTENT_PROTOCOL_ACTUAL_BALANCE = '26', // 'The actual balance of the protocol is inconsistent'
CALLER_NOT_LENDING_POOL_CONFIGURATOR = '27', // 'The actual balance of the protocol is inconsistent'
// require error messages - aToken
CALLER_MUST_BE_LENDING_POOL = '28', // 'The caller of this function must be a lending pool'
INTEREST_REDIRECTION_NOT_ALLOWED = '29', // 'Caller is not allowed to redirect the interest of the user'
CANNOT_GIVE_ALLOWANCE_TO_HIMSELF = '30', // 'User cannot give allowance to himself'
TRANSFER_AMOUNT_NOT_GT_0 = '31', // 'Transferred amount needs to be greater than zero'
INTEREST_ALREADY_REDIRECTED = '32', // 'Interest is already redirected to the user'
NO_VALID_BALANCE_FOR_REDIRECTION = '33', // 'Interest stream can only be redirected if there is a valid balance'
// require error messages - ReserveLogic
RESERVE_ALREADY_INITIALIZED = '34', // 'Reserve has already been initialized'
//require error messages - LendingPoolConfiguration
CALLER_NOT_LENDING_POOL_MANAGER = '35', // 'The caller must be a lending pool manager'
RESERVE_LIQUIDITY_NOT_0 = '36', // 'The liquidity of the reserve needs to be 0'
//require error messages - LendingPoolAddressesProviderRegistry
PROVIDER_NOT_REGISTERED = '37', // 'Provider is not registered'
//return error messages - LendingPoolLiquidationManager
HEALTH_FACTOR_NOT_BELOW_THRESHOLD = '38', // 'Health factor is not below the threshold'
COLLATERAL_CANNOT_BE_LIQUIDATED = '39', // 'The collateral chosen cannot be liquidated'
SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER = '40', // 'User did not borrow the specified currency'
NOT_ENOUGH_LIQUIDITY_TO_LIQUIDATE = '41', // "There isn't enough liquidity available to liquidate"
NO_ERRORS = '42', // 'No errors'
INVALID_FLASHLOAN_MODE = '43', //Invalid flashloan mode
// old
INVALID_FROM_BALANCE_AFTER_TRANSFER = 'Invalid from balance after transfer',
INVALID_TO_BALANCE_AFTER_TRANSFER = 'Invalid from balance after transfer',
INVALID_OWNER_REVERT_MSG = 'Ownable: caller is not the owner',
INVALID_REDIRECTED_BALANCE_BEFORE_TRANSFER = 'Invalid redirected balance before transfer',
INVALID_REDIRECTED_BALANCE_AFTER_TRANSFER = 'Invalid redirected balance after transfer',
INVALID_REDIRECTION_ADDRESS = 'Invalid redirection address',
TRANSFERRED_AMOUNT_GT_ZERO = 'Transferred amount needs to be greater than zero',
ZERO_COLLATERAL = 'The collateral balance is 0',
INCONSISTENT_PROTOCOL_BALANCE = 'The actual balance of the protocol is inconsistent',
TOO_SMALL_FLASH_LOAN = 'The requested amount is too small for a FlashLoan.',
NOT_ENOUGH_LIQUIDITY_TO_BORROW = 'There is not enough liquidity available to borrow',
HF_IS_NOT_BELLOW_THRESHOLD = 'Health factor is not below the threshold',
INVALID_HF = 'Invalid health factor',
USER_DID_NOT_BORROW_SPECIFIED = 'User did not borrow the specified currency',
THE_COLLATERAL_CHOSEN_CANNOT_BE_LIQUIDATED = 'The collateral chosen cannot be liquidated',
TRANSFER_AMOUNT_EXCEEDS_BALANCE = 'ERC20: transfer amount exceeds balance',
SAFEERC20_LOWLEVEL_CALL = 'SafeERC20: low-level call failed',
}
export type tEthereumAddress = string;

1
package.json
View File

@ -15,6 +15,7 @@
"test-scenarios": "buidler test test/__setup.spec.ts test/scenario.spec.ts",
"test-repay-with-collateral": "buidler test test/__setup.spec.ts test/repay-with-collateral.spec.ts",
"test-liquidate-with-collateral": "buidler test test/__setup.spec.ts test/flash-liquidation-with-collateral.spec.ts",
"test-flash": "buidler test test/__setup.spec.ts test/flashloan.spec.ts",
"dev:coverage": "buidler coverage --network coverage",
"dev:deployment": "buidler dev-deployment",
"dev:deployExample": "buidler deploy-Example",

2756
test.log Normal file
View File

File diff suppressed because it is too large Load Diff

10
test/atoken-modifiers.spec.ts
View File

@ -3,17 +3,17 @@ import {makeSuite, TestEnv} from './helpers/make-suite';
import {ProtocolErrors} from '../helpers/types';
makeSuite('AToken: Modifiers', (testEnv: TestEnv) => {
const {INVALID_POOL_CALLER_MSG_1} = ProtocolErrors;
const {CALLER_MUST_BE_LENDING_POOL} = ProtocolErrors;
it('Tries to invoke mint not being the LendingPool', async () => {
const {deployer, aDai} = testEnv;
await expect(aDai.mint(deployer.address, '1')).to.be.revertedWith(INVALID_POOL_CALLER_MSG_1);
await expect(aDai.mint(deployer.address, '1')).to.be.revertedWith(CALLER_MUST_BE_LENDING_POOL);
});
it('Tries to invoke burn not being the LendingPool', async () => {
const {deployer, aDai} = testEnv;
await expect(aDai.burn(deployer.address, deployer.address, '1')).to.be.revertedWith(
INVALID_POOL_CALLER_MSG_1
CALLER_MUST_BE_LENDING_POOL
);
});
@ -21,13 +21,13 @@ makeSuite('AToken: Modifiers', (testEnv: TestEnv) => {
const {deployer, users, aDai} = testEnv;
await expect(
aDai.transferOnLiquidation(deployer.address, users[0].address, '1')
).to.be.revertedWith(INVALID_POOL_CALLER_MSG_1);
).to.be.revertedWith(CALLER_MUST_BE_LENDING_POOL);
});
it('Tries to invoke transferUnderlyingTo not being the LendingPool', async () => {
const {deployer, users, aDai} = testEnv;
await expect(aDai.transferUnderlyingTo(deployer.address, '1')).to.be.revertedWith(
INVALID_POOL_CALLER_MSG_1
CALLER_MUST_BE_LENDING_POOL
);
});
});

28
test/atoken-transfer.spec.ts
View File

@ -17,8 +17,10 @@ makeSuite('AToken: Transfer', (testEnv: TestEnv) => {
INVALID_REDIRECTED_BALANCE_BEFORE_TRANSFER,
INVALID_REDIRECTED_BALANCE_AFTER_TRANSFER,
INVALID_REDIRECTION_ADDRESS,
ZERO_COLLATERAL,
TRANSFERRED_AMOUNT_GT_ZERO,
// ZERO_COLLATERAL,
TRANSFER_AMOUNT_NOT_GT_0,
COLLATERAL_BALANCE_IS_0,
TRANSFER_NOT_ALLOWED,
} = ProtocolErrors;
it('User 0 deposits 1000 DAI, transfers to user 1', async () => {
@ -96,16 +98,14 @@ makeSuite('AToken: Transfer', (testEnv: TestEnv) => {
await weth.connect(users[0].signer).mint(await convertToCurrencyDecimals(weth.address, '1'));
await weth.connect(users[0].signer).approve(pool.address, APPROVAL_AMOUNT_LENDING_POOL);
await pool
.connect(users[0].signer)
.deposit(weth.address, ethers.utils.parseEther('1.0'), '0');
await pool.connect(users[0].signer).deposit(weth.address, ethers.utils.parseEther('1.0'), '0');
await expect(
pool
.connect(users[1].signer)
.borrow(weth.address, ethers.utils.parseEther('0.1'), RateMode.Stable, AAVE_REFERRAL),
ZERO_COLLATERAL
).to.be.revertedWith(ZERO_COLLATERAL);
COLLATERAL_BALANCE_IS_0
).to.be.revertedWith(COLLATERAL_BALANCE_IS_0);
});
it('User 1 sets the DAI as collateral and borrows, tries to transfer everything back to user 0 (revert expected)', async () => {
@ -120,25 +120,25 @@ makeSuite('AToken: Transfer', (testEnv: TestEnv) => {
await expect(
aDai.connect(users[1].signer).transfer(users[0].address, aDAItoTransfer),
'Transfer cannot be allowed.'
).to.be.revertedWith('Transfer cannot be allowed.');
TRANSFER_NOT_ALLOWED
).to.be.revertedWith(TRANSFER_NOT_ALLOWED);
});
it('User 0 tries to transfer 0 balance (revert expected)', async () => {
const {users, pool, aDai, dai, weth} = testEnv;
await expect(
aDai.connect(users[0].signer).transfer(users[1].address, '0'),
TRANSFERRED_AMOUNT_GT_ZERO
).to.be.revertedWith(TRANSFERRED_AMOUNT_GT_ZERO);
TRANSFER_AMOUNT_NOT_GT_0
).to.be.revertedWith(TRANSFER_AMOUNT_NOT_GT_0);
});
it('User 1 repays the borrow, transfers aDAI back to user 0', async () => {
const {users, pool, aDai, dai, weth} = testEnv;
await weth.connect(users[1].signer).mint(await convertToCurrencyDecimals(weth.address, '2'));
await weth.connect(users[1].signer).approve(pool.address, APPROVAL_AMOUNT_LENDING_POOL);
await pool
.connect(users[1].signer)
.repay(weth.address, MAX_UINT_AMOUNT, RateMode.Stable, users[1].address);

66
test/configurator.spec.ts
View File

@ -6,7 +6,7 @@ import {ProtocolErrors} from '../helpers/types';
const {expect} = require('chai');
makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
const {INVALID_POOL_MANAGER_CALLER_MSG} = ProtocolErrors;
const {CALLER_NOT_LENDING_POOL_MANAGER, RESERVE_LIQUIDITY_NOT_0} = ProtocolErrors;
it('Deactivates the ETH reserve', async () => {
const {configurator, pool, weth} = testEnv;
@ -27,16 +27,16 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).deactivateReserve(weth.address),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Check the onlyLendingPoolManager on activateReserve ', async () => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).activateReserve(weth.address),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Freezes the ETH reserve', async () => {
@ -58,16 +58,16 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).freezeReserve(weth.address),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Check the onlyLendingPoolManager on unfreezeReserve ', async () => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).unfreezeReserve(weth.address),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Deactivates the ETH reserve for borrowing', async () => {
@ -90,16 +90,16 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).disableBorrowingOnReserve(weth.address),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Check the onlyLendingPoolManager on enableBorrowingOnReserve ', async () => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).enableBorrowingOnReserve(weth.address, true),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Deactivates the ETH reserve as collateral', async () => {
@ -121,8 +121,8 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).disableReserveAsCollateral(weth.address),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Check the onlyLendingPoolManager on enableReserveAsCollateral ', async () => {
@ -131,8 +131,8 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
configurator
.connect(users[2].signer)
.enableReserveAsCollateral(weth.address, '75', '80', '105'),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Disable stable borrow rate on the ETH reserve', async () => {
@ -153,16 +153,16 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).disableReserveStableRate(weth.address),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Check the onlyLendingPoolManager on enableReserveStableRate', async () => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).enableReserveStableRate(weth.address),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Changes LTV of the reserve', async () => {
@ -176,8 +176,8 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).setLtv(weth.address, '75'),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Changes liquidation threshold of the reserve', async () => {
@ -194,8 +194,8 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).setLiquidationThreshold(weth.address, '80'),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Changes liquidation bonus of the reserve', async () => {
@ -212,24 +212,24 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).setLiquidationBonus(weth.address, '80'),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Check the onlyLendingPoolManager on setReserveDecimals', async () => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).setReserveDecimals(weth.address, '80'),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Check the onlyLendingPoolManager on setLiquidationBonus', async () => {
const {configurator, users, weth} = testEnv;
await expect(
configurator.connect(users[2].signer).setLiquidationBonus(weth.address, '80'),
INVALID_POOL_MANAGER_CALLER_MSG
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
CALLER_NOT_LENDING_POOL_MANAGER
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Reverts when trying to disable the DAI reserve with liquidity on it', async () => {
@ -246,7 +246,7 @@ makeSuite('LendingPoolConfigurator', (testEnv: TestEnv) => {
await expect(
configurator.deactivateReserve(dai.address),
'The liquidity of the reserve needs to be 0'
).to.be.revertedWith('The liquidity of the reserve needs to be 0');
RESERVE_LIQUIDITY_NOT_0
).to.be.revertedWith(RESERVE_LIQUIDITY_NOT_0);
});
});

34
test/flash-liquidation-with-collateral.spec.ts
View File

@ -9,37 +9,13 @@ import {
import {getContractsData} from './helpers/actions';
import {waitForTx} from './__setup.spec';
import {timeLatest, BRE, increaseTime} from '../helpers/misc-utils';
import {tEthereumAddress, ProtocolErrors} from '../helpers/types';
import {ProtocolErrors} from '../helpers/types';
import {convertToCurrencyDecimals} from '../helpers/contracts-helpers';
import {formatUnits, formatEther} from 'ethers/lib/utils';
import {buidlerArguments} from '@nomiclabs/buidler';
import {expectRepayWithCollateralEvent} from './repay-with-collateral.spec';
const {expect} = require('chai');
const {parseUnits, parseEther} = ethers.utils;
const expectRepayWithCollateralEvent = (
events: ethers.Event[],
pool: tEthereumAddress,
collateral: tEthereumAddress,
borrowing: tEthereumAddress,
user: tEthereumAddress
) => {
if (!events || events.length < 14) {
expect(false, 'INVALID_EVENTS_LENGTH_ON_REPAY_COLLATERAL');
}
const repayWithCollateralEvent = events[13];
expect(repayWithCollateralEvent.address).to.be.equal(pool);
expect(`0x${repayWithCollateralEvent.topics[1].slice(26)}`.toLowerCase()).to.be.equal(
collateral.toLowerCase()
);
expect(`0x${repayWithCollateralEvent.topics[2].slice(26)}`).to.be.equal(borrowing.toLowerCase());
expect(`0x${repayWithCollateralEvent.topics[3].slice(26)}`.toLowerCase()).to.be.equal(
user.toLowerCase()
);
};
makeSuite('LendingPool. repayWithCollateral() with liquidator', (testEnv: TestEnv) => {
const {INVALID_HF} = ProtocolErrors;
@ -360,7 +336,7 @@ makeSuite('LendingPool. repayWithCollateral() with liquidator', (testEnv: TestEn
mockSwapAdapter.address,
'0x'
)
).to.be.revertedWith('revert CURRRENCY_NOT_BORROWED');
).to.be.revertedWith('40');
await oracle.setAssetPrice(usdc.address, usdcPrice);
});
@ -526,7 +502,7 @@ makeSuite('LendingPool. repayWithCollateral() with liquidator', (testEnv: TestEn
mockSwapAdapter.address,
'0x'
)
).to.be.revertedWith('FAILED_REPAY_WITH_COLLATERAL');
).to.be.revertedWith('53');
// Resets DAI Price
await oracle.setAssetPrice(dai.address, daiPrice);
@ -560,7 +536,7 @@ makeSuite('LendingPool. repayWithCollateral() with liquidator', (testEnv: TestEn
mockSwapAdapter.address,
'0x'
)
).to.be.revertedWith('HEALTH_FACTOR_ABOVE_THRESHOLD');
).to.be.revertedWith('38');
});
it('User 5 liquidates User 2 DAI Variable loan using his WETH collateral, half the amount', async () => {
const {pool, weth, dai, users, mockSwapAdapter, oracle} = testEnv;

261
test/flashloan.spec.ts
View File

@ -1,19 +1,27 @@
import {TestEnv, makeSuite} from './helpers/make-suite';
import {APPROVAL_AMOUNT_LENDING_POOL, oneRay} from '../helpers/constants';
import {convertToCurrencyDecimals, getMockFlashLoanReceiver} from '../helpers/contracts-helpers';
import {
convertToCurrencyDecimals,
getMockFlashLoanReceiver,
getContract,
} from '../helpers/contracts-helpers';
import {ethers} from 'ethers';
import {MockFlashLoanReceiver} from '../types/MockFlashLoanReceiver';
import {ProtocolErrors} from '../helpers/types';
import {ProtocolErrors, eContractid} from '../helpers/types';
import BigNumber from 'bignumber.js';
import {VariableDebtToken} from '../types/VariableDebtToken';
import {StableDebtToken} from '../types/StableDebtToken';
const {expect} = require('chai');
makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
let _mockFlashLoanReceiver = {} as MockFlashLoanReceiver;
const {
INCONSISTENT_PROTOCOL_BALANCE,
TOO_SMALL_FLASH_LOAN,
NOT_ENOUGH_LIQUIDITY_TO_BORROW,
COLLATERAL_BALANCE_IS_0,
REQUESTED_AMOUNT_TOO_SMALL,
TRANSFER_AMOUNT_EXCEEDS_BALANCE,
INVALID_FLASHLOAN_MODE,
SAFEERC20_LOWLEVEL_CALL,
} = ProtocolErrors;
before(async () => {
@ -31,14 +39,16 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
await pool.deposit(weth.address, amountToDeposit, '0');
});
it('Takes ETH flashloan, returns the funds correctly', async () => {
it('Takes WETH flashloan with mode = 0, returns the funds correctly', async () => {
const {pool, deployer, weth} = testEnv;
await pool.flashLoan(
_mockFlashLoanReceiver.address,
weth.address,
ethers.utils.parseEther('0.8'),
'0x10'
0,
'0x10',
'0'
);
ethers.utils.parseUnits('10000');
@ -57,18 +67,17 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
expect(currentLiquidityIndex.toString()).to.be.equal('1000720000000000000000000000');
});
it('Takes an ETH flashloan as big as the available liquidity', async () => {
it('Takes an ETH flashloan with mode = 0 as big as the available liquidity', async () => {
const {pool, weth} = testEnv;
const reserveDataBefore = await pool.getReserveData(weth.address);
console.log("Total liquidity is ", reserveDataBefore.availableLiquidity.toString());
const txResult = await pool.flashLoan(
_mockFlashLoanReceiver.address,
weth.address,
'1000720000000000000',
'0x10'
0,
'0x10',
'0'
);
const reserveData = await pool.getReserveData(weth.address);
@ -85,21 +94,79 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
expect(currentLiquidityIndex.toString()).to.be.equal('1001620648000000000000000000');
});
it('Takes WETH flashloan, does not return the funds (revert expected)', async () => {
const {pool, deployer, weth} = testEnv;
// move funds to the MockFlashLoanReceiver contract to pay the fee
it('Takes WETH flashloan, does not return the funds with mode = 0. (revert expected)', async () => {
const {pool, weth, users} = testEnv;
const caller = users[1];
await _mockFlashLoanReceiver.setFailExecutionTransfer(true);
await expect(
pool.flashLoan(
pool
.connect(caller.signer)
.flashLoan(
_mockFlashLoanReceiver.address,
weth.address,
ethers.utils.parseEther('0.8'),
0,
'0x10',
'0'
)
).to.be.revertedWith(TRANSFER_AMOUNT_EXCEEDS_BALANCE);
});
it('Takes a WETH flashloan with an invalid mode. (revert expected)', async () => {
const {pool, weth, users} = testEnv;
const caller = users[1];
await _mockFlashLoanReceiver.setFailExecutionTransfer(true);
await expect(
pool
.connect(caller.signer)
.flashLoan(
_mockFlashLoanReceiver.address,
weth.address,
ethers.utils.parseEther('0.8'),
4,
'0x10',
'0'
)
).to.be.revertedWith(INVALID_FLASHLOAN_MODE);
});
it('Caller deposits 1000 DAI as collateral, Takes WETH flashloan with mode = 2, does not return the funds. A variable loan for caller is created', async () => {
const {dai, pool, weth, users} = testEnv;
const caller = users[1];
await dai.connect(caller.signer).mint(await convertToCurrencyDecimals(dai.address, '1000'));
await dai.connect(caller.signer).approve(pool.address, APPROVAL_AMOUNT_LENDING_POOL);
const amountToDeposit = await convertToCurrencyDecimals(dai.address, '1000');
await pool.connect(caller.signer).deposit(dai.address, amountToDeposit, '0');
await _mockFlashLoanReceiver.setFailExecutionTransfer(true);
await pool
.connect(caller.signer)
.flashLoan(
_mockFlashLoanReceiver.address,
weth.address,
ethers.utils.parseEther('0.8'),
'0x10'
)
).to.be.revertedWith(INCONSISTENT_PROTOCOL_BALANCE);
2,
'0x10',
'0'
);
const {variableDebtTokenAddress} = await pool.getReserveTokensAddresses(weth.address);
const wethDebtToken = await getContract<VariableDebtToken>(
eContractid.VariableDebtToken,
variableDebtTokenAddress
);
const callerDebt = await wethDebtToken.balanceOf(caller.address);
expect(callerDebt.toString()).to.be.equal('800720000000000000', 'Invalid user debt');
});
it('tries to take a very small flashloan, which would result in 0 fees (revert expected)', async () => {
@ -110,9 +177,11 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
_mockFlashLoanReceiver.address,
weth.address,
'1', //1 wei loan
'0x10'
2,
'0x10',
'0'
)
).to.be.revertedWith(TOO_SMALL_FLASH_LOAN);
).to.be.revertedWith(REQUESTED_AMOUNT_TOO_SMALL);
});
it('tries to take a flashloan that is bigger than the available liquidity (revert expected)', async () => {
@ -123,45 +192,52 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
_mockFlashLoanReceiver.address,
weth.address,
'1004415000000000000', //slightly higher than the available liquidity
'0x10'
2,
'0x10',
'0'
),
NOT_ENOUGH_LIQUIDITY_TO_BORROW
).to.be.revertedWith(NOT_ENOUGH_LIQUIDITY_TO_BORROW);
TRANSFER_AMOUNT_EXCEEDS_BALANCE
).to.be.revertedWith(SAFEERC20_LOWLEVEL_CALL);
});
it('tries to take a flashloan using a non contract address as receiver (revert expected)', async () => {
const {pool, deployer, weth} = testEnv;
await expect(pool.flashLoan(deployer.address, weth.address, '1000000000000000000', '0x10')).to
.be.reverted;
await expect(
pool.flashLoan(deployer.address, weth.address, '1000000000000000000', 2, '0x10', '0')
).to.be.reverted;
});
it('Deposits DAI into the reserve', async () => {
const {dai, pool} = testEnv;
it('Deposits USDC into the reserve', async () => {
const {usdc, pool} = testEnv;
await dai.mint(await convertToCurrencyDecimals(dai.address, '1000'));
await usdc.mint(await convertToCurrencyDecimals(usdc.address, '1000'));
await dai.approve(pool.address, APPROVAL_AMOUNT_LENDING_POOL);
await usdc.approve(pool.address, APPROVAL_AMOUNT_LENDING_POOL);
const amountToDeposit = await convertToCurrencyDecimals(dai.address, '1000');
const amountToDeposit = await convertToCurrencyDecimals(usdc.address, '1000');
await pool.deposit(dai.address, amountToDeposit, '0');
await pool.deposit(usdc.address, amountToDeposit, '0');
});
it('Takes out a 500 DAI flashloan, returns the funds correctly', async () => {
const {dai, pool, deployer: depositor} = testEnv;
it('Takes out a 500 USDC flashloan, returns the funds correctly', async () => {
const {usdc, pool, deployer: depositor} = testEnv;
await _mockFlashLoanReceiver.setFailExecutionTransfer(false);
const flashloanAmount = await convertToCurrencyDecimals(usdc.address, '500');
await pool.flashLoan(
_mockFlashLoanReceiver.address,
dai.address,
ethers.utils.parseEther('500'),
'0x10'
usdc.address,
flashloanAmount,
0,
'0x10',
'0'
);
const reserveData = await pool.getReserveData(dai.address);
const userData = await pool.getUserReserveData(dai.address, depositor.address);
const reserveData = await pool.getReserveData(usdc.address);
const userData = await pool.getUserReserveData(usdc.address, depositor.address);
const totalLiquidity = reserveData.availableLiquidity
.add(reserveData.totalBorrowsStable)
@ -171,7 +247,7 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
const currentLiquidityIndex = reserveData.liquidityIndex.toString();
const currentUserBalance = userData.currentATokenBalance.toString();
const expectedLiquidity = ethers.utils.parseEther('1000.450');
const expectedLiquidity = await convertToCurrencyDecimals(usdc.address, '1000.450');
expect(totalLiquidity).to.be.equal(expectedLiquidity, 'Invalid total liquidity');
expect(currentLiqudityRate).to.be.equal('0', 'Invalid liquidity rate');
@ -182,19 +258,100 @@ makeSuite('LendingPool FlashLoan function', (testEnv: TestEnv) => {
expect(currentUserBalance.toString()).to.be.equal(expectedLiquidity, 'Invalid user balance');
});
it('Takes out a 500 DAI flashloan, does not return the funds (revert expected)', async () => {
const {dai, pool} = testEnv;
it('Takes out a 500 USDC flashloan with mode = 0, does not return the funds. (revert expected)', async () => {
const {usdc, pool, users} = testEnv;
const caller = users[2];
const flashloanAmount = await convertToCurrencyDecimals(usdc.address, '500');
await _mockFlashLoanReceiver.setFailExecutionTransfer(true);
await expect(
pool.flashLoan(
_mockFlashLoanReceiver.address,
dai.address,
ethers.utils.parseEther('500'),
'0x10'
),
INCONSISTENT_PROTOCOL_BALANCE
).to.be.revertedWith(INCONSISTENT_PROTOCOL_BALANCE);
pool
.connect(caller.signer)
.flashLoan(_mockFlashLoanReceiver.address, usdc.address, flashloanAmount, 2, '0x10', '0')
).to.be.revertedWith(COLLATERAL_BALANCE_IS_0);
});
it('Caller deposits 5 WETH as collateral, Takes a USDC flashloan with mode = 2, does not return the funds. A loan for caller is created', async () => {
const {usdc, pool, weth, users} = testEnv;
const caller = users[2];
await weth.connect(caller.signer).mint(await convertToCurrencyDecimals(weth.address, '5'));
await weth.connect(caller.signer).approve(pool.address, APPROVAL_AMOUNT_LENDING_POOL);
const amountToDeposit = await convertToCurrencyDecimals(weth.address, '5');
await pool.connect(caller.signer).deposit(weth.address, amountToDeposit, '0');
await _mockFlashLoanReceiver.setFailExecutionTransfer(true);
const flashloanAmount = await convertToCurrencyDecimals(usdc.address, '500');
await pool
.connect(caller.signer)
.flashLoan(_mockFlashLoanReceiver.address, usdc.address, flashloanAmount, 2, '0x10', '0');
const {variableDebtTokenAddress} = await pool.getReserveTokensAddresses(usdc.address);
const usdcDebtToken = await getContract<VariableDebtToken>(
eContractid.VariableDebtToken,
variableDebtTokenAddress
);
const callerDebt = await usdcDebtToken.balanceOf(caller.address);
expect(callerDebt.toString()).to.be.equal('500450000', 'Invalid user debt');
});
it('Caller deposits 1000 DAI as collateral, Takes a WETH flashloan with mode = 0, does not approve the transfer of the funds', async () => {
const {dai, pool, weth, users} = testEnv;
const caller = users[3];
await dai.connect(caller.signer).mint(await convertToCurrencyDecimals(dai.address, '1000'));
await dai.connect(caller.signer).approve(pool.address, APPROVAL_AMOUNT_LENDING_POOL);
const amountToDeposit = await convertToCurrencyDecimals(dai.address, '1000');
await pool.connect(caller.signer).deposit(dai.address, amountToDeposit, '0');
const flashAmount = ethers.utils.parseEther('0.8');
await _mockFlashLoanReceiver.setFailExecutionTransfer(false);
await _mockFlashLoanReceiver.setAmountToApprove(flashAmount.div(2));
await expect(
pool
.connect(caller.signer)
.flashLoan(_mockFlashLoanReceiver.address, weth.address, flashAmount, 0, '0x10', '0')
).to.be.revertedWith('ERC20: transfer amount exceeds allowance');
});
it('Caller takes a WETH flashloan with mode = 1', async () => {
const {dai, pool, weth, users} = testEnv;
const caller = users[3];
const flashAmount = ethers.utils.parseEther('0.8');
await _mockFlashLoanReceiver.setFailExecutionTransfer(true);
await pool
.connect(caller.signer)
.flashLoan(_mockFlashLoanReceiver.address, weth.address, flashAmount, 1, '0x10', '0');
const {stableDebtTokenAddress} = await pool.getReserveTokensAddresses(weth.address);
const wethDebtToken = await getContract<StableDebtToken>(
eContractid.VariableDebtToken,
stableDebtTokenAddress
);
const callerDebt = await wethDebtToken.balanceOf(caller.address);
expect(callerDebt.toString()).to.be.equal('800720000000000000', 'Invalid user debt');
});
});

28
test/helpers/utils/calculations.ts
View File

@ -7,9 +7,9 @@ import {
EXCESS_UTILIZATION_RATE,
ZERO_ADDRESS,
} from '../../../helpers/constants';
import { IReserveParams, iAavePoolAssets, RateMode } from '../../../helpers/types';
import {IReserveParams, iAavePoolAssets, RateMode} from '../../../helpers/types';
import './math';
import { ReserveData, UserReserveData } from './interfaces';
import {ReserveData, UserReserveData} from './interfaces';
export const strToBN = (amount: string): BigNumber => new BigNumber(amount);
@ -687,7 +687,7 @@ export const calcExpectedUserDataAfterSetUseAsCollateral = (
userDataBeforeAction: UserReserveData,
txCost: BigNumber
): UserReserveData => {
const expectedUserData = { ...userDataBeforeAction };
const expectedUserData = {...userDataBeforeAction};
expectedUserData.usageAsCollateralEnabled = useAsCollateral;
@ -793,7 +793,7 @@ export const calcExpectedUserDataAfterSwapRateMode = (
txCost: BigNumber,
txTimestamp: BigNumber
): UserReserveData => {
const expectedUserData = { ...userDataBeforeAction };
const expectedUserData = {...userDataBeforeAction};
const variableBorrowBalance = calcExpectedVariableDebtTokenBalance(
reserveDataBeforeAction,
@ -937,7 +937,7 @@ export const calcExpectedUserDataAfterStableRateRebalance = (
txCost: BigNumber,
txTimestamp: BigNumber
): UserReserveData => {
const expectedUserData = { ...userDataBeforeAction };
const expectedUserData = {...userDataBeforeAction};
expectedUserData.principalVariableDebt = calcExpectedVariableDebtTokenBalance(
reserveDataBeforeAction,
@ -992,8 +992,8 @@ export const calcExpectedUsersDataAfterRedirectInterest = (
txCost: BigNumber,
txTimestamp: BigNumber
): UserReserveData[] => {
const expectedFromData = { ...fromDataBeforeAction };
const expectedToData = { ...toDataBeforeAction };
const expectedFromData = {...fromDataBeforeAction};
const expectedToData = {...toDataBeforeAction};
expectedFromData.currentStableDebt = calcExpectedStableDebtTokenBalance(
fromDataBeforeAction,
@ -1164,7 +1164,7 @@ export const calcExpectedVariableDebtTokenBalance = (
) => {
const debt = calcExpectedReserveNormalizedDebt(reserveDataBeforeAction, currentTimestamp);
const { principalVariableDebt, variableBorrowIndex } = userDataBeforeAction;
const {principalVariableDebt, variableBorrowIndex} = userDataBeforeAction;
if (variableBorrowIndex.eq(0)) {
return principalVariableDebt;
@ -1177,7 +1177,7 @@ export const calcExpectedStableDebtTokenBalance = (
userDataBeforeAction: UserReserveData,
currentTimestamp: BigNumber
) => {
const { principalStableDebt, stableBorrowRate, stableRateLastUpdated } = userDataBeforeAction;
const {principalStableDebt, stableBorrowRate, stableRateLastUpdated} = userDataBeforeAction;
if (
stableBorrowRate.eq(0) ||
@ -1250,7 +1250,7 @@ const calcExpectedInterestRates = (
totalBorrowsVariable: BigNumber,
averageStableBorrowRate: BigNumber
): BigNumber[] => {
const { reservesParams } = configuration;
const {reservesParams} = configuration;
const reserveIndex = Object.keys(reservesParams).findIndex((value) => value === reserveSymbol);
const [, reserveConfiguration] = (Object.entries(reservesParams) as [string, IReserveParams][])[
@ -1340,7 +1340,7 @@ const calcExpectedReserveNormalizedIncome = (
reserveData: ReserveData,
currentTimestamp: BigNumber
) => {
const { liquidityRate, liquidityIndex, lastUpdateTimestamp } = reserveData;
const {liquidityRate, liquidityIndex, lastUpdateTimestamp} = reserveData;
//if utilization rate is 0, nothing to compound
if (liquidityRate.eq('0')) {
@ -1362,7 +1362,7 @@ const calcExpectedReserveNormalizedDebt = (
reserveData: ReserveData,
currentTimestamp: BigNumber
) => {
const { variableBorrowRate, variableBorrowIndex, lastUpdateTimestamp } = reserveData;
const {variableBorrowRate, variableBorrowIndex, lastUpdateTimestamp} = reserveData;
//if utilization rate is 0, nothing to compound
if (variableBorrowRate.eq('0')) {
@ -1408,8 +1408,8 @@ const calcExpectedLiquidityIndex = (reserveData: ReserveData, timestamp: BigNumb
};
const calcExpectedVariableBorrowIndex = (reserveData: ReserveData, timestamp: BigNumber) => {
//if utilization rate is 0, nothing to compound
if (reserveData.utilizationRate.eq('0')) {
//if totalBorrowsVariable is 0, nothing to compound
if (reserveData.totalBorrowsVariable.eq('0')) {
return reserveData.variableBorrowIndex;
}

12
test/liquidation-atoken.spec.ts
View File

@ -13,10 +13,10 @@ const {expect} = chai;
makeSuite('LendingPool liquidation - liquidator receiving aToken', (testEnv) => {
const {
HF_IS_NOT_BELLOW_THRESHOLD,
HEALTH_FACTOR_NOT_BELOW_THRESHOLD,
INVALID_HF,
USER_DID_NOT_BORROW_SPECIFIED,
THE_COLLATERAL_CHOSEN_CANNOT_BE_LIQUIDATED,
SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER,
COLLATERAL_CANNOT_BE_LIQUIDATED,
} = ProtocolErrors;
it('LIQUIDATION - Deposits WETH, borrows DAI/Check liquidation fails because health factor is above 1', async () => {
@ -71,7 +71,7 @@ makeSuite('LendingPool liquidation - liquidator receiving aToken', (testEnv) =>
//someone tries to liquidate user 2
await expect(
pool.liquidationCall(weth.address, dai.address, borrower.address, 1, true)
).to.be.revertedWith(HF_IS_NOT_BELLOW_THRESHOLD);
).to.be.revertedWith(HEALTH_FACTOR_NOT_BELOW_THRESHOLD);
});
it('LIQUIDATION - Drop the health factor below 1', async () => {
@ -96,7 +96,7 @@ makeSuite('LendingPool liquidation - liquidator receiving aToken', (testEnv) =>
//user 2 tries to borrow
await expect(
pool.liquidationCall(weth.address, weth.address, borrower.address, oneEther.toString(), true)
).revertedWith(USER_DID_NOT_BORROW_SPECIFIED);
).revertedWith(SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER);
});
it('LIQUIDATION - Tries to liquidate a different collateral than the borrower collateral', async () => {
@ -105,7 +105,7 @@ makeSuite('LendingPool liquidation - liquidator receiving aToken', (testEnv) =>
await expect(
pool.liquidationCall(dai.address, dai.address, borrower.address, oneEther.toString(), true)
).revertedWith(THE_COLLATERAL_CHOSEN_CANNOT_BE_LIQUIDATED);
).revertedWith(COLLATERAL_CANNOT_BE_LIQUIDATED);
});
it('LIQUIDATION - Liquidates the borrow', async () => {

13
test/liquidation-underlying.spec.ts
View File

@ -13,15 +13,12 @@ const chai = require('chai');
const {expect} = chai;
makeSuite('LendingPool liquidation - liquidator receiving the underlying asset', (testEnv) => {
const {
HF_IS_NOT_BELLOW_THRESHOLD,
INVALID_HF,
USER_DID_NOT_BORROW_SPECIFIED,
THE_COLLATERAL_CHOSEN_CANNOT_BE_LIQUIDATED,
} = ProtocolErrors;
const {INVALID_HF} = ProtocolErrors;
before('Before LendingPool liquidation: set config', () => {
BigNumber.config({DECIMAL_PLACES: 0, ROUNDING_MODE: BigNumber.ROUND_DOWN});
});
after('After LendingPool liquidation: reset config', () => {
BigNumber.config({DECIMAL_PLACES: 20, ROUNDING_MODE: BigNumber.ROUND_HALF_UP});
});
@ -73,7 +70,7 @@ makeSuite('LendingPool liquidation - liquidator receiving the underlying asset',
expect(userGlobalDataAfter.currentLiquidationThreshold.toString()).to.be.bignumber.equal(
'8000',
'Invalid liquidation threshold'
INVALID_HF
);
});
@ -92,7 +89,7 @@ makeSuite('LendingPool liquidation - liquidator receiving the underlying asset',
expect(userGlobalData.healthFactor.toString()).to.be.bignumber.lt(
oneEther.toFixed(0),
'Invalid health factor'
INVALID_HF
);
});

15
test/repay-with-collateral.spec.ts
View File

@ -14,18 +14,18 @@ import {tEthereumAddress} from '../helpers/types';
const {expect} = require('chai');
const {parseUnits, parseEther} = ethers.utils;
const expectRepayWithCollateralEvent = (
export const expectRepayWithCollateralEvent = (
events: ethers.Event[],
pool: tEthereumAddress,
collateral: tEthereumAddress,
borrowing: tEthereumAddress,
user: tEthereumAddress
) => {
if (!events || events.length < 14) {
if (!events || events.length < 16) {
expect(false, 'INVALID_EVENTS_LENGTH_ON_REPAY_COLLATERAL');
}
const repayWithCollateralEvent = events[13];
const repayWithCollateralEvent = events[15];
expect(repayWithCollateralEvent.address).to.be.equal(pool);
expect(`0x${repayWithCollateralEvent.topics[1].slice(26)}`.toLowerCase()).to.be.equal(
@ -73,7 +73,7 @@ makeSuite('LendingPool. repayWithCollateral()', (testEnv: TestEnv) => {
const amountToRepay = parseEther('10');
await waitForTx(await mockSwapAdapter.setTryReentrancy(true))
await waitForTx(await mockSwapAdapter.setTryReentrancy(true));
await mockSwapAdapter.setAmountToReturn(amountToRepay);
await expect(
@ -87,8 +87,7 @@ makeSuite('LendingPool. repayWithCollateral()', (testEnv: TestEnv) => {
mockSwapAdapter.address,
'0x'
)
).to.be.revertedWith("FAILED_REPAY_WITH_COLLATERAL")
).to.be.revertedWith('53');
});
it('User 2 tries to repay his DAI Variable loan using his WETH collateral. First half the amount, after that, the rest', async () => {
@ -97,7 +96,7 @@ makeSuite('LendingPool. repayWithCollateral()', (testEnv: TestEnv) => {
const amountToRepay = parseEther('10');
await waitForTx(await mockSwapAdapter.setTryReentrancy(false))
await waitForTx(await mockSwapAdapter.setTryReentrancy(false));
const {userData: wethUserDataBefore} = await getContractsData(
weth.address,
@ -294,7 +293,7 @@ makeSuite('LendingPool. repayWithCollateral()', (testEnv: TestEnv) => {
mockSwapAdapter.address,
'0x'
)
).to.be.revertedWith('revert CURRRENCY_NOT_BORROWED');
).to.be.revertedWith('40');
});
it('User 3 tries to repay with his collateral all his variable debt and part of the stable', async () => {

6
test/stable-token.spec.ts
View File

@ -5,7 +5,7 @@ import {getContract} from '../helpers/contracts-helpers';
import {StableDebtToken} from '../types/StableDebtToken';
makeSuite('Stable debt token tests', (testEnv: TestEnv) => {
const {INVALID_POOL_CALLER_MSG_1} = ProtocolErrors;
const {CALLER_MUST_BE_LENDING_POOL} = ProtocolErrors;
it('Tries to invoke mint not being the LendingPool', async () => {
const {deployer, pool, dai} = testEnv;
@ -19,7 +19,7 @@ makeSuite('Stable debt token tests', (testEnv: TestEnv) => {
);
await expect(stableDebtContract.mint(deployer.address, '1', '1')).to.be.revertedWith(
INVALID_POOL_CALLER_MSG_1
CALLER_MUST_BE_LENDING_POOL
);
});
@ -35,7 +35,7 @@ makeSuite('Stable debt token tests', (testEnv: TestEnv) => {
);
await expect(stableDebtContract.burn(deployer.address, '1')).to.be.revertedWith(
INVALID_POOL_CALLER_MSG_1
CALLER_MUST_BE_LENDING_POOL
);
});
});

60
test/upgradeability.spec.ts
View File

@ -1,18 +1,22 @@
import {expect} from 'chai';
import {makeSuite, TestEnv} from './helpers/make-suite';
import {ProtocolErrors, eContractid} from '../helpers/types';
import {deployGenericAToken, getAToken, deployContract, getContract} from '../helpers/contracts-helpers';
import {
deployGenericAToken,
getAToken,
deployContract,
getContract,
} from '../helpers/contracts-helpers';
import {MockAToken} from '../types/MockAToken';
import { MockStableDebtToken } from '../types/MockStableDebtToken';
import { MockVariableDebtToken } from '../types/MockVariableDebtToken';
import {MockStableDebtToken} from '../types/MockStableDebtToken';
import {MockVariableDebtToken} from '../types/MockVariableDebtToken';
makeSuite('Upgradeability', (testEnv: TestEnv) => {
const {INVALID_POOL_MANAGER_CALLER_MSG} = ProtocolErrors;
const {CALLER_NOT_LENDING_POOL_MANAGER} = ProtocolErrors;
let newATokenAddress: string;
let newStableTokenAddress: string;
let newVariableTokenAddress: string;
before('deploying instances', async () => {
const {dai, pool} = testEnv;
const aTokenInstance = await deployContract<MockAToken>(eContractid.MockAToken, [
@ -22,24 +26,19 @@ makeSuite('Upgradeability', (testEnv: TestEnv) => {
'aDAI',
]);
const stableDebtTokenInstance = await deployContract<MockStableDebtToken>(eContractid.MockStableDebtToken, [
pool.address,
dai.address,
'Aave stable debt bearing DAI updated',
'stableDebtDAI',
]);
const stableDebtTokenInstance = await deployContract<MockStableDebtToken>(
eContractid.MockStableDebtToken,
[pool.address, dai.address, 'Aave stable debt bearing DAI updated', 'stableDebtDAI']
);
const variableDebtTokenInstance = await deployContract<MockVariableDebtToken>(eContractid.MockVariableDebtToken, [
pool.address,
dai.address,
'Aave variable debt bearing DAI updated',
'variableDebtDAI',
]);
const variableDebtTokenInstance = await deployContract<MockVariableDebtToken>(
eContractid.MockVariableDebtToken,
[pool.address, dai.address, 'Aave variable debt bearing DAI updated', 'variableDebtDAI']
);
newATokenAddress = aTokenInstance.address;
newVariableTokenAddress = variableDebtTokenInstance.address;
newStableTokenAddress = stableDebtTokenInstance.address;
});
it('Tries to update the DAI Atoken implementation with a different address than the lendingPoolManager', async () => {
@ -47,7 +46,7 @@ makeSuite('Upgradeability', (testEnv: TestEnv) => {
await expect(
configurator.connect(users[1].signer).updateAToken(dai.address, newATokenAddress)
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Upgrades the DAI Atoken implementation ', async () => {
@ -66,8 +65,10 @@ makeSuite('Upgradeability', (testEnv: TestEnv) => {
const {dai, configurator, users} = testEnv;
await expect(
configurator.connect(users[1].signer).updateStableDebtToken(dai.address, newStableTokenAddress)
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
configurator
.connect(users[1].signer)
.updateStableDebtToken(dai.address, newStableTokenAddress)
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Upgrades the DAI stable debt token implementation ', async () => {
@ -79,7 +80,10 @@ makeSuite('Upgradeability', (testEnv: TestEnv) => {
const {stableDebtTokenAddress} = await pool.getReserveTokensAddresses(dai.address);
const debtToken = await getContract<MockStableDebtToken>(eContractid.MockStableDebtToken, stableDebtTokenAddress);
const debtToken = await getContract<MockStableDebtToken>(
eContractid.MockStableDebtToken,
stableDebtTokenAddress
);
const tokenName = await debtToken.name();
@ -90,8 +94,10 @@ makeSuite('Upgradeability', (testEnv: TestEnv) => {
const {dai, configurator, users} = testEnv;
await expect(
configurator.connect(users[1].signer).updateVariableDebtToken(dai.address, newVariableTokenAddress)
).to.be.revertedWith(INVALID_POOL_MANAGER_CALLER_MSG);
configurator
.connect(users[1].signer)
.updateVariableDebtToken(dai.address, newVariableTokenAddress)
).to.be.revertedWith(CALLER_NOT_LENDING_POOL_MANAGER);
});
it('Upgrades the DAI variable debt token implementation ', async () => {
@ -103,11 +109,13 @@ makeSuite('Upgradeability', (testEnv: TestEnv) => {
const {variableDebtTokenAddress} = await pool.getReserveTokensAddresses(dai.address);
const debtToken = await getContract<MockStableDebtToken>(eContractid.MockStableDebtToken, variableDebtTokenAddress);
const debtToken = await getContract<MockStableDebtToken>(
eContractid.MockStableDebtToken,
variableDebtTokenAddress
);
const tokenName = await debtToken.name();
expect(tokenName).to.be.eq('Aave variable debt bearing DAI updated', 'Invalid token name');
});
});

6
test/variable-debt-token.spec.ts
View File

@ -5,7 +5,7 @@ import {getContract} from '../helpers/contracts-helpers';
import {VariableDebtToken} from '../types/VariableDebtToken';
makeSuite('Variable debt token tests', (testEnv: TestEnv) => {
const {INVALID_POOL_CALLER_MSG_1} = ProtocolErrors;
const {CALLER_MUST_BE_LENDING_POOL} = ProtocolErrors;
it('Tries to invoke mint not being the LendingPool', async () => {
const {deployer, pool, dai} = testEnv;
@ -19,7 +19,7 @@ makeSuite('Variable debt token tests', (testEnv: TestEnv) => {
);
await expect(variableDebtContract.mint(deployer.address, '1')).to.be.revertedWith(
INVALID_POOL_CALLER_MSG_1
CALLER_MUST_BE_LENDING_POOL
);
});
@ -35,7 +35,7 @@ makeSuite('Variable debt token tests', (testEnv: TestEnv) => {
);
await expect(variableDebtContract.burn(deployer.address, '1')).to.be.revertedWith(
INVALID_POOL_CALLER_MSG_1
CALLER_MUST_BE_LENDING_POOL
);
});
});