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 branch 'master' into fix/23

Browse Source
This commit is contained in:
The3D 2020-08-23 16:41:35 +02:00
commit 8e3c1a048b
17 changed files with 426 additions and 3084 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
contracts/configuration/LendingPoolAddressesProvider.sol
View File

@ -43,7 +43,7 @@ contract LendingPoolAddressesProvider is Ownable, ILendingPoolAddressesProvider
* @param pool the new lending pool implementation
**/
function setLendingPoolImpl(address pool) external override onlyOwner {
_updateImplementation(LENDING_POOL, pool);
_updateImpl(LENDING_POOL, pool);
emit LendingPoolUpdated(pool);
}
@ -60,7 +60,7 @@ contract LendingPoolAddressesProvider is Ownable, ILendingPoolAddressesProvider
* @param configurator the new lending pool configurator implementation
**/
function setLendingPoolConfiguratorImpl(address configurator) external override onlyOwner {
_updateImplementation(LENDING_POOL_CONFIGURATOR, configurator);
_updateImpl(LENDING_POOL_CONFIGURATOR, configurator);
emit LendingPoolConfiguratorUpdated(configurator);
}
@ -121,7 +121,7 @@ contract LendingPoolAddressesProvider is Ownable, ILendingPoolAddressesProvider
* @param id the id of the contract to be updated
* @param newAddress the address of the new implementation
**/
function _updateImplementation(bytes32 id, address newAddress) internal {
function _updateImpl(bytes32 id, address newAddress) internal {
address payable proxyAddress = payable(_addresses[id]);
InitializableAdminUpgradeabilityProxy proxy = InitializableAdminUpgradeabilityProxy(

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

@ -20,7 +20,7 @@ abstract contract FlashLoanReceiverBase is IFlashLoanReceiver {
receive() external payable {}
function transferFundsBackInternal(
function _transferFundsBack(
address reserve,
address destination,
uint256 amount

4
contracts/lendingpool/DefaultReserveInterestRateStrategy.sol
View File

@ -149,7 +149,7 @@ contract DefaultReserveInterestRateStrategy is IReserveInterestRateStrategy {
);
}
currentLiquidityRate = getOverallBorrowRateInternal(
currentLiquidityRate = _getOverallBorrowRate(
totalBorrowsStable,
totalBorrowsVariable,
currentVariableBorrowRate,
@ -170,7 +170,7 @@ contract DefaultReserveInterestRateStrategy is IReserveInterestRateStrategy {
* @param currentAverageStableBorrowRate the weighted average of all the stable rate borrows
* @return the weighted averaged borrow rate
**/
function getOverallBorrowRateInternal(
function _getOverallBorrowRate(
uint256 totalBorrowsStable,
uint256 totalBorrowsVariable,
uint256 currentVariableBorrowRate,

23
contracts/lendingpool/LendingPool.sol
View File

@ -241,7 +241,7 @@ contract LendingPool is VersionedInitializable, ILendingPool {
(uint256 stableDebt, uint256 variableDebt) = Helpers.getUserCurrentDebt(_onBehalfOf, reserve);
ReserveLogic.InterestRateMode rateMode = ReserveLogic.InterestRateMode(_rateMode);
//default to max amount
uint256 paybackAmount = rateMode == ReserveLogic.InterestRateMode.STABLE
? stableDebt
@ -253,13 +253,11 @@ contract LendingPool is VersionedInitializable, ILendingPool {
ValidationLogic.validateRepay(
reserve,
asset,
amount,
rateMode,
_onBehalfOf,
stableDebt,
variableDebt,
paybackAmount
variableDebt
);
reserve.updateCumulativeIndexesAndTimestamp();
@ -490,7 +488,18 @@ contract LendingPool is VersionedInitializable, ILendingPool {
'The actual balance of the protocol is inconsistent'
);
reserve.updateStateOnFlashLoan(asset, availableLiquidityBefore, amountFee);
//compounding the cumulated interest
reserve.updateCumulativeIndexesAndTimestamp();
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, amountFee, 0);
//solium-disable-next-line
emit FlashLoan(receiverAddress, asset, amount, amountFee);
@ -578,8 +587,8 @@ contract LendingPool is VersionedInitializable, ILendingPool {
reserve.currentVariableBorrowRate,
reserve.currentStableBorrowRate,
IStableDebtToken(reserve.stableDebtTokenAddress).getAverageStableRate(),
reserve.lastLiquidityCumulativeIndex,
reserve.lastVariableBorrowCumulativeIndex,
reserve.lastLiquidityIndex,
reserve.lastVariableBorrowIndex,
reserve.lastUpdateTimestamp
);
}

131
contracts/libraries/configuration/ReserveConfiguration.sol
View File

@ -36,174 +36,171 @@ library ReserveConfiguration {
/**
* @dev sets the Loan to Value of the reserve
* @param _self the reserve configuration
* @param _ltv the new ltv
* @param self the reserve configuration
* @param ltv the new ltv
**/
function setLtv(ReserveConfiguration.Map memory _self, uint256 _ltv) internal {
_self.data = (_self.data & LTV_MASK) | _ltv;
function setLtv(ReserveConfiguration.Map memory self, uint256 ltv) internal pure {
self.data = (self.data & LTV_MASK) | ltv;
}
/**
* @dev gets the Loan to Value of the reserve
* @param _self the reserve configuration
* @param self the reserve configuration
* @return the loan to value
**/
function getLtv(ReserveConfiguration.Map storage _self) internal view returns (uint256) {
return _self.data & ~LTV_MASK;
function getLtv(ReserveConfiguration.Map storage self) internal view returns (uint256) {
return self.data & ~LTV_MASK;
}
/**
* @dev sets the liquidation threshold of the reserve
* @param _self the reserve configuration
* @param _threshold the new liquidation threshold
* @param self the reserve configuration
* @param threshold the new liquidation threshold
**/
function setLiquidationThreshold(ReserveConfiguration.Map memory _self, uint256 _threshold)
function setLiquidationThreshold(ReserveConfiguration.Map memory self, uint256 threshold)
internal
pure
{
_self.data = (_self.data & LIQUIDATION_THRESHOLD_MASK) | (_threshold << 16);
self.data = (self.data & LIQUIDATION_THRESHOLD_MASK) | (threshold << 16);
}
/**
* @dev gets the Loan to Value of the reserve
* @param _self the reserve configuration
* @param self the reserve configuration
* @return the liquidation threshold
**/
function getLiquidationThreshold(ReserveConfiguration.Map storage _self)
function getLiquidationThreshold(ReserveConfiguration.Map storage self)
internal
view
returns (uint256)
{
return (_self.data & ~LIQUIDATION_THRESHOLD_MASK) >> 16;
return (self.data & ~LIQUIDATION_THRESHOLD_MASK) >> 16;
}
/**
* @dev sets the liquidation bonus of the reserve
* @param _self the reserve configuration
* @param _bonus the new liquidation bonus
* @param self the reserve configuration
* @param bonus the new liquidation bonus
**/
function setLiquidationBonus(ReserveConfiguration.Map memory _self, uint256 _bonus) internal {
_self.data = (_self.data & LIQUIDATION_BONUS_MASK) | (_bonus << 32);
function setLiquidationBonus(ReserveConfiguration.Map memory self, uint256 bonus) internal pure {
self.data = (self.data & LIQUIDATION_BONUS_MASK) | (bonus << 32);
}
/**
* @dev gets the liquidation bonus of the reserve
* @param _self the reserve configuration
* @param self the reserve configuration
* @return the liquidation bonus
**/
function getLiquidationBonus(ReserveConfiguration.Map storage _self)
function getLiquidationBonus(ReserveConfiguration.Map storage self)
internal
view
returns (uint256)
{
return (_self.data & ~LIQUIDATION_BONUS_MASK) >> 32;
return (self.data & ~LIQUIDATION_BONUS_MASK) >> 32;
}
/**
* @dev sets the decimals of the underlying asset of the reserve
* @param _self the reserve configuration
* @param _decimals the decimals
* @param self the reserve configuration
* @param decimals the decimals
**/
function setDecimals(ReserveConfiguration.Map memory _self, uint256 _decimals) internal {
_self.data = (_self.data & DECIMALS_MASK) | (_decimals << 48);
function setDecimals(ReserveConfiguration.Map memory self, uint256 decimals) internal pure {
self.data = (self.data & DECIMALS_MASK) | (decimals << 48);
}
/**
* @dev gets the decimals of the underlying asset of the reserve
* @param _self the reserve configuration
* @param self the reserve configuration
* @return the decimals of the asset
**/
function getDecimals(ReserveConfiguration.Map storage _self) internal view returns (uint256) {
return (_self.data & ~DECIMALS_MASK) >> 48;
function getDecimals(ReserveConfiguration.Map storage self) internal view returns (uint256) {
return (self.data & ~DECIMALS_MASK) >> 48;
}
/**
* @dev sets the active state of the reserve
* @param _self the reserve configuration
* @param _active the active state
* @param self the reserve configuration
* @param active the active state
**/
function setActive(ReserveConfiguration.Map memory _self, bool _active) internal {
_self.data = (_self.data & ACTIVE_MASK) | (uint256(_active ? 1 : 0) << 56);
function setActive(ReserveConfiguration.Map memory self, bool active) internal {
self.data = (self.data & ACTIVE_MASK) | (uint256(active ? 1 : 0) << 56);
}
/**
* @dev gets the active state of the reserve
* @param _self the reserve configuration
* @param self the reserve configuration
* @return the active state
**/
function getActive(ReserveConfiguration.Map storage _self) internal view returns (bool) {
return ((_self.data & ~ACTIVE_MASK) >> 56) != 0;
function getActive(ReserveConfiguration.Map storage self) internal view returns (bool) {
return ((self.data & ~ACTIVE_MASK) >> 56) != 0;
}
/**
* @dev sets the frozen state of the reserve
* @param _self the reserve configuration
* @param _frozen the frozen state
* @param self the reserve configuration
* @param frozen the frozen state
**/
function setFrozen(ReserveConfiguration.Map memory _self, bool _frozen) internal {
_self.data = (_self.data & FROZEN_MASK) | (uint256(_frozen ? 1 : 0) << 57);
function setFrozen(ReserveConfiguration.Map memory self, bool frozen) internal pure {
self.data = (self.data & FROZEN_MASK) | (uint256(frozen ? 1 : 0) << 57);
}
/**
* @dev gets the frozen state of the reserve
* @param _self the reserve configuration
* @param self the reserve configuration
* @return the frozen state
**/
function getFrozen(ReserveConfiguration.Map storage _self) internal view returns (bool) {
return ((_self.data & ~FROZEN_MASK) >> 57) != 0;
function getFrozen(ReserveConfiguration.Map storage self) internal view returns (bool) {
return ((self.data & ~FROZEN_MASK) >> 57) != 0;
}
/**
* @dev enables or disables borrowing on the reserve
* @param _self the reserve configuration
* @param _enabled true if the borrowing needs to be enabled, false otherwise
* @param self the reserve configuration
* @param enabled true if the borrowing needs to be enabled, false otherwise
**/
function setBorrowingEnabled(ReserveConfiguration.Map memory _self, bool _enabled) internal {
_self.data = (_self.data & BORROWING_MASK) | (uint256(_enabled ? 1 : 0) << 58);
function setBorrowingEnabled(ReserveConfiguration.Map memory self, bool enabled) internal pure {
self.data = (self.data & BORROWING_MASK) | (uint256(enabled ? 1 : 0) << 58);
}
/**
* @dev gets the borrowing state of the reserve
* @param _self the reserve configuration
* @param self the reserve configuration
* @return the borrowing state
**/
function getBorrowingEnabled(ReserveConfiguration.Map storage _self)
internal
view
returns (bool)
{
return ((_self.data & ~BORROWING_MASK) >> 58) != 0;
function getBorrowingEnabled(ReserveConfiguration.Map storage self) internal view returns (bool) {
return ((self.data & ~BORROWING_MASK) >> 58) != 0;
}
/**
* @dev enables or disables stable rate borrowing on the reserve
* @param _self the reserve configuration
* @param _enabled true if the stable rate borrowing needs to be enabled, false otherwise
* @param self the reserve configuration
* @param enabled true if the stable rate borrowing needs to be enabled, false otherwise
**/
function setStableRateBorrowingEnabled(ReserveConfiguration.Map memory _self, bool _enabled)
internal
function setStableRateBorrowingEnabled(ReserveConfiguration.Map memory self, bool enabled)
internal pure
{
_self.data = (_self.data & STABLE_BORROWING_MASK) | (uint256(_enabled ? 1 : 0) << 59);
self.data = (self.data & STABLE_BORROWING_MASK) | (uint256(enabled ? 1 : 0) << 59);
}
/**
* @dev gets the stable rate borrowing state of the reserve
* @param _self the reserve configuration
* @param self the reserve configuration
* @return the stable rate borrowing state
**/
function getStableRateBorrowingEnabled(ReserveConfiguration.Map storage _self)
function getStableRateBorrowingEnabled(ReserveConfiguration.Map storage self)
internal
view
returns (bool)
{
return ((_self.data & ~STABLE_BORROWING_MASK) >> 59) != 0;
return ((self.data & ~STABLE_BORROWING_MASK) >> 59) != 0;
}
/**
* @dev gets the configuration flags of the reserve
* @param _self the reserve configuration
* @param self the reserve configuration
* @return the state flags representing active, freezed, borrowing enabled, stableRateBorrowing enabled
**/
function getFlags(ReserveConfiguration.Map storage _self)
function getFlags(ReserveConfiguration.Map storage self)
internal
view
returns (
@ -213,7 +210,7 @@ library ReserveConfiguration {
bool
)
{
uint256 dataLocal = _self.data;
uint256 dataLocal = self.data;
return (
(dataLocal & ~ACTIVE_MASK) >> 56 != 0,
@ -225,10 +222,10 @@ library ReserveConfiguration {
/**
* @dev gets the configuration paramters of the reserve
* @param _self the reserve configuration
* @param self the reserve configuration
* @return the state params representing ltv, liquidation threshold, liquidation bonus, the reserve decimals
**/
function getParams(ReserveConfiguration.Map storage _self)
function getParams(ReserveConfiguration.Map storage self)
internal
view
returns (
@ -238,7 +235,7 @@ library ReserveConfiguration {
uint256
)
{
uint256 dataLocal = _self.data;
uint256 dataLocal = self.data;
return (
dataLocal & ~LTV_MASK,

78
contracts/libraries/configuration/UserConfiguration.sol
View File

@ -18,94 +18,94 @@ library UserConfiguration {
}
/**
* @dev sets if the user is borrowing the reserve identified by _reserveIndex
* @param _self the configuration object
* @param _reserveIndex the index of the reserve in the bitmap
* @param _borrowing true if the user is borrowing the reserve, false otherwise
* @dev sets if the user is borrowing the reserve identified by reserveIndex
* @param self the configuration object
* @param reserveIndex the index of the reserve in the bitmap
* @param borrowing true if the user is borrowing the reserve, false otherwise
**/
function setBorrowing(
UserConfiguration.Map storage _self,
uint256 _reserveIndex,
bool _borrowing
UserConfiguration.Map storage self,
uint256 reserveIndex,
bool borrowing
) internal {
_self.data =
(_self.data & ~(1 << (_reserveIndex * 2))) |
(uint256(_borrowing ? 1 : 0) << (_reserveIndex * 2));
self.data =
(self.data & ~(1 << (reserveIndex * 2))) |
(uint256(borrowing ? 1 : 0) << (reserveIndex * 2));
}
/**
* @dev sets if the user is using as collateral the reserve identified by _reserveIndex
* @param _self the configuration object
* @param _reserveIndex the index of the reserve in the bitmap
* @dev sets if the user is using as collateral the reserve identified by reserveIndex
* @param self the configuration object
* @param reserveIndex the index of the reserve in the bitmap
* @param _usingAsCollateral true if the user is usin the reserve as collateral, false otherwise
**/
function setUsingAsCollateral(
UserConfiguration.Map storage _self,
uint256 _reserveIndex,
UserConfiguration.Map storage self,
uint256 reserveIndex,
bool _usingAsCollateral
) internal {
_self.data =
(_self.data & ~(1 << (_reserveIndex * 2 + 1))) |
(uint256(_usingAsCollateral ? 1 : 0) << (_reserveIndex * 2 + 1));
self.data =
(self.data & ~(1 << (reserveIndex * 2 + 1))) |
(uint256(_usingAsCollateral ? 1 : 0) << (reserveIndex * 2 + 1));
}
/**
* @dev used to validate if a user has been using the reserve for borrowing or as collateral
* @param _self the configuration object
* @param _reserveIndex the index of the reserve in the bitmap
* @param self the configuration object
* @param reserveIndex the index of the reserve in the bitmap
* @return true if the user has been using a reserve for borrowing or as collateral, false otherwise
**/
function isUsingAsCollateralOrBorrowing(UserConfiguration.Map memory _self, uint256 _reserveIndex)
function isUsingAsCollateralOrBorrowing(UserConfiguration.Map memory self, uint256 reserveIndex)
internal
view
pure
returns (bool)
{
return (_self.data >> (_reserveIndex * 2)) & 3 != 0;
return (self.data >> (reserveIndex * 2)) & 3 != 0;
}
/**
* @dev used to validate if a user has been using the reserve for borrowing
* @param _self the configuration object
* @param _reserveIndex the index of the reserve in the bitmap
* @param self the configuration object
* @param reserveIndex the index of the reserve in the bitmap
* @return true if the user has been using a reserve for borrowing, false otherwise
**/
function isBorrowing(UserConfiguration.Map memory _self, uint256 _reserveIndex)
function isBorrowing(UserConfiguration.Map memory self, uint256 reserveIndex)
internal
view
pure
returns (bool)
{
return (_self.data >> (_reserveIndex * 2)) & 1 != 0;
return (self.data >> (reserveIndex * 2)) & 1 != 0;
}
/**
* @dev used to validate if a user has been using the reserve as collateral
* @param _self the configuration object
* @param _reserveIndex the index of the reserve in the bitmap
* @param self the configuration object
* @param reserveIndex the index of the reserve in the bitmap
* @return true if the user has been using a reserve as collateral, false otherwise
**/
function isUsingAsCollateral(UserConfiguration.Map memory _self, uint256 _reserveIndex)
function isUsingAsCollateral(UserConfiguration.Map memory self, uint256 reserveIndex)
internal
view
pure
returns (bool)
{
return (_self.data >> (_reserveIndex * 2 + 1)) & 1 != 0;
return (self.data >> (reserveIndex * 2 + 1)) & 1 != 0;
}
/**
* @dev used to validate if a user has been borrowing from any reserve
* @param _self the configuration object
* @param self the configuration object
* @return true if the user has been borrowing any reserve, false otherwise
**/
function isBorrowingAny(UserConfiguration.Map memory _self) internal view returns (bool) {
return _self.data & BORROWING_MASK != 0;
function isBorrowingAny(UserConfiguration.Map memory self) internal pure returns (bool) {
return self.data & BORROWING_MASK != 0;
}
/**
* @dev used to validate if a user has not been using any reserve
* @param _self the configuration object
* @param self the configuration object
* @return true if the user has been borrowing any reserve, false otherwise
**/
function isEmpty(UserConfiguration.Map memory _self) internal view returns (bool) {
return _self.data == 0;
function isEmpty(UserConfiguration.Map memory self) internal pure returns (bool) {
return self.data == 0;
}
}

20
contracts/libraries/helpers/Helpers.sol
View File

@ -12,35 +12,35 @@ import {ReserveLogic} from '../logic/ReserveLogic.sol';
library Helpers {
/**
* @dev fetches the user current stable and variable debt balances
* @param _user the user
* @param _reserve the reserve object
* @param user the user
* @param reserve the reserve object
* @return the stable and variable debt balance
**/
function getUserCurrentDebt(address _user, ReserveLogic.ReserveData storage _reserve)
function getUserCurrentDebt(address user, ReserveLogic.ReserveData storage reserve)
internal
view
returns (uint256, uint256)
{
return (
DebtTokenBase(_reserve.stableDebtTokenAddress).balanceOf(_user),
DebtTokenBase(_reserve.variableDebtTokenAddress).balanceOf(_user)
DebtTokenBase(reserve.stableDebtTokenAddress).balanceOf(user),
DebtTokenBase(reserve.variableDebtTokenAddress).balanceOf(user)
);
}
/**
* @dev fetches the user principal stable and variable debt balances
* @param _user the user
* @param _reserve the reserve object
* @param user the user
* @param reserve the reserve object
* @return the stable and variable debt balance
**/
function getUserPrincipalDebt(address _user, ReserveLogic.ReserveData storage _reserve)
function getUserPrincipalDebt(address user, ReserveLogic.ReserveData storage reserve)
internal
view
returns (uint256, uint256)
{
return (
DebtTokenBase(_reserve.stableDebtTokenAddress).principalBalanceOf(_user),
DebtTokenBase(_reserve.variableDebtTokenAddress).principalBalanceOf(_user)
DebtTokenBase(reserve.stableDebtTokenAddress).principalBalanceOf(user),
DebtTokenBase(reserve.variableDebtTokenAddress).principalBalanceOf(user)
);
}
}

80
contracts/libraries/logic/GenericLogic.sol
View File

@ -43,23 +43,27 @@ library GenericLogic {
/**
* @dev check if a specific balance decrease is allowed
* (i.e. doesn't bring the user borrow position health factor under HEALTH_FACTOR_LIQUIDATION_THRESHOLD)
* @param _reserve the address of the reserve
* @param _user the address of the user
* @param _amount the amount to decrease
* @param asset the address of the reserve
* @param user the address of the user
* @param amount the amount to decrease
* @param reservesData the data of all the reserves
* @param userConfig the user configuration
* @param reserves the list of all the active reserves
* @param oracle the address of the oracle contract
* @return true if the decrease of the balance is allowed
**/
function balanceDecreaseAllowed(
address _reserve,
address _user,
uint256 _amount,
mapping(address => ReserveLogic.ReserveData) storage _reservesData,
UserConfiguration.Map calldata _userConfig,
address[] calldata _reserves,
address _oracle
address asset,
address user,
uint256 amount,
mapping(address => ReserveLogic.ReserveData) storage reservesData,
UserConfiguration.Map calldata userConfig,
address[] calldata reserves,
address oracle
) external view returns (bool) {
if (
!_userConfig.isBorrowingAny() ||
!_userConfig.isUsingAsCollateral(_reservesData[_reserve].index)
!userConfig.isBorrowingAny() ||
!userConfig.isUsingAsCollateral(reservesData[asset].index)
) {
return true;
}
@ -67,7 +71,7 @@ library GenericLogic {
// Usage of a memory struct of vars to avoid "Stack too deep" errors due to local variables
balanceDecreaseAllowedLocalVars memory vars;
(vars.ltv, , , vars.decimals) = _reservesData[_reserve].configuration.getParams();
(vars.ltv, , , vars.decimals) = reservesData[asset].configuration.getParams();
if (vars.ltv == 0) {
return true; //if reserve is not used as collateral, no reasons to block the transfer
@ -79,13 +83,13 @@ library GenericLogic {
,
vars.currentLiquidationThreshold,
) = calculateUserAccountData(_user, _reservesData, _userConfig, _reserves, _oracle);
) = calculateUserAccountData(user, reservesData, userConfig, reserves, oracle);
if (vars.borrowBalanceETH == 0) {
return true; //no borrows - no reasons to block the transfer
}
vars.amountToDecreaseETH = IPriceOracleGetter(_oracle).getAssetPrice(_reserve).mul(_amount).div(
vars.amountToDecreaseETH = IPriceOracleGetter(oracle).getAssetPrice(asset).mul(amount).div(
10**vars.decimals
);
@ -137,20 +141,20 @@ library GenericLogic {
* @dev calculates the user data across the reserves.
* this includes the total liquidity/collateral/borrow balances in ETH,
* the average Loan To Value, the average Liquidation Ratio, and the Health factor.
* @param _user the address of the user
* @param _reservesData data of all the reserves
* @param _userConfig the configuration of the user
* @param _reserves the list of the available reserves
* @param _oracle the price oracle address
* @param user the address of the user
* @param reservesData data of all the reserves
* @param userConfig the configuration of the user
* @param reserves the list of the available reserves
* @param oracle the price oracle address
* @return the total collateral and total borrow balance of the user in ETH, the avg ltv and liquidation threshold and the HF
* also the average Ltv, liquidation threshold, and the health factor
**/
function calculateUserAccountData(
address _user,
mapping(address => ReserveLogic.ReserveData) storage _reservesData,
UserConfiguration.Map memory _userConfig,
address[] memory _reserves,
address _oracle
address user,
mapping(address => ReserveLogic.ReserveData) storage reservesData,
UserConfiguration.Map memory userConfig,
address[] memory reserves,
address oracle
)
internal
view
@ -164,26 +168,26 @@ library GenericLogic {
{
CalculateUserAccountDataVars memory vars;
if (_userConfig.isEmpty()) {
if (userConfig.isEmpty()) {
return (0, 0, 0, 0, uint256(-1));
}
for (vars.i = 0; vars.i < _reserves.length; vars.i++) {
if (!_userConfig.isUsingAsCollateralOrBorrowing(vars.i)) {
for (vars.i = 0; vars.i < reserves.length; vars.i++) {
if (!userConfig.isUsingAsCollateralOrBorrowing(vars.i)) {
continue;
}
vars.currentReserveAddress = _reserves[vars.i];
ReserveLogic.ReserveData storage currentReserve = _reservesData[vars.currentReserveAddress];
vars.currentReserveAddress = reserves[vars.i];
ReserveLogic.ReserveData storage currentReserve = reservesData[vars.currentReserveAddress];
(vars.ltv, vars.liquidationThreshold, , vars.decimals) = currentReserve
.configuration
.getParams();
vars.tokenUnit = 10**vars.decimals;
vars.reserveUnitPrice = IPriceOracleGetter(_oracle).getAssetPrice(vars.currentReserveAddress);
vars.reserveUnitPrice = IPriceOracleGetter(oracle).getAssetPrice(vars.currentReserveAddress);
if (vars.ltv != 0 && _userConfig.isUsingAsCollateral(vars.i)) {
vars.compoundedLiquidityBalance = IERC20(currentReserve.aTokenAddress).balanceOf(_user);
if (vars.ltv != 0 && userConfig.isUsingAsCollateral(vars.i)) {
vars.compoundedLiquidityBalance = IERC20(currentReserve.aTokenAddress).balanceOf(user);
uint256 liquidityBalanceETH = vars
.reserveUnitPrice
@ -198,12 +202,12 @@ library GenericLogic {
);
}
if (_userConfig.isBorrowing(vars.i)) {
if (userConfig.isBorrowing(vars.i)) {
vars.compoundedBorrowBalance = IERC20(currentReserve.stableDebtTokenAddress).balanceOf(
_user
user
);
vars.compoundedBorrowBalance = vars.compoundedBorrowBalance.add(
IERC20(currentReserve.variableDebtTokenAddress).balanceOf(_user)
IERC20(currentReserve.variableDebtTokenAddress).balanceOf(user)
);
vars.totalBorrowBalanceETH = vars.totalBorrowBalanceETH.add(
@ -244,7 +248,7 @@ library GenericLogic {
uint256 collateralBalanceETH,
uint256 borrowBalanceETH,
uint256 liquidationThreshold
) internal view returns (uint256) {
) internal pure returns (uint256) {
if (borrowBalanceETH == 0) return uint256(-1);
return (collateralBalanceETH.percentMul(liquidationThreshold)).wadDiv(borrowBalanceETH);
@ -263,7 +267,7 @@ library GenericLogic {
uint256 collateralBalanceETH,
uint256 borrowBalanceETH,
uint256 ltv
) external view returns (uint256) {
) internal pure returns (uint256) {
uint256 availableBorrowsETH = collateralBalanceETH.percentMul(ltv); //ltv is in percentage
if (availableBorrowsETH < borrowBalanceETH) {

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

@ -23,7 +23,6 @@ library ReserveLogic {
/**
* @dev Emitted when the state of a reserve is updated
* @dev NOTE: This event replaces the Deprecated ReserveUpdated() event, which didn't emit the average stable borrow rate
* @param reserve the address of the reserve
* @param liquidityRate the new liquidity rate
* @param stableBorrowRate the new stable borrow rate
@ -50,7 +49,7 @@ 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 lastLiquidityCumulativeIndex;
uint256 lastLiquidityIndex;
//the current supply rate. Expressed in ray
uint256 currentLiquidityRate;
//the current variable borrow rate. Expressed in ray
@ -58,7 +57,7 @@ library ReserveLogic {
//the current stable borrow rate. Expressed in ray
uint256 currentStableBorrowRate;
//variable borrow index. Expressed in ray
uint256 lastVariableBorrowCumulativeIndex;
uint256 lastVariableBorrowIndex;
//stores the reserve configuration
ReserveConfiguration.Map configuration;
address aTokenAddress;
@ -74,21 +73,21 @@ library ReserveLogic {
* @dev returns the ongoing normalized income for the reserve.
* a value of 1e27 means there is no income. As time passes, the income is accrued.
* A value of 2*1e27 means for each unit of assset two units of income have been accrued.
* @param _reserve the reserve object
* @param reserve the reserve object
* @return the normalized income. expressed in ray
**/
function getNormalizedIncome(ReserveData storage _reserve) internal view returns (uint256) {
uint40 timestamp = _reserve.lastUpdateTimestamp;
function getNormalizedIncome(ReserveData storage reserve) internal view returns (uint256) {
uint40 timestamp = reserve.lastUpdateTimestamp;
//solium-disable-next-line
if (timestamp == uint40(block.timestamp)) {
//if the index was updated in the same block, no need to perform any calculation
return _reserve.lastLiquidityCumulativeIndex;
return reserve.lastLiquidityIndex;
}
uint256 cumulated = MathUtils
.calculateLinearInterest(_reserve.currentLiquidityRate, timestamp)
.rayMul(_reserve.lastLiquidityCumulativeIndex);
.calculateLinearInterest(reserve.currentLiquidityRate, timestamp)
.rayMul(reserve.lastLiquidityIndex);
return cumulated;
}
@ -97,21 +96,21 @@ library ReserveLogic {
* @dev returns the ongoing normalized variable debt for the reserve.
* a value of 1e27 means there is no debt. As time passes, the income is accrued.
* A value of 2*1e27 means that the debt of the reserve is double the initial amount.
* @param _reserve the reserve object
* @param reserve the reserve object
* @return the normalized variable debt. expressed in ray
**/
function getNormalizedDebt(ReserveData storage _reserve) internal view returns (uint256) {
uint40 timestamp = _reserve.lastUpdateTimestamp;
function getNormalizedDebt(ReserveData storage reserve) internal view returns (uint256) {
uint40 timestamp = reserve.lastUpdateTimestamp;
//solium-disable-next-line
if (timestamp == uint40(block.timestamp)) {
//if the index was updated in the same block, no need to perform any calculation
return _reserve.lastVariableBorrowCumulativeIndex;
return reserve.lastVariableBorrowIndex;
}
uint256 cumulated = MathUtils
.calculateCompoundedInterest(_reserve.currentVariableBorrowRate, timestamp)
.rayMul(_reserve.lastVariableBorrowCumulativeIndex);
.calculateCompoundedInterest(reserve.currentVariableBorrowRate, timestamp)
.rayMul(reserve.lastVariableBorrowIndex);
return cumulated;
}
@ -119,153 +118,128 @@ library ReserveLogic {
/**
* @dev Updates the liquidity cumulative index Ci and variable borrow cumulative index Bvc. Refer to the whitepaper for
* a formal specification.
* @param _self the reserve object
* @param reserve the reserve object
**/
function updateCumulativeIndexesAndTimestamp(ReserveData storage _self) internal {
function updateCumulativeIndexesAndTimestamp(ReserveData storage reserve) internal {
//only cumulating if there is any income being produced
if (
IERC20(_self.variableDebtTokenAddress).totalSupply() > 0 ||
IERC20(_self.stableDebtTokenAddress).totalSupply() > 0
IERC20(reserve.variableDebtTokenAddress).totalSupply() > 0 ||
IERC20(reserve.stableDebtTokenAddress).totalSupply() > 0
) {
uint256 cumulatedLiquidityInterest = MathUtils.calculateLinearInterest(
_self.currentLiquidityRate,
_self.lastUpdateTimestamp
reserve.currentLiquidityRate,
reserve.lastUpdateTimestamp
);
_self.lastLiquidityCumulativeIndex = cumulatedLiquidityInterest.rayMul(
_self.lastLiquidityCumulativeIndex
reserve.lastLiquidityIndex = cumulatedLiquidityInterest.rayMul(
reserve.lastLiquidityIndex
);
uint256 cumulatedVariableBorrowInterest = MathUtils.calculateCompoundedInterest(
_self.currentVariableBorrowRate,
_self.lastUpdateTimestamp
reserve.currentVariableBorrowRate,
reserve.lastUpdateTimestamp
);
_self.lastVariableBorrowCumulativeIndex = cumulatedVariableBorrowInterest.rayMul(
_self.lastVariableBorrowCumulativeIndex
reserve.lastVariableBorrowIndex = cumulatedVariableBorrowInterest.rayMul(
reserve.lastVariableBorrowIndex
);
}
//solium-disable-next-line
_self.lastUpdateTimestamp = uint40(block.timestamp);
reserve.lastUpdateTimestamp = uint40(block.timestamp);
}
/**
* @dev accumulates a predefined amount of asset to the reserve as a fixed, one time income. Used for example to accumulate
* the flashloan fee to the reserve, and spread it through the depositors.
* @param _self the reserve object
* @param _totalLiquidity the total liquidity available in the reserve
* @param _amount the amount to accomulate
* @param reserve the reserve object
* @param totalLiquidity the total liquidity available in the reserve
* @param amount the amount to accomulate
**/
function cumulateToLiquidityIndex(
ReserveData storage _self,
uint256 _totalLiquidity,
uint256 _amount
ReserveData storage reserve,
uint256 totalLiquidity,
uint256 amount
) internal {
uint256 amountToLiquidityRatio = _amount.wadToRay().rayDiv(_totalLiquidity.wadToRay());
uint256 amountToLiquidityRatio = amount.wadToRay().rayDiv(totalLiquidity.wadToRay());
uint256 cumulatedLiquidity = amountToLiquidityRatio.add(WadRayMath.ray());
_self.lastLiquidityCumulativeIndex = cumulatedLiquidity.rayMul(
_self.lastLiquidityCumulativeIndex
reserve.lastLiquidityIndex = cumulatedLiquidity.rayMul(
reserve.lastLiquidityIndex
);
}
/**
* @dev initializes a reserve
* @param _self the reserve object
* @param _aTokenAddress the address of the overlying atoken contract
* @param _interestRateStrategyAddress the address of the interest rate strategy contract
* @param reserve the reserve object
* @param aTokenAddress the address of the overlying atoken contract
* @param interestRateStrategyAddress the address of the interest rate strategy contract
**/
function init(
ReserveData storage _self,
address _aTokenAddress,
address _stableDebtAddress,
address _variableDebtAddress,
address _interestRateStrategyAddress
ReserveData storage reserve,
address aTokenAddress,
address stableDebtTokenAddress,
address variableDebtTokenAddress,
address interestRateStrategyAddress
) external {
require(_self.aTokenAddress == address(0), 'Reserve has already been initialized');
if (_self.lastLiquidityCumulativeIndex == 0) {
require(reserve.aTokenAddress == address(0), 'Reserve has already been initialized');
if (reserve.lastLiquidityIndex == 0) {
//if the reserve has not been initialized yet
_self.lastLiquidityCumulativeIndex = WadRayMath.ray();
reserve.lastLiquidityIndex = WadRayMath.ray();
}
if (_self.lastVariableBorrowCumulativeIndex == 0) {
_self.lastVariableBorrowCumulativeIndex = WadRayMath.ray();
if (reserve.lastVariableBorrowIndex == 0) {
reserve.lastVariableBorrowIndex = WadRayMath.ray();
}
_self.aTokenAddress = _aTokenAddress;
_self.stableDebtTokenAddress = _stableDebtAddress;
_self.variableDebtTokenAddress = _variableDebtAddress;
_self.interestRateStrategyAddress = _interestRateStrategyAddress;
}
/**
* @dev updates the state of the core as a result of a flashloan action
* @param _reserve the address of the reserve in which the flashloan is happening
* @param _income the income of the protocol as a result of the action
**/
function updateStateOnFlashLoan(
ReserveData storage _reserve,
address _reserveAddress,
uint256 _availableLiquidityBefore,
uint256 _income
) external {
//compounding the cumulated interest
_reserve.updateCumulativeIndexesAndTimestamp();
uint256 totalLiquidityBefore = _availableLiquidityBefore
.add(IERC20(_reserve.variableDebtTokenAddress).totalSupply())
.add(IERC20(_reserve.stableDebtTokenAddress).totalSupply());
//compounding the received fee into the reserve
_reserve.cumulateToLiquidityIndex(totalLiquidityBefore, _income);
//refresh interest rates
updateInterestRates(_reserve, _reserveAddress, _income, 0);
reserve.aTokenAddress = aTokenAddress;
reserve.stableDebtTokenAddress = stableDebtTokenAddress;
reserve.variableDebtTokenAddress = variableDebtTokenAddress;
reserve.interestRateStrategyAddress = interestRateStrategyAddress;
}
/**
* @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.
* @param _reserve the address of the reserve to be updated
* @param _liquidityAdded the amount of liquidity added to the protocol (deposit or repay) in the previous action
* @param _liquidityTaken the amount of liquidity taken from the protocol (redeem or borrow)
* @param reserve the address of the reserve to be updated
* @param liquidityAdded the amount of liquidity added to the protocol (deposit or repay) in the previous action
* @param liquidityTaken the amount of liquidity taken from the protocol (redeem or borrow)
**/
function updateInterestRates(
ReserveData storage _reserve,
address _reserveAddress,
uint256 _liquidityAdded,
uint256 _liquidityTaken
ReserveData storage reserve,
address reserveAddress,
uint256 liquidityAdded,
uint256 liquidityTaken
) internal {
uint256 currentAvgStableRate = IStableDebtToken(_reserve.stableDebtTokenAddress)
uint256 currentAvgStableRate = IStableDebtToken(reserve.stableDebtTokenAddress)
.getAverageStableRate();
uint256 balance = IERC20(_reserveAddress).balanceOf(_reserve.aTokenAddress);
uint256 balance = IERC20(reserveAddress).balanceOf(reserve.aTokenAddress);
(
uint256 newLiquidityRate,
uint256 newStableRate,
uint256 newVariableRate
) = IReserveInterestRateStrategy(_reserve.interestRateStrategyAddress).calculateInterestRates(
_reserveAddress,
balance.add(_liquidityAdded).sub(_liquidityTaken),
IERC20(_reserve.stableDebtTokenAddress).totalSupply(),
IERC20(_reserve.variableDebtTokenAddress).totalSupply(),
) = IReserveInterestRateStrategy(reserve.interestRateStrategyAddress).calculateInterestRates(
reserveAddress,
balance.add(liquidityAdded).sub(liquidityTaken),
IERC20(reserve.stableDebtTokenAddress).totalSupply(),
IERC20(reserve.variableDebtTokenAddress).totalSupply(),
currentAvgStableRate
);
_reserve.currentLiquidityRate = newLiquidityRate;
_reserve.currentStableBorrowRate = newStableRate;
_reserve.currentVariableBorrowRate = newVariableRate;
reserve.currentLiquidityRate = newLiquidityRate;
reserve.currentStableBorrowRate = newStableRate;
reserve.currentVariableBorrowRate = newVariableRate;
emit ReserveDataUpdated(
_reserveAddress,
reserveAddress,
newLiquidityRate,
newStableRate,
currentAvgStableRate,
newVariableRate,
_reserve.lastLiquidityCumulativeIndex,
_reserve.lastVariableBorrowCumulativeIndex
reserve.lastLiquidityIndex,
reserve.lastVariableBorrowIndex
);
}
}

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

@ -29,54 +29,54 @@ library ValidationLogic {
/**
* @dev validates a deposit.
* @param _reserve the reserve state on which the user is depositing
* @param _amount the amount to be deposited
* @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)
function validateDeposit(ReserveLogic.ReserveData storage reserve, uint256 amount)
internal
view
{
(bool isActive, bool isFreezed, , ) = _reserve.configuration.getFlags();
(bool isActive, bool isFreezed, , ) = reserve.configuration.getFlags();
require(_amount > 0, 'Amount must be greater than 0');
require(amount > 0, 'Amount must be greater than 0');
require(isActive, 'Action requires an active reserve');
require(!isFreezed, 'Action requires an unfreezed reserve');
}
/**
* @dev validates a withdraw action.
* @param _reserveAddress the address of the reserve
* @param _aTokenAddress the address of the aToken for the reserve
* @param _amount the amount to be withdrawn
* @param _userBalance the balance of the user
* @param reserveAddress the address of the reserve
* @param aTokenAddress the address of the aToken for the reserve
* @param amount the amount to be withdrawn
* @param userBalance the balance of the user
*/
function validateWithdraw(
address _reserveAddress,
address _aTokenAddress,
uint256 _amount,
uint256 _userBalance,
mapping(address => ReserveLogic.ReserveData) storage _reservesData,
UserConfiguration.Map storage _userConfig,
address[] calldata _reserves,
address _oracle
address reserveAddress,
address aTokenAddress,
uint256 amount,
uint256 userBalance,
mapping(address => ReserveLogic.ReserveData) storage reservesData,
UserConfiguration.Map storage userConfig,
address[] calldata reserves,
address oracle
) external view {
require(_amount > 0, 'Amount must be greater than 0');
require(amount > 0, 'Amount must be greater than 0');
uint256 currentAvailableLiquidity = IERC20(_reserveAddress).balanceOf(address(_aTokenAddress));
uint256 currentAvailableLiquidity = IERC20(reserveAddress).balanceOf(address(aTokenAddress));
require(currentAvailableLiquidity >= _amount, '4');
require(currentAvailableLiquidity >= amount, '4');
require(_amount <= _userBalance, 'User cannot withdraw more than the available balance');
require(amount <= userBalance, 'User cannot withdraw more than the available balance');
require(
GenericLogic.balanceDecreaseAllowed(
_reserveAddress,
reserveAddress,
msg.sender,
_userBalance,
_reservesData,
_userConfig,
_reserves,
_oracle
userBalance,
reservesData,
userConfig,
reserves,
oracle
),
'Transfer cannot be allowed.'
);
@ -105,29 +105,29 @@ library ValidationLogic {
/**
* @dev validates a borrow.
* @param _reserve the reserve state from which the user is borrowing
* @param _reserveAddress the address of the reserve
* @param _amount the amount to be borrowed
* @param _amountInETH the amount to be borrowed, in ETH
* @param _interestRateMode the interest rate mode at which the user is borrowing
* @param _maxStableLoanPercent the max amount of the liquidity that can be borrowed at stable rate, in percentage
* @param _reservesData the state of all the reserves
* @param _userConfig the state of the user for the specific reserve
* @param _reserves the addresses of all the active reserves
* @param _oracle the price oracle
* @param reserve the reserve state from which the user is borrowing
* @param reserveAddress the address of the reserve
* @param amount the amount to be borrowed
* @param amountInETH the amount to be borrowed, in ETH
* @param interestRateMode the interest rate mode at which the user is borrowing
* @param maxStableLoanPercent the max amount of the liquidity that can be borrowed at stable rate, in percentage
* @param reservesData the state of all the reserves
* @param userConfig the state of the user for the specific reserve
* @param reserves the addresses of all the active reserves
* @param oracle the price oracle
*/
function validateBorrow(
ReserveLogic.ReserveData storage _reserve,
address _reserveAddress,
uint256 _amount,
uint256 _amountInETH,
uint256 _interestRateMode,
uint256 _maxStableLoanPercent,
mapping(address => ReserveLogic.ReserveData) storage _reservesData,
UserConfiguration.Map storage _userConfig,
address[] calldata _reserves,
address _oracle
ReserveLogic.ReserveData storage reserve,
address reserveAddress,
uint256 amount,
uint256 amountInETH,
uint256 interestRateMode,
uint256 maxStableLoanPercent,
mapping(address => ReserveLogic.ReserveData) storage reservesData,
UserConfiguration.Map storage userConfig,
address[] calldata reserves,
address oracle
) external view {
ValidateBorrowLocalVars memory vars;
@ -136,7 +136,7 @@ library ValidationLogic {
vars.isFreezed,
vars.borrowingEnabled,
vars.stableRateBorrowingEnabled
) = _reserve.configuration.getFlags();
) = reserve.configuration.getFlags();
require(vars.isActive, 'Action requires an active reserve');
require(!vars.isFreezed, 'Action requires an unfreezed reserve');
@ -145,15 +145,15 @@ library ValidationLogic {
//validate interest rate mode
require(
uint256(ReserveLogic.InterestRateMode.VARIABLE) == _interestRateMode ||
uint256(ReserveLogic.InterestRateMode.STABLE) == _interestRateMode,
uint256(ReserveLogic.InterestRateMode.VARIABLE) == interestRateMode ||
uint256(ReserveLogic.InterestRateMode.STABLE) == interestRateMode,
'Invalid interest rate mode selected'
);
//check that the amount is available in the reserve
vars.availableLiquidity = IERC20(_reserveAddress).balanceOf(address(_reserve.aTokenAddress));
vars.availableLiquidity = IERC20(reserveAddress).balanceOf(address(reserve.aTokenAddress));
require(vars.availableLiquidity >= _amount, '7');
require(vars.availableLiquidity >= amount, '7');
(
vars.userCollateralBalanceETH,
@ -163,10 +163,10 @@ library ValidationLogic {
vars.healthFactor
) = GenericLogic.calculateUserAccountData(
msg.sender,
_reservesData,
_userConfig,
_reserves,
_oracle
reservesData,
userConfig,
reserves,
oracle
);
require(vars.userCollateralBalanceETH > 0, 'The collateral balance is 0');
@ -174,7 +174,7 @@ library ValidationLogic {
require(vars.healthFactor > GenericLogic.HEALTH_FACTOR_LIQUIDATION_THRESHOLD, '8');
//add the current already borrowed amount to the amount requested to calculate the total collateral needed.
vars.amountOfCollateralNeededETH = vars.userBorrowBalanceETH.add(_amountInETH).percentDiv(
vars.amountOfCollateralNeededETH = vars.userBorrowBalanceETH.add(amountInETH).percentDiv(
vars.currentLtv
); //LTV is calculated in percentage
@ -198,88 +198,84 @@ library ValidationLogic {
require(vars.stableRateBorrowingEnabled, '11');
require(
!_userConfig.isUsingAsCollateral(_reserve.index) ||
_reserve.configuration.getLtv() == 0 ||
_amount > IERC20(_reserve.aTokenAddress).balanceOf(msg.sender),
!userConfig.isUsingAsCollateral(reserve.index) ||
reserve.configuration.getLtv() == 0 ||
amount > IERC20(reserve.aTokenAddress).balanceOf(msg.sender),
'12'
);
//calculate the max available loan size in stable rate mode as a percentage of the
//available liquidity
uint256 maxLoanSizeStable = vars.availableLiquidity.percentMul(_maxStableLoanPercent);
uint256 maxLoanSizeStable = vars.availableLiquidity.percentMul(maxStableLoanPercent);
require(_amount <= maxLoanSizeStable, '13');
require(amount <= maxLoanSizeStable, '13');
}
}
/**
* @dev validates a repay.
* @param _reserve the reserve state from which the user is repaying
* @param _reserveAddress the address of the reserve
* @param _amountSent the amount sent for the repayment. Can be an actual value or uint(-1)
* @param _onBehalfOf the address of the user msg.sender is repaying for
* @param _stableBorrowBalance the borrow balance of the user
* @param _variableBorrowBalance the borrow balance of the user
* @param _actualPaybackAmount the actual amount being repaid
* @param reserve the reserve state from which the user is repaying
* @param amountSent the amount sent for the repayment. Can be an actual value or uint(-1)
* @param onBehalfOf the address of the user msg.sender is repaying for
* @param stableDebt the borrow balance of the user
* @param variableDebt the borrow balance of the user
*/
function validateRepay(
ReserveLogic.ReserveData storage _reserve,
address _reserveAddress,
uint256 _amountSent,
ReserveLogic.InterestRateMode _rateMode,
address _onBehalfOf,
uint256 _stableBorrowBalance,
uint256 _variableBorrowBalance,
uint256 _actualPaybackAmount
ReserveLogic.ReserveData storage reserve,
uint256 amountSent,
ReserveLogic.InterestRateMode rateMode,
address onBehalfOf,
uint256 stableDebt,
uint256 variableDebt
) external view {
bool isActive = _reserve.configuration.getActive();
bool isActive = reserve.configuration.getActive();
require(isActive, 'Action requires an active reserve');
require(_amountSent > 0, 'Amount must be greater than 0');
require(amountSent > 0, 'Amount must be greater than 0');
require(
(_stableBorrowBalance > 0 &&
ReserveLogic.InterestRateMode(_rateMode) == ReserveLogic.InterestRateMode.STABLE) ||
(_variableBorrowBalance > 0 &&
ReserveLogic.InterestRateMode(_rateMode) == ReserveLogic.InterestRateMode.VARIABLE),
(stableDebt > 0 &&
ReserveLogic.InterestRateMode(rateMode) == ReserveLogic.InterestRateMode.STABLE) ||
(variableDebt > 0 &&
ReserveLogic.InterestRateMode(rateMode) == ReserveLogic.InterestRateMode.VARIABLE),
'16'
);
require(
_amountSent != uint256(-1) || msg.sender == _onBehalfOf,
amountSent != uint256(-1) || msg.sender == onBehalfOf,
'To repay on behalf of an user an explicit amount to repay is needed'
);
}
/**
* @dev validates a swap of borrow rate mode.
* @param _reserve the reserve state on which the user is swapping the rate
* @param _userConfig the user reserves configuration
* @param _stableBorrowBalance the stable borrow balance of the user
* @param _variableBorrowBalance the stable borrow balance of the user
* @param _currentRateMode the rate mode of the borrow
* @param reserve the reserve state on which the user is swapping the rate
* @param userConfig the user reserves configuration
* @param stableBorrowBalance the stable borrow balance of the user
* @param variableBorrowBalance the stable borrow balance of the user
* @param currentRateMode the rate mode of the borrow
*/
function validateSwapRateMode(
ReserveLogic.ReserveData storage _reserve,
UserConfiguration.Map storage _userConfig,
uint256 _stableBorrowBalance,
uint256 _variableBorrowBalance,
ReserveLogic.InterestRateMode _currentRateMode
ReserveLogic.ReserveData storage reserve,
UserConfiguration.Map storage userConfig,
uint256 stableBorrowBalance,
uint256 variableBorrowBalance,
ReserveLogic.InterestRateMode currentRateMode
) external view {
(bool isActive, bool isFreezed, , bool stableRateEnabled) = _reserve.configuration.getFlags();
(bool isActive, bool isFreezed, , bool stableRateEnabled) = reserve.configuration.getFlags();
require(isActive, 'Action requires an active reserve');
require(!isFreezed, 'Action requires an unfreezed reserve');
if (_currentRateMode == ReserveLogic.InterestRateMode.STABLE) {
if (currentRateMode == ReserveLogic.InterestRateMode.STABLE) {
require(
_stableBorrowBalance > 0,
stableBorrowBalance > 0,
'User does not have a stable rate loan in progress on this reserve'
);
} else if (_currentRateMode == ReserveLogic.InterestRateMode.VARIABLE) {
} else if (currentRateMode == ReserveLogic.InterestRateMode.VARIABLE) {
require(
_variableBorrowBalance > 0,
variableBorrowBalance > 0,
'User does not have a variable rate loan in progress on this reserve'
);
/**
@ -292,10 +288,10 @@ library ValidationLogic {
require(stableRateEnabled, '11');
require(
!_userConfig.isUsingAsCollateral(_reserve.index) ||
_reserve.configuration.getLtv() == 0 ||
_stableBorrowBalance.add(_variableBorrowBalance) >
IERC20(_reserve.aTokenAddress).balanceOf(msg.sender),
!userConfig.isUsingAsCollateral(reserve.index) ||
reserve.configuration.getLtv() == 0 ||
stableBorrowBalance.add(variableBorrowBalance) >
IERC20(reserve.aTokenAddress).balanceOf(msg.sender),
'12'
);
} else {
@ -305,34 +301,34 @@ library ValidationLogic {
/**
* @dev validates the choice of a user of setting (or not) an asset as collateral
* @param _reserve the state of the reserve that the user is enabling or disabling as collateral
* @param _reserveAddress the address of the reserve
* @param _reservesData the data of all the reserves
* @param _userConfig the state of the user for the specific reserve
* @param _reserves the addresses of all the active reserves
* @param _oracle the price oracle
* @param reserve the state of the reserve that the user is enabling or disabling as collateral
* @param reserveAddress the address of the reserve
* @param reservesData the data of all the reserves
* @param userConfig the state of the user for the specific reserve
* @param reserves the addresses of all the active reserves
* @param oracle the price oracle
*/
function validateSetUseReserveAsCollateral(
ReserveLogic.ReserveData storage _reserve,
address _reserveAddress,
mapping(address => ReserveLogic.ReserveData) storage _reservesData,
UserConfiguration.Map storage _userConfig,
address[] calldata _reserves,
address _oracle
ReserveLogic.ReserveData storage reserve,
address reserveAddress,
mapping(address => ReserveLogic.ReserveData) storage reservesData,
UserConfiguration.Map storage userConfig,
address[] calldata reserves,
address oracle
) external view {
uint256 underlyingBalance = IERC20(_reserve.aTokenAddress).balanceOf(msg.sender);
uint256 underlyingBalance = IERC20(reserve.aTokenAddress).balanceOf(msg.sender);
require(underlyingBalance > 0, '22');
require(
GenericLogic.balanceDecreaseAllowed(
_reserveAddress,
reserveAddress,
msg.sender,
underlyingBalance,
_reservesData,
_userConfig,
_reserves,
_oracle
reservesData,
userConfig,
reserves,
oracle
),
'User deposit is already being used as collateral'
);

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

@ -12,22 +12,22 @@ library MathUtils {
/**
* @dev function to calculate the interest using a linear interest rate formula
* @param _rate the interest rate, in ray
* @param _lastUpdateTimestamp the timestamp of the last update of the interest
* @param rate the interest rate, in ray
* @param lastUpdateTimestamp the timestamp of the last update of the interest
* @return the interest rate linearly accumulated during the timeDelta, in ray
**/
function calculateLinearInterest(uint256 _rate, uint40 _lastUpdateTimestamp)
function calculateLinearInterest(uint256 rate, uint40 lastUpdateTimestamp)
internal
view
returns (uint256)
{
//solium-disable-next-line
uint256 timeDifference = block.timestamp.sub(uint256(_lastUpdateTimestamp));
uint256 timeDifference = block.timestamp.sub(uint256(lastUpdateTimestamp));
uint256 timeDelta = timeDifference.wadToRay().rayDiv(SECONDS_PER_YEAR.wadToRay());
return _rate.rayMul(timeDelta).add(WadRayMath.ray());
return rate.rayMul(timeDelta).add(WadRayMath.ray());
}
/**
@ -39,17 +39,17 @@ library MathUtils {
* The approximation slightly underpays liquidity providers, with the advantage of great gas cost reductions.
* The whitepaper contains reference to the approximation and a table showing the margin of error per different time periods.
*
* @param _rate the interest rate, in ray
* @param _lastUpdateTimestamp the timestamp of the last update of the interest
* @param rate the interest rate, in ray
* @param lastUpdateTimestamp the timestamp of the last update of the interest
* @return the interest rate compounded during the timeDelta, in ray
**/
function calculateCompoundedInterest(uint256 _rate, uint40 _lastUpdateTimestamp)
function calculateCompoundedInterest(uint256 rate, uint40 lastUpdateTimestamp)
internal
view
returns (uint256)
{
//solium-disable-next-line
uint256 exp = block.timestamp.sub(uint256(_lastUpdateTimestamp));
uint256 exp = block.timestamp.sub(uint256(lastUpdateTimestamp));
if (exp == 0) {
return WadRayMath.ray();
@ -59,7 +59,7 @@ library MathUtils {
uint256 expMinusTwo = exp > 2 ? exp.sub(2) : 0;
uint256 ratePerSecond = _rate.div(31536000);
uint256 ratePerSecond = rate.div(31536000);
uint256 basePowerTwo = ratePerSecond.rayMul(ratePerSecond);
uint256 basePowerThree = basePowerTwo.rayMul(ratePerSecond);

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

@ -19,23 +19,23 @@ library PercentageMath {
/**
* @dev executes a percentage multiplication
* @param _value the value of which the percentage needs to be calculated
* @param _percentage the percentage of the value to be calculated
* @return the _percentage of _value
* @param value the value of which the percentage needs to be calculated
* @param percentage the percentage of the value to be calculated
* @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);
function percentMul(uint256 value, uint256 percentage) internal pure returns (uint256) {
return HALF_PERCENT.add(value.mul(percentage)).div(PERCENTAGE_FACTOR);
}
/**
* @dev executes a percentage division
* @param _value the value of which the percentage needs to be calculated
* @param _percentage the percentage of the value to be calculated
* @return the _value divided the _percentage
* @param value the value of which the percentage needs to be calculated
* @param percentage the percentage of the value to be calculated
* @return the value divided the percentage
**/
function percentDiv(uint256 _value, uint256 _percentage) internal pure returns (uint256) {
uint256 halfPercentage = _percentage / 2;
function percentDiv(uint256 value, uint256 percentage) internal pure returns (uint256) {
uint256 halfPercentage = percentage / 2;
return halfPercentage.add(_value.mul(PERCENTAGE_FACTOR)).div(_percentage);
return halfPercentage.add(value.mul(PERCENTAGE_FACTOR)).div(percentage);
}
}

16
contracts/libraries/openzeppelin-upgradeability/InitializableAdminUpgradeabilityProxy.sol
View File

@ -15,22 +15,22 @@ contract InitializableAdminUpgradeabilityProxy is
{
/**
* Contract initializer.
* @param _logic address of the initial implementation.
* @param _admin Address of the proxy administrator.
* @param _data Data to send as msg.data to the implementation to initialize the proxied contract.
* @param logic address of the initial implementation.
* @param admin Address of the proxy administrator.
* @param data Data to send as msg.data to the implementation to initialize the proxied contract.
* It should include the signature and the parameters of the function to be called, as described in
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
* This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
*/
function initialize(
address _logic,
address _admin,
bytes memory _data
address logic,
address admin,
bytes memory data
) public payable {
require(_implementation() == address(0));
InitializableUpgradeabilityProxy.initialize(_logic, _data);
InitializableUpgradeabilityProxy.initialize(logic, data);
assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1));
_setAdmin(_admin);
_setAdmin(admin);
}
/**

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

@ -51,7 +51,7 @@ contract MockFlashLoanReceiver is FlashLoanReceiverBase {
token.mint(_fee);
//returning amount + fee to the destination
transferFundsBackInternal(_reserve, _destination, _amount.add(_fee));
_transferFundsBack(_reserve, _destination, _amount.add(_fee));
emit ExecutedWithSuccess(_reserve, _amount, _fee);
}

58
contracts/tokenization/AToken.sol
View File

@ -76,7 +76,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
address to,
uint256 amount
) internal override whenTransferAllowed(from, amount) {
executeTransferInternal(from, to, amount);
_executeTransfer(from, to, amount);
}
/**
@ -86,7 +86,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
* @param to the address to which the interest will be redirected
**/
function redirectInterestStream(address to) external override {
redirectInterestStreamInternal(msg.sender, to);
_redirectInterestStream(msg.sender, to);
}
/**
@ -102,7 +102,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
msg.sender == _interestRedirectionAllowances[from],
'Caller is not allowed to redirect the interest of the user'
);
redirectInterestStreamInternal(from, to);
_redirectInterestStream(from, to);
}
/**
@ -128,12 +128,12 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
uint256 amount
) external override onlyLendingPool {
//cumulates the balance of the user
(, uint256 currentBalance, uint256 balanceIncrease) = calculateBalanceIncreaseInternal(user);
(, uint256 currentBalance, uint256 balanceIncrease) = _calculateBalanceIncrease(user);
//if the user is redirecting his interest towards someone else,
//we update the redirected balance of the redirection address by adding the accrued interest,
//and removing the amount to redeem
updateRedirectedBalanceOfRedirectionAddressInternal(user, balanceIncrease, amount);
_updateRedirectedBalanceOfRedirectionAddress(user, balanceIncrease, amount);
if (balanceIncrease > amount) {
_mint(user, balanceIncrease.sub(amount));
@ -145,7 +145,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
//reset the user data if the remaining balance is 0
if (currentBalance.sub(amount) == 0) {
resetDataOnZeroBalanceInternal(user);
_resetDataOnZeroBalance(user);
} else {
//updates the user index
userIndex = _userIndexes[user] = _pool.getReserveNormalizedIncome(UNDERLYING_ASSET_ADDRESS);
@ -165,7 +165,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
*/
function mint(address user, uint256 amount) external override onlyLendingPool {
//cumulates the balance of the user
(, , uint256 balanceIncrease) = calculateBalanceIncreaseInternal(user);
(, , uint256 balanceIncrease) = _calculateBalanceIncrease(user);
//updates the user index
uint256 index = _userIndexes[user] = _pool.getReserveNormalizedIncome(UNDERLYING_ASSET_ADDRESS);
@ -173,7 +173,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
//if the user is redirecting his interest towards someone else,
//we update the redirected balance of the redirection address by adding the accrued interest
//and the amount deposited
updateRedirectedBalanceOfRedirectionAddressInternal(user, balanceIncrease.add(amount), 0);
_updateRedirectedBalanceOfRedirectionAddress(user, balanceIncrease.add(amount), 0);
//mint an equivalent amount of tokens to cover the new deposit
_mint(user, amount.add(balanceIncrease));
@ -195,7 +195,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
) external override onlyLendingPool {
//being a normal transfer, the Transfer() and BalanceTransfer() are emitted
//so no need to emit a specific event here
executeTransferInternal(from, to, value);
_executeTransfer(from, to, value);
}
/**
@ -220,7 +220,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
//accruing for himself means that both the principal balance and
//the redirected balance partecipate in the interest
return
calculateCumulatedBalanceInternal(user, currentPrincipalBalance.add(redirectedBalance)).sub(
_calculateCumulatedBalance(user, currentPrincipalBalance.add(redirectedBalance)).sub(
redirectedBalance
);
} else {
@ -229,7 +229,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
//by the redirected balance is added to the current principal balance.
return
currentPrincipalBalance.add(
calculateCumulatedBalanceInternal(user, redirectedBalance).sub(redirectedBalance)
_calculateCumulatedBalance(user, redirectedBalance).sub(redirectedBalance)
);
}
}
@ -307,7 +307,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
* @param user the address of the user
* @return the last user principal balance, the current balance and the balance increase
**/
function calculateBalanceIncreaseInternal(address user)
function _calculateBalanceIncrease(address user)
internal
view
returns (
@ -335,7 +335,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
* @return the previous principal balance, the new principal balance, the balance increase
* and the new user index
**/
function cumulateBalanceInternal(address user)
function _cumulateBalance(address user)
internal
returns (
uint256,
@ -348,7 +348,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
uint256 previousBalance,
uint256 currentBalance,
uint256 balanceIncrease
) = calculateBalanceIncreaseInternal(user);
) = _calculateBalanceIncrease(user);
_mint(user, balanceIncrease);
@ -365,7 +365,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
* @param balanceToAdd the amount to add to the redirected balance
* @param balanceToRemove the amount to remove from the redirected balance
**/
function updateRedirectedBalanceOfRedirectionAddressInternal(
function _updateRedirectedBalanceOfRedirectionAddress(
address user,
uint256 balanceToAdd,
uint256 balanceToRemove
@ -377,7 +377,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
}
//compound balances of the redirected address
(, , uint256 balanceIncrease, uint256 index) = cumulateBalanceInternal(redirectionAddress);
(, , uint256 balanceIncrease, uint256 index) = _cumulateBalance(redirectionAddress);
//updating the redirected balance
_redirectedBalances[redirectionAddress] = _redirectedBalances[redirectionAddress]
@ -391,7 +391,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
// if the redirection address is also redirecting the interest, we accumulate his balance
// and update his chain of redirection
if (targetOfRedirectionAddress != address(0)) {
updateRedirectedBalanceOfRedirectionAddressInternal(redirectionAddress, balanceIncrease, 0);
_updateRedirectedBalanceOfRedirectionAddress(redirectionAddress, balanceIncrease, 0);
}
emit RedirectedBalanceUpdated(
@ -409,7 +409,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
* @param balance the balance on which the interest is calculated
* @return the interest rate accrued
**/
function calculateCumulatedBalanceInternal(address user, uint256 balance)
function _calculateCumulatedBalance(address user, uint256 balance)
internal
view
returns (uint256)
@ -429,7 +429,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
* @param to the destination address
* @param value the amount to transfer
**/
function executeTransferInternal(
function _executeTransfer(
address from,
address to,
uint256 value
@ -442,20 +442,20 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
uint256 fromBalance,
uint256 fromBalanceIncrease,
uint256 fromIndex
) = cumulateBalanceInternal(from);
) = _cumulateBalance(from);
//cumulate the balance of the receiver
(, , uint256 toBalanceIncrease, uint256 toIndex) = cumulateBalanceInternal(to);
(, , uint256 toBalanceIncrease, uint256 toIndex) = _cumulateBalance(to);
//if the sender is redirecting his interest towards someone else,
//adds to the redirected balance the accrued interest and removes the amount
//being transferred
updateRedirectedBalanceOfRedirectionAddressInternal(from, fromBalanceIncrease, value);
_updateRedirectedBalanceOfRedirectionAddress(from, fromBalanceIncrease, value);
//if the receiver is redirecting his interest towards someone else,
//adds to the redirected balance the accrued interest and the amount
//being transferred
updateRedirectedBalanceOfRedirectionAddressInternal(to, toBalanceIncrease.add(value), 0);
_updateRedirectedBalanceOfRedirectionAddress(to, toBalanceIncrease.add(value), 0);
//performs the transfer
super._transfer(from, to, value);
@ -463,7 +463,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
bool fromIndexReset = false;
//reset the user data if the remaining balance is 0
if (fromBalance.sub(value) == 0 && from != to) {
fromIndexReset = resetDataOnZeroBalanceInternal(from);
fromIndexReset = _resetDataOnZeroBalance(from);
}
emit BalanceTransfer(
@ -483,7 +483,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
* @param from the address from which transfer the aTokens
* @param to the destination address
**/
function redirectInterestStreamInternal(address from, address to) internal {
function _redirectInterestStream(address from, address to) internal {
address currentRedirectionAddress = _interestRedirectionAddresses[from];
require(to != currentRedirectionAddress, 'Interest is already redirected to the user');
@ -494,7 +494,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
uint256 fromBalance,
uint256 balanceIncrease,
uint256 fromIndex
) = cumulateBalanceInternal(from);
) = _cumulateBalance(from);
require(fromBalance > 0, 'Interest stream can only be redirected if there is a valid balance');
@ -502,7 +502,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
//the redirection address we substract the redirected balance of the previous
//recipient
if (currentRedirectionAddress != address(0)) {
updateRedirectedBalanceOfRedirectionAddressInternal(from, 0, previousPrincipalBalance);
_updateRedirectedBalanceOfRedirectionAddress(from, 0, previousPrincipalBalance);
}
//if the user is redirecting the interest back to himself,
@ -517,7 +517,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
_interestRedirectionAddresses[from] = to;
//adds the user balance to the redirected balance of the destination
updateRedirectedBalanceOfRedirectionAddressInternal(from, fromBalance, 0);
_updateRedirectedBalanceOfRedirectionAddress(from, fromBalance, 0);
emit InterestStreamRedirected(from, to, fromBalance, balanceIncrease, fromIndex);
}
@ -528,7 +528,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
* @param user the address of the user
* @return true if the user index has also been reset, false otherwise. useful to emit the proper user index value
**/
function resetDataOnZeroBalanceInternal(address user) internal returns (bool) {
function _resetDataOnZeroBalance(address user) internal returns (bool) {
//if the user has 0 principal balance, the interest stream redirection gets reset
_interestRedirectionAddresses[user] = address(0);

0
tests.log
View File

2638
tsts.log
View File

File diff suppressed because it is too large Load Diff