From 6cdfd8e31b6f14e721f87ccdf6e427f696b32725 Mon Sep 17 00:00:00 2001 From: The3D Date: Thu, 3 Jun 2021 14:10:50 +0200 Subject: [PATCH 01/13] feat: initial cache layer implementation --- .../protocol/lendingpool/LendingPool.sol | 61 ++++++++++------- .../LendingPoolCollateralManager.sol | 9 ++- .../libraries/helpers/CachingHelper.sol | 59 ++++++++++++++++ .../protocol/libraries/logic/ReserveLogic.sol | 67 +++++++------------ 4 files changed, 127 insertions(+), 69 deletions(-) create mode 100644 contracts/protocol/libraries/helpers/CachingHelper.sol diff --git a/contracts/protocol/lendingpool/LendingPool.sol b/contracts/protocol/lendingpool/LendingPool.sol index 0ea6f302..0c4ea068 100644 --- a/contracts/protocol/lendingpool/LendingPool.sol +++ b/contracts/protocol/lendingpool/LendingPool.sol @@ -26,6 +26,7 @@ import {ReserveConfiguration} from '../libraries/configuration/ReserveConfigurat import {UserConfiguration} from '../libraries/configuration/UserConfiguration.sol'; import {DataTypes} from '../libraries/types/DataTypes.sol'; import {LendingPoolStorage} from './LendingPoolStorage.sol'; +import {CachingHelper} from '../libraries/helpers/CachingHelper.sol'; /** * @title LendingPool contract @@ -270,6 +271,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage **/ function swapBorrowRateMode(address asset, uint256 rateMode) external override whenNotPaused { DataTypes.ReserveData storage reserve = _reserves[asset]; + CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); (uint256 stableDebt, uint256 variableDebt) = Helpers.getUserCurrentDebt(msg.sender, reserve); @@ -283,7 +285,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage interestRateMode ); - reserve.updateState(); + reserve.updateState(cachedData); if (interestRateMode == DataTypes.InterestRateMode.STABLE) { IStableDebtToken(reserve.stableDebtTokenAddress).burn(msg.sender, stableDebt); @@ -323,6 +325,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage **/ function rebalanceStableBorrowRate(address asset, address user) external override whenNotPaused { DataTypes.ReserveData storage reserve = _reserves[asset]; + CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); IERC20 stableDebtToken = IERC20(reserve.stableDebtTokenAddress); IERC20 variableDebtToken = IERC20(reserve.variableDebtTokenAddress); @@ -338,7 +341,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage aTokenAddress ); - reserve.updateState(); + reserve.updateState(cachedData); IStableDebtToken(address(stableDebtToken)).burn(user, stableDebt); IStableDebtToken(address(stableDebtToken)).mint( @@ -435,6 +438,8 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage uint256 currentPremium; uint256 currentAmountPlusPremium; address debtToken; + address[] aTokenAddresses; + uint256[] premiums; } /** @@ -465,40 +470,44 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage ) external override whenNotPaused { FlashLoanLocalVars memory vars; + vars.aTokenAddresses = new address[](assets.length); + vars.premiums = new uint256[](assets.length); + ValidationLogic.validateFlashloan(assets, amounts, _reserves); - address[] memory aTokenAddresses = new address[](assets.length); - uint256[] memory premiums = new uint256[](assets.length); vars.receiver = IFlashLoanReceiver(receiverAddress); for (vars.i = 0; vars.i < assets.length; vars.i++) { - aTokenAddresses[vars.i] = _reserves[assets[vars.i]].aTokenAddress; + vars.aTokenAddresses[vars.i] = _reserves[assets[vars.i]].aTokenAddress; - premiums[vars.i] = amounts[vars.i].mul(_flashLoanPremiumTotal).div(10000); + vars.premiums[vars.i] = amounts[vars.i].mul(_flashLoanPremiumTotal).div(10000); - IAToken(aTokenAddresses[vars.i]).transferUnderlyingTo(receiverAddress, amounts[vars.i]); + IAToken(vars.aTokenAddresses[vars.i]).transferUnderlyingTo(receiverAddress, amounts[vars.i]); } require( - vars.receiver.executeOperation(assets, amounts, premiums, msg.sender, params), + vars.receiver.executeOperation(assets, amounts, vars.premiums, msg.sender, params), Errors.LP_INVALID_FLASH_LOAN_EXECUTOR_RETURN ); for (vars.i = 0; vars.i < assets.length; vars.i++) { vars.currentAsset = assets[vars.i]; vars.currentAmount = amounts[vars.i]; - vars.currentPremium = premiums[vars.i]; - vars.currentATokenAddress = aTokenAddresses[vars.i]; + vars.currentPremium = vars.premiums[vars.i]; + vars.currentATokenAddress = vars.aTokenAddresses[vars.i]; vars.currentAmountPlusPremium = vars.currentAmount.add(vars.currentPremium); if (DataTypes.InterestRateMode(modes[vars.i]) == DataTypes.InterestRateMode.NONE) { - _reserves[vars.currentAsset].updateState(); - _reserves[vars.currentAsset].cumulateToLiquidityIndex( + DataTypes.ReserveData storage reserve = _reserves[vars.currentAsset]; + CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); + + reserve.updateState(cachedData); + reserve.cumulateToLiquidityIndex( IERC20(vars.currentATokenAddress).totalSupply(), vars.currentPremium ); - _reserves[vars.currentAsset].updateInterestRates( + reserve.updateInterestRates( vars.currentAsset, vars.currentATokenAddress, vars.currentAmountPlusPremium, @@ -863,6 +872,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage function _executeBorrow(ExecuteBorrowParams memory vars) internal { DataTypes.ReserveData storage reserve = _reserves[vars.asset]; DataTypes.UserConfigurationMap storage userConfig = _usersConfig[vars.onBehalfOf]; + CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); address oracle = _addressesProvider.getPriceOracle(); @@ -886,7 +896,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage oracle ); - reserve.updateState(); + reserve.updateState(cachedData); uint256 currentStableRate = 0; @@ -944,17 +954,16 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage uint16 referralCode ) internal { DataTypes.ReserveData storage reserve = _reserves[asset]; + CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); ValidationLogic.validateDeposit(reserve, amount); - address aToken = reserve.aTokenAddress; + reserve.updateState(cachedData); + reserve.updateInterestRates(asset, cachedData.aTokenAddress, amount, 0); - reserve.updateState(); - reserve.updateInterestRates(asset, aToken, amount, 0); + IERC20(asset).safeTransferFrom(msg.sender, cachedData.aTokenAddress, amount); - IERC20(asset).safeTransferFrom(msg.sender, aToken, amount); - - bool isFirstDeposit = IAToken(aToken).mint(onBehalfOf, amount, reserve.liquidityIndex); + bool isFirstDeposit = IAToken(cachedData.aTokenAddress).mint(onBehalfOf, amount, cachedData.newLiquidityIndex); if (isFirstDeposit) { _usersConfig[onBehalfOf].setUsingAsCollateral(reserve.id, true); @@ -971,14 +980,13 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage ) internal returns (uint256) { DataTypes.ReserveData storage reserve = _reserves[asset]; DataTypes.UserConfigurationMap storage userConfig = _usersConfig[msg.sender]; + CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); address aToken = reserve.aTokenAddress; - reserve.updateState(); + reserve.updateState(cachedData); - uint256 liquidityIndex = reserve.liquidityIndex; - - uint256 userBalance = IAToken(aToken).scaledBalanceOf(msg.sender).rayMul(liquidityIndex); + uint256 userBalance = IAToken(aToken).scaledBalanceOf(msg.sender).rayMul(cachedData.newLiquidityIndex); uint256 amountToWithdraw = amount; @@ -990,7 +998,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage reserve.updateInterestRates(asset, aToken, 0, amountToWithdraw); - IAToken(aToken).burn(msg.sender, to, amountToWithdraw, liquidityIndex); + IAToken(aToken).burn(msg.sender, to, amountToWithdraw, cachedData.newLiquidityIndex); if (userConfig.isUsingAsCollateral(reserve.id)) { if (userConfig.isBorrowingAny()) { @@ -1022,6 +1030,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage address onBehalfOf ) internal returns (uint256) { DataTypes.ReserveData storage reserve = _reserves[asset]; + CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); (uint256 stableDebt, uint256 variableDebt) = Helpers.getUserCurrentDebt(onBehalfOf, reserve); @@ -1043,7 +1052,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage paybackAmount = amount; } - reserve.updateState(); + reserve.updateState(cachedData); if (interestRateMode == DataTypes.InterestRateMode.STABLE) { IStableDebtToken(reserve.stableDebtTokenAddress).burn(onBehalfOf, paybackAmount); diff --git a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol index 80692726..5e6722b2 100644 --- a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol +++ b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol @@ -18,6 +18,7 @@ import {Errors} from '../libraries/helpers/Errors.sol'; import {ValidationLogic} from '../libraries/logic/ValidationLogic.sol'; import {DataTypes} from '../libraries/types/DataTypes.sol'; import {LendingPoolStorage} from './LendingPoolStorage.sol'; +import {CachingHelper} from '../libraries/helpers/CachingHelper.sol'; /** * @title LendingPoolCollateralManager contract @@ -160,7 +161,9 @@ contract LendingPoolCollateralManager is } } - debtReserve.updateState(); + CachingHelper.CachedData memory debtReserveCachedData = CachingHelper.fetchData(debtReserve); + + debtReserve.updateState(debtReserveCachedData); if (vars.userVariableDebt >= vars.actualDebtToLiquidate) { IVariableDebtToken(debtReserve.variableDebtTokenAddress).burn( @@ -200,7 +203,9 @@ contract LendingPoolCollateralManager is emit ReserveUsedAsCollateralEnabled(collateralAsset, msg.sender); } } else { - collateralReserve.updateState(); + CachingHelper.CachedData memory collateralReserveCachedData = CachingHelper.fetchData(collateralReserve); + + collateralReserve.updateState(collateralReserveCachedData); collateralReserve.updateInterestRates( collateralAsset, address(vars.collateralAtoken), diff --git a/contracts/protocol/libraries/helpers/CachingHelper.sol b/contracts/protocol/libraries/helpers/CachingHelper.sol new file mode 100644 index 00000000..bbfd959c --- /dev/null +++ b/contracts/protocol/libraries/helpers/CachingHelper.sol @@ -0,0 +1,59 @@ +pragma solidity 0.6.12; + +pragma experimental ABIEncoderV2; + +import {DataTypes} from '../types/DataTypes.sol'; +import {IVariableDebtToken} from '../../../interfaces/IVariableDebtToken.sol'; + +library CachingHelper { + struct CachedData { + uint256 oldScaledVariableDebt; + uint256 oldTotalVariableDebt; + uint256 newSscaledVariableDebt; + uint256 newTtotalVariableDebt; + uint256 oldPrincipalStableDebt; + uint256 oldAvgStableBorrowRate; + uint256 oldTotalStableDebt; + uint256 newPrincipalStableDebt; + uint256 newAvgStableBorrowRate; + uint256 newTotalStableDebt; + uint256 oldLiquidityIndex; + uint256 newLiquidityIndex; + uint256 oldVariableBorrowIndex; + uint256 newVariableBorrowIndex; + uint256 oldLiquidityRate; + uint256 oldVariableBorrowRate; + DataTypes.ReserveConfigurationMap reserveConfiguration; + address aTokenAddress; + address stableDebtTokenAddress; + address variableDebtTokenAddress; + uint40 reserveLastUpdateTimestamp; + } + + function fetchData(DataTypes.ReserveData storage reserveData) + internal + view + returns (CachingHelper.CachedData memory) + { + CachedData memory cachedData; + + cachedData.oldLiquidityIndex = reserveData.liquidityIndex; + cachedData.oldVariableBorrowIndex = reserveData.variableBorrowIndex; + + cachedData.aTokenAddress = reserveData.aTokenAddress; + cachedData.stableDebtTokenAddress = reserveData.stableDebtTokenAddress; + cachedData.variableDebtTokenAddress = reserveData.variableDebtTokenAddress; + + cachedData.reserveConfiguration = reserveData.configuration; + + cachedData.oldLiquidityRate = reserveData.currentLiquidityRate; + cachedData.oldVariableBorrowRate = reserveData.currentVariableBorrowRate; + + cachedData.reserveLastUpdateTimestamp = reserveData.lastUpdateTimestamp; + + cachedData.oldScaledVariableDebt = IVariableDebtToken(cachedData.variableDebtTokenAddress) + .scaledTotalSupply(); + + return cachedData; + } +} diff --git a/contracts/protocol/libraries/logic/ReserveLogic.sol b/contracts/protocol/libraries/logic/ReserveLogic.sol index 2e9850c9..33ba2aaf 100644 --- a/contracts/protocol/libraries/logic/ReserveLogic.sol +++ b/contracts/protocol/libraries/logic/ReserveLogic.sol @@ -14,6 +14,7 @@ import {WadRayMath} from '../math/WadRayMath.sol'; import {PercentageMath} from '../math/PercentageMath.sol'; import {Errors} from '../helpers/Errors.sol'; import {DataTypes} from '../types/DataTypes.sol'; +import {CachingHelper} from '../helpers/CachingHelper.sol'; /** * @title ReserveLogic library @@ -107,29 +108,22 @@ library ReserveLogic { * @dev Updates the liquidity cumulative index and the variable borrow index. * @param reserve the reserve object **/ - function updateState(DataTypes.ReserveData storage reserve) internal { - uint256 scaledVariableDebt = - IVariableDebtToken(reserve.variableDebtTokenAddress).scaledTotalSupply(); - uint256 previousVariableBorrowIndex = reserve.variableBorrowIndex; - uint256 previousLiquidityIndex = reserve.liquidityIndex; - uint40 lastUpdatedTimestamp = reserve.lastUpdateTimestamp; + function updateState(DataTypes.ReserveData storage reserve, CachingHelper.CachedData memory cachedData) internal { - (uint256 newLiquidityIndex, uint256 newVariableBorrowIndex) = _updateIndexes( reserve, - scaledVariableDebt, - previousLiquidityIndex, - previousVariableBorrowIndex, - lastUpdatedTimestamp + cachedData ); + + _accrueToTreasury( reserve, - scaledVariableDebt, - previousVariableBorrowIndex, - newLiquidityIndex, - newVariableBorrowIndex, - lastUpdatedTimestamp + cachedData.oldScaledVariableDebt, + cachedData.oldVariableBorrowIndex, + cachedData.newLiquidityIndex, + cachedData.newVariableBorrowIndex, + cachedData.reserveLastUpdateTimestamp ); } @@ -209,9 +203,7 @@ library ReserveLogic { (vars.totalStableDebt, vars.avgStableRate) = IStableDebtToken(vars.stableDebtTokenAddress) .getTotalSupplyAndAvgRate(); - //calculates the total variable debt locally using the scaled total supply instead - //of totalSupply(), as it's noticeably cheaper. Also, the index has been - //updated by the previous updateState() call + vars.totalVariableDebt = IVariableDebtToken(reserve.variableDebtTokenAddress) .scaledTotalSupply() .rayMul(reserve.variableBorrowIndex); @@ -327,47 +319,40 @@ library ReserveLogic { /** * @dev Updates the reserve indexes and the timestamp of the update * @param reserve The reserve reserve to be updated - * @param scaledVariableDebt The scaled variable debt - * @param liquidityIndex The last stored liquidity index - * @param variableBorrowIndex The last stored variable borrow index + * @param cachedData The cache layer holding the cached protocol data **/ function _updateIndexes( DataTypes.ReserveData storage reserve, - uint256 scaledVariableDebt, - uint256 liquidityIndex, - uint256 variableBorrowIndex, - uint40 timestamp - ) internal returns (uint256, uint256) { - uint256 currentLiquidityRate = reserve.currentLiquidityRate; + CachingHelper.CachedData memory cachedData + ) internal { - uint256 newLiquidityIndex = liquidityIndex; - uint256 newVariableBorrowIndex = variableBorrowIndex; + cachedData.newLiquidityIndex = cachedData.oldLiquidityIndex; + cachedData.newVariableBorrowIndex = cachedData.oldVariableBorrowIndex; //only cumulating if there is any income being produced - if (currentLiquidityRate > 0) { + if (cachedData.oldLiquidityRate > 0) { uint256 cumulatedLiquidityInterest = - MathUtils.calculateLinearInterest(currentLiquidityRate, timestamp); - newLiquidityIndex = cumulatedLiquidityInterest.rayMul(liquidityIndex); - require(newLiquidityIndex <= type(uint128).max, Errors.RL_LIQUIDITY_INDEX_OVERFLOW); + MathUtils.calculateLinearInterest(cachedData.oldLiquidityRate, cachedData.reserveLastUpdateTimestamp); + cachedData.newLiquidityIndex = cumulatedLiquidityInterest.rayMul(cachedData.oldLiquidityIndex); + require( cachedData.newLiquidityIndex <= type(uint128).max, Errors.RL_LIQUIDITY_INDEX_OVERFLOW); - reserve.liquidityIndex = uint128(newLiquidityIndex); + reserve.liquidityIndex = uint128(cachedData.newLiquidityIndex); //as the liquidity rate might come only from stable rate loans, we need to ensure //that there is actual variable debt before accumulating - if (scaledVariableDebt != 0) { + if (cachedData.oldScaledVariableDebt != 0) { uint256 cumulatedVariableBorrowInterest = - MathUtils.calculateCompoundedInterest(reserve.currentVariableBorrowRate, timestamp); - newVariableBorrowIndex = cumulatedVariableBorrowInterest.rayMul(variableBorrowIndex); + MathUtils.calculateCompoundedInterest(cachedData.oldVariableBorrowRate, cachedData.reserveLastUpdateTimestamp); + cachedData.newVariableBorrowIndex = cumulatedVariableBorrowInterest.rayMul(cachedData.oldVariableBorrowIndex); require( - newVariableBorrowIndex <= type(uint128).max, + cachedData.newVariableBorrowIndex <= type(uint128).max, Errors.RL_VARIABLE_BORROW_INDEX_OVERFLOW ); - reserve.variableBorrowIndex = uint128(newVariableBorrowIndex); + reserve.variableBorrowIndex = uint128(cachedData.newVariableBorrowIndex); } } //solium-disable-next-line reserve.lastUpdateTimestamp = uint40(block.timestamp); - return (newLiquidityIndex, newVariableBorrowIndex); } } From 360e83fd05598d4b3ed1683d6135b31e14b43c94 Mon Sep 17 00:00:00 2001 From: The3D Date: Thu, 3 Jun 2021 21:28:21 +0200 Subject: [PATCH 02/13] refactor: further refactored the cache layer and replaced reads/calls --- .../protocol/lendingpool/LendingPool.sol | 125 +++++++++++------- .../LendingPoolCollateralManager.sol | 26 +++- .../configuration/ReserveConfiguration.sol | 37 ++++++ .../libraries/helpers/CachingHelper.sol | 24 +++- .../protocol/libraries/logic/ReserveLogic.sol | 112 ++++++++-------- .../libraries/logic/ValidationLogic.sol | 76 ++++++----- 6 files changed, 250 insertions(+), 150 deletions(-) diff --git a/contracts/protocol/lendingpool/LendingPool.sol b/contracts/protocol/lendingpool/LendingPool.sol index 0c4ea068..06bfeb8e 100644 --- a/contracts/protocol/lendingpool/LendingPool.sol +++ b/contracts/protocol/lendingpool/LendingPool.sol @@ -288,28 +288,44 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage reserve.updateState(cachedData); if (interestRateMode == DataTypes.InterestRateMode.STABLE) { - IStableDebtToken(reserve.stableDebtTokenAddress).burn(msg.sender, stableDebt); - IVariableDebtToken(reserve.variableDebtTokenAddress).mint( + IStableDebtToken(cachedData.stableDebtTokenAddress).burn(msg.sender, stableDebt); + + cachedData.newPrincipalStableDebt = cachedData.newTotalStableDebt = cachedData + .oldTotalStableDebt + .sub(stableDebt); + + IVariableDebtToken(cachedData.variableDebtTokenAddress).mint( msg.sender, msg.sender, stableDebt, - reserve.variableBorrowIndex + cachedData.newVariableBorrowIndex + ); + cachedData.newScaledVariableDebt = cachedData.oldScaledVariableDebt.add( + stableDebt.rayDiv(cachedData.newVariableBorrowIndex) ); } else { - IVariableDebtToken(reserve.variableDebtTokenAddress).burn( + IVariableDebtToken(cachedData.variableDebtTokenAddress).burn( msg.sender, variableDebt, - reserve.variableBorrowIndex + cachedData.newVariableBorrowIndex ); - IStableDebtToken(reserve.stableDebtTokenAddress).mint( + cachedData.newScaledVariableDebt = cachedData.oldScaledVariableDebt.sub( + variableDebt.rayDiv(cachedData.newVariableBorrowIndex) + ); + + IStableDebtToken(cachedData.stableDebtTokenAddress).mint( msg.sender, msg.sender, variableDebt, reserve.currentStableBorrowRate ); + + cachedData.newPrincipalStableDebt = cachedData.newTotalStableDebt = cachedData + .oldTotalStableDebt + .add(stableDebt); } - reserve.updateInterestRates(asset, reserve.aTokenAddress, 0, 0); + reserve.updateInterestRates(cachedData, asset, 0, 0); emit Swap(asset, msg.sender, rateMode); } @@ -327,10 +343,8 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage DataTypes.ReserveData storage reserve = _reserves[asset]; CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); - IERC20 stableDebtToken = IERC20(reserve.stableDebtTokenAddress); - IERC20 variableDebtToken = IERC20(reserve.variableDebtTokenAddress); - address aTokenAddress = reserve.aTokenAddress; - + IERC20 stableDebtToken = IERC20(cachedData.stableDebtTokenAddress); + IERC20 variableDebtToken = IERC20(cachedData.variableDebtTokenAddress); uint256 stableDebt = IERC20(stableDebtToken).balanceOf(user); ValidationLogic.validateRebalanceStableBorrowRate( @@ -338,7 +352,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage asset, stableDebtToken, variableDebtToken, - aTokenAddress + cachedData.aTokenAddress ); reserve.updateState(cachedData); @@ -351,7 +365,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage reserve.currentStableBorrowRate ); - reserve.updateInterestRates(asset, aTokenAddress, 0, 0); + reserve.updateInterestRates(cachedData, asset, 0, 0); emit RebalanceStableBorrowRate(asset, user); } @@ -475,7 +489,6 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage ValidationLogic.validateFlashloan(assets, amounts, _reserves); - vars.receiver = IFlashLoanReceiver(receiverAddress); for (vars.i = 0; vars.i < assets.length; vars.i++) { @@ -508,8 +521,8 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage vars.currentPremium ); reserve.updateInterestRates( + cachedData, vars.currentAsset, - vars.currentATokenAddress, vars.currentAmountPlusPremium, 0 ); @@ -553,11 +566,11 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage function mintToTreasury(address[] calldata reserves) public { for (uint256 i = 0; i < reserves.length; i++) { address reserveAddress = reserves[i]; - + DataTypes.ReserveData storage reserve = _reserves[reserveAddress]; // this cover both inactive reserves and invalid reserves since the flag will be 0 for both - if(!reserve.configuration.getActive()){ + if (!reserve.configuration.getActive()) { continue; } @@ -874,48 +887,49 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage DataTypes.UserConfigurationMap storage userConfig = _usersConfig[vars.onBehalfOf]; CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); - address oracle = _addressesProvider.getPriceOracle(); - - uint256 amountInETH = - IPriceOracleGetter(oracle).getAssetPrice(vars.asset).mul(vars.amount).div( - 10**reserve.configuration.getDecimals() - ); + reserve.updateState(cachedData); ValidationLogic.validateBorrow( + cachedData, vars.asset, - reserve, vars.onBehalfOf, vars.amount, - amountInETH, vars.interestRateMode, _maxStableRateBorrowSizePercent, _reserves, userConfig, _reservesList, _reservesCount, - oracle + _addressesProvider.getPriceOracle() ); - reserve.updateState(cachedData); - uint256 currentStableRate = 0; bool isFirstBorrowing = false; if (DataTypes.InterestRateMode(vars.interestRateMode) == DataTypes.InterestRateMode.STABLE) { currentStableRate = reserve.currentStableBorrowRate; - isFirstBorrowing = IStableDebtToken(reserve.stableDebtTokenAddress).mint( + isFirstBorrowing = IStableDebtToken(cachedData.stableDebtTokenAddress).mint( vars.user, vars.onBehalfOf, vars.amount, currentStableRate ); + + cachedData.newPrincipalStableDebt = cachedData.newTotalStableDebt = cachedData + .oldTotalStableDebt + .add(vars.amount); + } else { - isFirstBorrowing = IVariableDebtToken(reserve.variableDebtTokenAddress).mint( + isFirstBorrowing = IVariableDebtToken(cachedData.variableDebtTokenAddress).mint( vars.user, vars.onBehalfOf, vars.amount, - reserve.variableBorrowIndex + cachedData.newVariableBorrowIndex + ); + + cachedData.newScaledVariableDebt = cachedData.newScaledVariableDebt.add( + vars.amount.rayDiv(cachedData.newVariableBorrowIndex) ); } @@ -924,14 +938,14 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage } reserve.updateInterestRates( + cachedData, vars.asset, - vars.aTokenAddress, 0, vars.releaseUnderlying ? vars.amount : 0 ); if (vars.releaseUnderlying) { - IAToken(vars.aTokenAddress).transferUnderlyingTo(vars.user, vars.amount); + IAToken(cachedData.aTokenAddress).transferUnderlyingTo(vars.user, vars.amount); } emit Borrow( @@ -956,14 +970,16 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage DataTypes.ReserveData storage reserve = _reserves[asset]; CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); - ValidationLogic.validateDeposit(reserve, amount); - reserve.updateState(cachedData); - reserve.updateInterestRates(asset, cachedData.aTokenAddress, amount, 0); + + ValidationLogic.validateDeposit(reserve, cachedData, amount); + + reserve.updateInterestRates(cachedData, asset, amount, 0); IERC20(asset).safeTransferFrom(msg.sender, cachedData.aTokenAddress, amount); - bool isFirstDeposit = IAToken(cachedData.aTokenAddress).mint(onBehalfOf, amount, cachedData.newLiquidityIndex); + bool isFirstDeposit = + IAToken(cachedData.aTokenAddress).mint(onBehalfOf, amount, cachedData.newLiquidityIndex); if (isFirstDeposit) { _usersConfig[onBehalfOf].setUsingAsCollateral(reserve.id, true); @@ -982,11 +998,12 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage DataTypes.UserConfigurationMap storage userConfig = _usersConfig[msg.sender]; CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); - address aToken = reserve.aTokenAddress; - reserve.updateState(cachedData); - uint256 userBalance = IAToken(aToken).scaledBalanceOf(msg.sender).rayMul(cachedData.newLiquidityIndex); + uint256 userBalance = + IAToken(cachedData.aTokenAddress).scaledBalanceOf(msg.sender).rayMul( + cachedData.newLiquidityIndex + ); uint256 amountToWithdraw = amount; @@ -996,9 +1013,14 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage ValidationLogic.validateWithdraw(reserve, amountToWithdraw, userBalance); - reserve.updateInterestRates(asset, aToken, 0, amountToWithdraw); + reserve.updateInterestRates(cachedData, asset, 0, amountToWithdraw); - IAToken(aToken).burn(msg.sender, to, amountToWithdraw, cachedData.newLiquidityIndex); + IAToken(cachedData.aTokenAddress).burn( + msg.sender, + to, + amountToWithdraw, + cachedData.newLiquidityIndex + ); if (userConfig.isUsingAsCollateral(reserve.id)) { if (userConfig.isBorrowingAny()) { @@ -1055,25 +1077,30 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage reserve.updateState(cachedData); if (interestRateMode == DataTypes.InterestRateMode.STABLE) { - IStableDebtToken(reserve.stableDebtTokenAddress).burn(onBehalfOf, paybackAmount); + IStableDebtToken(cachedData.stableDebtTokenAddress).burn(onBehalfOf, paybackAmount); + cachedData.newPrincipalStableDebt = cachedData.newTotalStableDebt = cachedData + .oldTotalStableDebt + .sub(paybackAmount); } else { - IVariableDebtToken(reserve.variableDebtTokenAddress).burn( + IVariableDebtToken(cachedData.variableDebtTokenAddress).burn( onBehalfOf, paybackAmount, - reserve.variableBorrowIndex + cachedData.newVariableBorrowIndex + ); + cachedData.newScaledVariableDebt = cachedData.oldScaledVariableDebt.sub( + paybackAmount.rayDiv(cachedData.newVariableBorrowIndex) ); } - address aToken = reserve.aTokenAddress; - reserve.updateInterestRates(asset, aToken, paybackAmount, 0); + reserve.updateInterestRates(cachedData, asset, paybackAmount, 0); if (stableDebt.add(variableDebt).sub(paybackAmount) == 0) { _usersConfig[onBehalfOf].setBorrowing(reserve.id, false); } - IERC20(asset).safeTransferFrom(msg.sender, aToken, paybackAmount); + IERC20(asset).safeTransferFrom(msg.sender, cachedData.aTokenAddress, paybackAmount); - IAToken(aToken).handleRepayment(msg.sender, paybackAmount); + IAToken(cachedData.aTokenAddress).handleRepayment(msg.sender, paybackAmount); emit Repay(asset, onBehalfOf, msg.sender, paybackAmount); diff --git a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol index 5e6722b2..2f823d50 100644 --- a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol +++ b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol @@ -169,26 +169,37 @@ contract LendingPoolCollateralManager is IVariableDebtToken(debtReserve.variableDebtTokenAddress).burn( user, vars.actualDebtToLiquidate, - debtReserve.variableBorrowIndex + debtReserveCachedData.newVariableBorrowIndex + ); + debtReserveCachedData.newScaledVariableDebt = debtReserveCachedData.oldScaledVariableDebt.sub( + vars.actualDebtToLiquidate.rayDiv(debtReserveCachedData.newVariableBorrowIndex) ); } else { // If the user doesn't have variable debt, no need to try to burn variable debt tokens if (vars.userVariableDebt > 0) { - IVariableDebtToken(debtReserve.variableDebtTokenAddress).burn( + IVariableDebtToken(debtReserveCachedData.variableDebtTokenAddress).burn( user, vars.userVariableDebt, - debtReserve.variableBorrowIndex + debtReserveCachedData.newVariableBorrowIndex ); + debtReserveCachedData.newScaledVariableDebt = debtReserveCachedData + .oldScaledVariableDebt + .sub(vars.userVariableDebt.rayDiv(debtReserveCachedData.newVariableBorrowIndex)); } - IStableDebtToken(debtReserve.stableDebtTokenAddress).burn( + IStableDebtToken(debtReserveCachedData.stableDebtTokenAddress).burn( user, vars.actualDebtToLiquidate.sub(vars.userVariableDebt) ); + + debtReserveCachedData.newPrincipalStableDebt = debtReserveCachedData + .newTotalStableDebt = debtReserveCachedData.oldTotalStableDebt.sub( + vars.actualDebtToLiquidate.sub(vars.userVariableDebt) + ); } debtReserve.updateInterestRates( + debtReserveCachedData, debtAsset, - debtReserve.aTokenAddress, vars.actualDebtToLiquidate, 0 ); @@ -203,12 +214,13 @@ contract LendingPoolCollateralManager is emit ReserveUsedAsCollateralEnabled(collateralAsset, msg.sender); } } else { - CachingHelper.CachedData memory collateralReserveCachedData = CachingHelper.fetchData(collateralReserve); + CachingHelper.CachedData memory collateralReserveCachedData = + CachingHelper.fetchData(collateralReserve); collateralReserve.updateState(collateralReserveCachedData); collateralReserve.updateInterestRates( + collateralReserveCachedData, collateralAsset, - address(vars.collateralAtoken), 0, vars.maxCollateralToLiquidate ); diff --git a/contracts/protocol/libraries/configuration/ReserveConfiguration.sol b/contracts/protocol/libraries/configuration/ReserveConfiguration.sol index 91d8bc50..389f5091 100644 --- a/contracts/protocol/libraries/configuration/ReserveConfiguration.sol +++ b/contracts/protocol/libraries/configuration/ReserveConfiguration.sol @@ -65,6 +65,16 @@ library ReserveConfiguration { return self.data & ~LTV_MASK; } + /** + * @dev Gets the Loan to Value of the reserve + * @param self The reserve configuration + * @return The loan to value + **/ + function getLtvMemory(DataTypes.ReserveConfigurationMap memory self) internal view returns (uint256) { + return self.data & ~LTV_MASK; + } + + /** * @dev Sets the liquidation threshold of the reserve * @param self The reserve configuration @@ -150,6 +160,20 @@ library ReserveConfiguration { return (self.data & ~DECIMALS_MASK) >> RESERVE_DECIMALS_START_BIT_POSITION; } + + /** + * @dev Gets the decimals of the underlying asset of the reserve + * @param self The reserve configuration + * @return The decimals of the asset + **/ + function getDecimalsMemory(DataTypes.ReserveConfigurationMap memory self) + internal + view + returns (uint256) + { + return (self.data & ~DECIMALS_MASK) >> RESERVE_DECIMALS_START_BIT_POSITION; + } + /** * @dev Sets the active state of the reserve * @param self The reserve configuration @@ -293,6 +317,19 @@ library ReserveConfiguration { return (self.data & ~RESERVE_FACTOR_MASK) >> RESERVE_FACTOR_START_BIT_POSITION; } + /** + * @dev Gets the reserve factor of the reserve + * @param self The reserve configuration + * @return The reserve factor + **/ + function getReserveFactorMemory(DataTypes.ReserveConfigurationMap memory self) + internal + view + returns (uint256) + { + return (self.data & ~RESERVE_FACTOR_MASK) >> RESERVE_FACTOR_START_BIT_POSITION; + } + /** * @dev Sets the borrow cap of the reserve * @param self The reserve configuration diff --git a/contracts/protocol/libraries/helpers/CachingHelper.sol b/contracts/protocol/libraries/helpers/CachingHelper.sol index bbfd959c..8bb739ef 100644 --- a/contracts/protocol/libraries/helpers/CachingHelper.sol +++ b/contracts/protocol/libraries/helpers/CachingHelper.sol @@ -4,13 +4,14 @@ pragma experimental ABIEncoderV2; import {DataTypes} from '../types/DataTypes.sol'; import {IVariableDebtToken} from '../../../interfaces/IVariableDebtToken.sol'; +import {IStableDebtToken} from '../../../interfaces/IStableDebtToken.sol'; library CachingHelper { struct CachedData { uint256 oldScaledVariableDebt; uint256 oldTotalVariableDebt; - uint256 newSscaledVariableDebt; - uint256 newTtotalVariableDebt; + uint256 newScaledVariableDebt; + uint256 newTotalVariableDebt; uint256 oldPrincipalStableDebt; uint256 oldAvgStableBorrowRate; uint256 oldTotalStableDebt; @@ -28,6 +29,7 @@ library CachingHelper { address stableDebtTokenAddress; address variableDebtTokenAddress; uint40 reserveLastUpdateTimestamp; + uint40 stableDebtLastUpdateTimestamp; } function fetchData(DataTypes.ReserveData storage reserveData) @@ -51,9 +53,23 @@ library CachingHelper { cachedData.reserveLastUpdateTimestamp = reserveData.lastUpdateTimestamp; - cachedData.oldScaledVariableDebt = IVariableDebtToken(cachedData.variableDebtTokenAddress) + cachedData.oldScaledVariableDebt = cachedData.newScaledVariableDebt = IVariableDebtToken( + cachedData + .variableDebtTokenAddress + ) .scaledTotalSupply(); - + + ( + cachedData.oldPrincipalStableDebt, + cachedData.oldTotalStableDebt, + cachedData.oldAvgStableBorrowRate, + cachedData.stableDebtLastUpdateTimestamp + ) = IStableDebtToken(cachedData.stableDebtTokenAddress).getSupplyData(); + + cachedData.newPrincipalStableDebt = cachedData.oldPrincipalStableDebt; + cachedData.newTotalStableDebt = cachedData.oldTotalStableDebt; + cachedData.newAvgStableBorrowRate = cachedData.oldAvgStableBorrowRate; + return cachedData; } } diff --git a/contracts/protocol/libraries/logic/ReserveLogic.sol b/contracts/protocol/libraries/logic/ReserveLogic.sol index 33ba2aaf..53c56454 100644 --- a/contracts/protocol/libraries/logic/ReserveLogic.sol +++ b/contracts/protocol/libraries/logic/ReserveLogic.sol @@ -108,23 +108,13 @@ library ReserveLogic { * @dev Updates the liquidity cumulative index and the variable borrow index. * @param reserve the reserve object **/ - function updateState(DataTypes.ReserveData storage reserve, CachingHelper.CachedData memory cachedData) internal { + function updateState( + DataTypes.ReserveData storage reserve, + CachingHelper.CachedData memory cachedData + ) internal { + _updateIndexes(reserve, cachedData); - _updateIndexes( - reserve, - cachedData - ); - - - - _accrueToTreasury( - reserve, - cachedData.oldScaledVariableDebt, - cachedData.oldVariableBorrowIndex, - cachedData.newLiquidityIndex, - cachedData.newVariableBorrowIndex, - cachedData.reserveLastUpdateTimestamp - ); + _accrueToTreasury(reserve, cachedData); } /** @@ -191,22 +181,21 @@ library ReserveLogic { **/ function updateInterestRates( DataTypes.ReserveData storage reserve, + CachingHelper.CachedData memory cachedData, address reserveAddress, - address aTokenAddress, uint256 liquidityAdded, uint256 liquidityTaken ) internal { UpdateInterestRatesLocalVars memory vars; - vars.stableDebtTokenAddress = reserve.stableDebtTokenAddress; + if (cachedData.oldTotalStableDebt != cachedData.newTotalStableDebt) { + cachedData.newAvgStableBorrowRate = IStableDebtToken(cachedData.stableDebtTokenAddress) + .getAverageStableRate(); + } - (vars.totalStableDebt, vars.avgStableRate) = IStableDebtToken(vars.stableDebtTokenAddress) - .getTotalSupplyAndAvgRate(); - - - vars.totalVariableDebt = IVariableDebtToken(reserve.variableDebtTokenAddress) - .scaledTotalSupply() - .rayMul(reserve.variableBorrowIndex); + cachedData.newTotalVariableDebt = cachedData.newScaledVariableDebt.rayMul( + cachedData.newVariableBorrowIndex + ); ( vars.newLiquidityRate, @@ -214,13 +203,13 @@ library ReserveLogic { vars.newVariableRate ) = IReserveInterestRateStrategy(reserve.interestRateStrategyAddress).calculateInterestRates( reserveAddress, - aTokenAddress, + cachedData.aTokenAddress, liquidityAdded, liquidityTaken, - vars.totalStableDebt, - vars.totalVariableDebt, - vars.avgStableRate, - reserve.configuration.getReserveFactor() + cachedData.newTotalStableDebt, + cachedData.newTotalVariableDebt, + cachedData.newAvgStableBorrowRate, + cachedData.reserveConfiguration.getReserveFactorMemory() ); require(vars.newLiquidityRate <= type(uint128).max, Errors.RL_LIQUIDITY_RATE_OVERFLOW); require(vars.newStableRate <= type(uint128).max, Errors.RL_STABLE_BORROW_RATE_OVERFLOW); @@ -235,8 +224,8 @@ library ReserveLogic { vars.newLiquidityRate, vars.newStableRate, vars.newVariableRate, - reserve.liquidityIndex, - reserve.variableBorrowIndex + cachedData.newLiquidityIndex, + cachedData.newVariableBorrowIndex ); } @@ -258,46 +247,35 @@ library ReserveLogic { * @dev Mints part of the repaid interest to the reserve treasury as a function of the reserveFactor for the * specific asset. * @param reserve The reserve reserve to be updated - * @param scaledVariableDebt The current scaled total variable debt - * @param previousVariableBorrowIndex The variable borrow index before the last accumulation of the interest - * @param newLiquidityIndex The new liquidity index - * @param newVariableBorrowIndex The variable borrow index after the last accumulation of the interest + * @param cachedData The caching layer for the reserve data **/ function _accrueToTreasury( DataTypes.ReserveData storage reserve, - uint256 scaledVariableDebt, - uint256 previousVariableBorrowIndex, - uint256 newLiquidityIndex, - uint256 newVariableBorrowIndex, - uint40 timestamp + CachingHelper.CachedData memory cachedData ) internal { MintToTreasuryLocalVars memory vars; - vars.reserveFactor = reserve.configuration.getReserveFactor(); + vars.reserveFactor = cachedData.reserveConfiguration.getReserveFactorMemory(); if (vars.reserveFactor == 0) { return; } - //fetching the principal, total stable debt and the avg stable rate - ( - vars.principalStableDebt, - vars.currentStableDebt, - vars.avgStableRate, - vars.stableSupplyUpdatedTimestamp - ) = IStableDebtToken(reserve.stableDebtTokenAddress).getSupplyData(); - //calculate the last principal variable debt - vars.previousVariableDebt = scaledVariableDebt.rayMul(previousVariableBorrowIndex); + vars.previousVariableDebt = cachedData.oldScaledVariableDebt.rayMul( + cachedData.oldVariableBorrowIndex + ); //calculate the new total supply after accumulation of the index - vars.currentVariableDebt = scaledVariableDebt.rayMul(newVariableBorrowIndex); + vars.currentVariableDebt = cachedData.oldScaledVariableDebt.rayMul( + cachedData.newVariableBorrowIndex + ); //calculate the stable debt until the last timestamp update vars.cumulatedStableInterest = MathUtils.calculateCompoundedInterest( vars.avgStableRate, vars.stableSupplyUpdatedTimestamp, - timestamp + cachedData.reserveLastUpdateTimestamp ); vars.previousStableDebt = vars.principalStableDebt.rayMul(vars.cumulatedStableInterest); @@ -312,7 +290,9 @@ library ReserveLogic { vars.amountToMint = vars.totalDebtAccrued.percentMul(vars.reserveFactor); if (vars.amountToMint != 0) { - reserve.accruedToTreasury = reserve.accruedToTreasury.add(vars.amountToMint.rayDiv(newLiquidityIndex)); + reserve.accruedToTreasury = reserve.accruedToTreasury.add( + vars.amountToMint.rayDiv(cachedData.newLiquidityIndex) + ); } } @@ -325,16 +305,23 @@ library ReserveLogic { DataTypes.ReserveData storage reserve, CachingHelper.CachedData memory cachedData ) internal { - cachedData.newLiquidityIndex = cachedData.oldLiquidityIndex; cachedData.newVariableBorrowIndex = cachedData.oldVariableBorrowIndex; //only cumulating if there is any income being produced if (cachedData.oldLiquidityRate > 0) { uint256 cumulatedLiquidityInterest = - MathUtils.calculateLinearInterest(cachedData.oldLiquidityRate, cachedData.reserveLastUpdateTimestamp); - cachedData.newLiquidityIndex = cumulatedLiquidityInterest.rayMul(cachedData.oldLiquidityIndex); - require( cachedData.newLiquidityIndex <= type(uint128).max, Errors.RL_LIQUIDITY_INDEX_OVERFLOW); + MathUtils.calculateLinearInterest( + cachedData.oldLiquidityRate, + cachedData.reserveLastUpdateTimestamp + ); + cachedData.newLiquidityIndex = cumulatedLiquidityInterest.rayMul( + cachedData.oldLiquidityIndex + ); + require( + cachedData.newLiquidityIndex <= type(uint128).max, + Errors.RL_LIQUIDITY_INDEX_OVERFLOW + ); reserve.liquidityIndex = uint128(cachedData.newLiquidityIndex); @@ -342,8 +329,13 @@ library ReserveLogic { //that there is actual variable debt before accumulating if (cachedData.oldScaledVariableDebt != 0) { uint256 cumulatedVariableBorrowInterest = - MathUtils.calculateCompoundedInterest(cachedData.oldVariableBorrowRate, cachedData.reserveLastUpdateTimestamp); - cachedData.newVariableBorrowIndex = cumulatedVariableBorrowInterest.rayMul(cachedData.oldVariableBorrowIndex); + MathUtils.calculateCompoundedInterest( + cachedData.oldVariableBorrowRate, + cachedData.reserveLastUpdateTimestamp + ); + cachedData.newVariableBorrowIndex = cumulatedVariableBorrowInterest.rayMul( + cachedData.oldVariableBorrowIndex + ); require( cachedData.newVariableBorrowIndex <= type(uint128).max, Errors.RL_VARIABLE_BORROW_INDEX_OVERFLOW diff --git a/contracts/protocol/libraries/logic/ValidationLogic.sol b/contracts/protocol/libraries/logic/ValidationLogic.sol index 40ef23be..94cc3248 100644 --- a/contracts/protocol/libraries/logic/ValidationLogic.sol +++ b/contracts/protocol/libraries/logic/ValidationLogic.sol @@ -12,11 +12,14 @@ import {SafeERC20} from '../../../dependencies/openzeppelin/contracts/SafeERC20. import {ReserveConfiguration} from '../configuration/ReserveConfiguration.sol'; import {UserConfiguration} from '../configuration/UserConfiguration.sol'; import {Errors} from '../helpers/Errors.sol'; +import {CachingHelper} from '../helpers/CachingHelper.sol'; import {Helpers} from '../helpers/Helpers.sol'; import {IReserveInterestRateStrategy} from '../../../interfaces/IReserveInterestRateStrategy.sol'; import {IVariableDebtToken} from '../../../interfaces/IVariableDebtToken.sol'; import {IStableDebtToken} from '../../../interfaces/IStableDebtToken.sol'; +import {IAToken} from '../../../interfaces/IAToken.sol'; import {DataTypes} from '../types/DataTypes.sol'; +import {IPriceOracleGetter} from '../../../interfaces/IPriceOracleGetter.sol'; /** * @title ReserveLogic library @@ -40,11 +43,15 @@ library ValidationLogic { * @param reserve The reserve object on which the user is depositing * @param amount The amount to be deposited */ - function validateDeposit(DataTypes.ReserveData storage reserve, uint256 amount) internal view { - DataTypes.ReserveConfigurationMap memory reserveConfiguration = reserve.configuration; - (bool isActive, bool isFrozen, , , bool isPaused) = reserveConfiguration.getFlagsMemory(); - (, , , uint256 reserveDecimals, ) = reserveConfiguration.getParamsMemory(); - uint256 supplyCap = reserveConfiguration.getSupplyCapMemory(); + function validateDeposit( + DataTypes.ReserveData storage reserve, + CachingHelper.CachedData memory cachedData, + uint256 amount + ) internal view { + (bool isActive, bool isFrozen, , , bool isPaused) = + cachedData.reserveConfiguration.getFlagsMemory(); + (, , , uint256 reserveDecimals, ) = cachedData.reserveConfiguration.getParamsMemory(); + uint256 supplyCap = cachedData.reserveConfiguration.getSupplyCapMemory(); require(amount != 0, Errors.VL_INVALID_AMOUNT); require(isActive, Errors.VL_NO_ACTIVE_RESERVE); @@ -52,7 +59,11 @@ library ValidationLogic { require(!isFrozen, Errors.VL_RESERVE_FROZEN); require( supplyCap == 0 || - IERC20(reserve.aTokenAddress).totalSupply().add(amount).div(10**reserveDecimals) < + IAToken(cachedData.aTokenAddress) + .scaledTotalSupply() + .rayMul(cachedData.newLiquidityIndex) + .add(amount) + .div(10**reserveDecimals) < supplyCap, Errors.VL_SUPPLY_CAP_EXCEEDED ); @@ -85,10 +96,11 @@ library ValidationLogic { uint256 userBorrowBalanceETH; uint256 availableLiquidity; uint256 healthFactor; - uint256 totalSupplyStableDebt; + uint256 totalDebt; uint256 totalSupplyVariableDebt; uint256 reserveDecimals; uint256 borrowCap; + uint256 amountInETH; bool isActive; bool isFrozen; bool isPaused; @@ -99,10 +111,8 @@ library ValidationLogic { /** * @dev Validates a borrow action * @param asset The address of the asset to borrow - * @param reserve The reserve state from which the user is borrowing * @param userAddress The address of the user * @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 @@ -112,11 +122,10 @@ library ValidationLogic { */ function validateBorrow( + CachingHelper.CachedData memory cachedData, address asset, - DataTypes.ReserveData storage reserve, address userAddress, uint256 amount, - uint256 amountInETH, uint256 interestRateMode, uint256 maxStableLoanPercent, mapping(address => DataTypes.ReserveData) storage reservesData, @@ -127,8 +136,7 @@ library ValidationLogic { ) external view { ValidateBorrowLocalVars memory vars; - DataTypes.ReserveConfigurationMap memory reserveConfiguration = reserve.configuration; - (, , , vars.reserveDecimals, ) = reserveConfiguration.getParamsMemory(); + (, , , vars.reserveDecimals, ) = cachedData.reserveConfiguration.getParamsMemory(); ( vars.isActive, @@ -136,7 +144,7 @@ library ValidationLogic { vars.borrowingEnabled, vars.stableRateBorrowingEnabled, vars.isPaused - ) = reserveConfiguration.getFlagsMemory(); + ) = cachedData.reserveConfiguration.getFlagsMemory(); require(vars.isActive, Errors.VL_NO_ACTIVE_RESERVE); require(!vars.isPaused, Errors.VL_RESERVE_PAUSED); @@ -152,18 +160,23 @@ library ValidationLogic { Errors.VL_INVALID_INTEREST_RATE_MODE_SELECTED ); - vars.totalSupplyStableDebt = IERC20(reserve.stableDebtTokenAddress).totalSupply(); - vars.borrowCap = reserveConfiguration.getBorrowCapMemory(); - vars.totalSupplyVariableDebt = IERC20(reserve.variableDebtTokenAddress).totalSupply(); + vars.borrowCap = cachedData.reserveConfiguration.getBorrowCapMemory(); - require( - vars.borrowCap == 0 || - vars.totalSupplyStableDebt.add(vars.totalSupplyVariableDebt).add(amount).div( - 10**vars.reserveDecimals - ) < - vars.borrowCap, - Errors.VL_BORROW_CAP_EXCEEDED - ); + if (vars.borrowCap > 0) { + { + vars.totalSupplyVariableDebt = cachedData.oldScaledVariableDebt.rayMul( + cachedData.newVariableBorrowIndex + ); + + vars.totalDebt = cachedData.oldTotalStableDebt.add(vars.totalSupplyVariableDebt).add( + amount + ); + require( + vars.totalDebt.div(10**vars.reserveDecimals) < vars.borrowCap, + Errors.VL_BORROW_CAP_EXCEEDED + ); + } + } ( vars.userCollateralBalanceETH, @@ -187,8 +200,11 @@ library ValidationLogic { Errors.VL_HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD ); + vars.amountInETH = IPriceOracleGetter(oracle).getAssetPrice(asset); + vars.amountInETH = vars.amountInETH.mul(amount).div(10**vars.reserveDecimals); + //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(vars.amountInETH).percentDiv( vars.currentLtv ); //LTV is calculated in percentage @@ -211,13 +227,13 @@ library ValidationLogic { require(vars.stableRateBorrowingEnabled, Errors.VL_STABLE_BORROWING_NOT_ENABLED); require( - !userConfig.isUsingAsCollateral(reserve.id) || - reserve.configuration.getLtv() == 0 || - amount > IERC20(reserve.aTokenAddress).balanceOf(userAddress), + !userConfig.isUsingAsCollateral(reservesData[asset].id) || + cachedData.reserveConfiguration.getLtvMemory() == 0 || + amount > IERC20(cachedData.aTokenAddress).balanceOf(userAddress), Errors.VL_COLLATERAL_SAME_AS_BORROWING_CURRENCY ); - vars.availableLiquidity = IERC20(asset).balanceOf(reserve.aTokenAddress); + vars.availableLiquidity = IERC20(asset).balanceOf(cachedData.aTokenAddress); //calculate the max available loan size in stable rate mode as a percentage of the //available liquidity From 044b492f7fbb853d5ad7c93dabe883a27c9226e9 Mon Sep 17 00:00:00 2001 From: The3D Date: Fri, 4 Jun 2021 14:47:02 +0200 Subject: [PATCH 03/13] refactor: further refactored the CachingHelper --- contracts/protocol/lendingpool/LendingPool.sol | 3 --- .../protocol/lendingpool/LendingPoolCollateralManager.sol | 2 +- contracts/protocol/libraries/helpers/CachingHelper.sol | 8 +++----- contracts/protocol/libraries/logic/ReserveLogic.sol | 8 ++++---- 4 files changed, 8 insertions(+), 13 deletions(-) diff --git a/contracts/protocol/lendingpool/LendingPool.sol b/contracts/protocol/lendingpool/LendingPool.sol index 06bfeb8e..3165a0e2 100644 --- a/contracts/protocol/lendingpool/LendingPool.sol +++ b/contracts/protocol/lendingpool/LendingPool.sol @@ -198,7 +198,6 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage onBehalfOf, amount, interestRateMode, - reserve.aTokenAddress, referralCode, true ) @@ -542,7 +541,6 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage onBehalfOf, vars.currentAmount, modes[vars.i], - vars.currentATokenAddress, referralCode, false ) @@ -877,7 +875,6 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage address onBehalfOf; uint256 amount; uint256 interestRateMode; - address aTokenAddress; uint16 referralCode; bool releaseUnderlying; } diff --git a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol index 2f823d50..a92045c3 100644 --- a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol +++ b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol @@ -166,7 +166,7 @@ contract LendingPoolCollateralManager is debtReserve.updateState(debtReserveCachedData); if (vars.userVariableDebt >= vars.actualDebtToLiquidate) { - IVariableDebtToken(debtReserve.variableDebtTokenAddress).burn( + IVariableDebtToken(debtReserveCachedData.variableDebtTokenAddress).burn( user, vars.actualDebtToLiquidate, debtReserveCachedData.newVariableBorrowIndex diff --git a/contracts/protocol/libraries/helpers/CachingHelper.sol b/contracts/protocol/libraries/helpers/CachingHelper.sol index 8bb739ef..06908ee9 100644 --- a/contracts/protocol/libraries/helpers/CachingHelper.sol +++ b/contracts/protocol/libraries/helpers/CachingHelper.sol @@ -39,18 +39,16 @@ library CachingHelper { { CachedData memory cachedData; + cachedData.reserveConfiguration = reserveData.configuration; cachedData.oldLiquidityIndex = reserveData.liquidityIndex; cachedData.oldVariableBorrowIndex = reserveData.variableBorrowIndex; + cachedData.oldLiquidityRate = reserveData.currentLiquidityRate; + cachedData.oldVariableBorrowRate = reserveData.currentVariableBorrowRate; cachedData.aTokenAddress = reserveData.aTokenAddress; cachedData.stableDebtTokenAddress = reserveData.stableDebtTokenAddress; cachedData.variableDebtTokenAddress = reserveData.variableDebtTokenAddress; - cachedData.reserveConfiguration = reserveData.configuration; - - cachedData.oldLiquidityRate = reserveData.currentLiquidityRate; - cachedData.oldVariableBorrowRate = reserveData.currentVariableBorrowRate; - cachedData.reserveLastUpdateTimestamp = reserveData.lastUpdateTimestamp; cachedData.oldScaledVariableDebt = cachedData.newScaledVariableDebt = IVariableDebtToken( diff --git a/contracts/protocol/libraries/logic/ReserveLogic.sol b/contracts/protocol/libraries/logic/ReserveLogic.sol index 53c56454..ac5ff510 100644 --- a/contracts/protocol/libraries/logic/ReserveLogic.sol +++ b/contracts/protocol/libraries/logic/ReserveLogic.sol @@ -273,17 +273,17 @@ library ReserveLogic { //calculate the stable debt until the last timestamp update vars.cumulatedStableInterest = MathUtils.calculateCompoundedInterest( - vars.avgStableRate, - vars.stableSupplyUpdatedTimestamp, + cachedData.oldAvgStableBorrowRate, + cachedData.stableDebtLastUpdateTimestamp, cachedData.reserveLastUpdateTimestamp ); - vars.previousStableDebt = vars.principalStableDebt.rayMul(vars.cumulatedStableInterest); + vars.previousStableDebt = cachedData.oldPrincipalStableDebt.rayMul(vars.cumulatedStableInterest); //debt accrued is the sum of the current debt minus the sum of the debt at the last update vars.totalDebtAccrued = vars .currentVariableDebt - .add(vars.currentStableDebt) + .add(cachedData.oldTotalStableDebt) .sub(vars.previousVariableDebt) .sub(vars.previousStableDebt); From 86686ef3be93bde85a9d6269569ebbc6ec3a5a30 Mon Sep 17 00:00:00 2001 From: The3D Date: Mon, 7 Jun 2021 18:02:13 +0200 Subject: [PATCH 04/13] refactor: further refactored the cache helper functions --- .../protocol/lendingpool/LendingPool.sol | 127 ++++++++-------- .../LendingPoolCollateralManager.sol | 41 +++--- .../configuration/ReserveConfiguration.sol | 12 ++ .../libraries/helpers/CachingHelper.sol | 73 ---------- .../protocol/libraries/logic/ReserveLogic.sol | 136 +++++++++++------- .../libraries/logic/ValidationLogic.sol | 77 +++++----- .../protocol/libraries/types/DataTypes.sol | 25 ++++ package-lock.json | 14 +- 8 files changed, 260 insertions(+), 245 deletions(-) delete mode 100644 contracts/protocol/libraries/helpers/CachingHelper.sol diff --git a/contracts/protocol/lendingpool/LendingPool.sol b/contracts/protocol/lendingpool/LendingPool.sol index e99428cc..1c5f4208 100644 --- a/contracts/protocol/lendingpool/LendingPool.sol +++ b/contracts/protocol/lendingpool/LendingPool.sol @@ -26,7 +26,6 @@ import {ReserveConfiguration} from '../libraries/configuration/ReserveConfigurat import {UserConfiguration} from '../libraries/configuration/UserConfiguration.sol'; import {DataTypes} from '../libraries/types/DataTypes.sol'; import {LendingPoolStorage} from './LendingPoolStorage.sol'; -import {CachingHelper} from '../libraries/helpers/CachingHelper.sol'; /** * @title LendingPool contract @@ -270,7 +269,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage **/ function swapBorrowRateMode(address asset, uint256 rateMode) external override whenNotPaused { DataTypes.ReserveData storage reserve = _reserves[asset]; - CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); + DataTypes.ReserveCache memory reserveCache = reserve.cache(); (uint256 stableDebt, uint256 variableDebt) = Helpers.getUserCurrentDebt(msg.sender, reserve); @@ -278,53 +277,54 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage ValidationLogic.validateSwapRateMode( reserve, + reserveCache, _usersConfig[msg.sender], stableDebt, variableDebt, interestRateMode ); - reserve.updateState(cachedData); + reserve.updateState(reserveCache); if (interestRateMode == DataTypes.InterestRateMode.STABLE) { - IStableDebtToken(cachedData.stableDebtTokenAddress).burn(msg.sender, stableDebt); + IStableDebtToken(reserveCache.stableDebtTokenAddress).burn(msg.sender, stableDebt); - cachedData.newPrincipalStableDebt = cachedData.newTotalStableDebt = cachedData + reserveCache.newPrincipalStableDebt = reserveCache.newTotalStableDebt = reserveCache .oldTotalStableDebt .sub(stableDebt); - IVariableDebtToken(cachedData.variableDebtTokenAddress).mint( + IVariableDebtToken(reserveCache.variableDebtTokenAddress).mint( msg.sender, msg.sender, stableDebt, - cachedData.newVariableBorrowIndex + reserveCache.newVariableBorrowIndex ); - cachedData.newScaledVariableDebt = cachedData.oldScaledVariableDebt.add( - stableDebt.rayDiv(cachedData.newVariableBorrowIndex) + reserveCache.newScaledVariableDebt = reserveCache.oldScaledVariableDebt.add( + stableDebt.rayDiv(reserveCache.newVariableBorrowIndex) ); } else { - IVariableDebtToken(cachedData.variableDebtTokenAddress).burn( + IVariableDebtToken(reserveCache.variableDebtTokenAddress).burn( msg.sender, variableDebt, - cachedData.newVariableBorrowIndex + reserveCache.newVariableBorrowIndex ); - cachedData.newScaledVariableDebt = cachedData.oldScaledVariableDebt.sub( - variableDebt.rayDiv(cachedData.newVariableBorrowIndex) + reserveCache.newScaledVariableDebt = reserveCache.oldScaledVariableDebt.sub( + variableDebt.rayDiv(reserveCache.newVariableBorrowIndex) ); - IStableDebtToken(cachedData.stableDebtTokenAddress).mint( + IStableDebtToken(reserveCache.stableDebtTokenAddress).mint( msg.sender, msg.sender, variableDebt, reserve.currentStableBorrowRate ); - cachedData.newPrincipalStableDebt = cachedData.newTotalStableDebt = cachedData + reserveCache.newPrincipalStableDebt = reserveCache.newTotalStableDebt = reserveCache .oldTotalStableDebt .add(stableDebt); } - reserve.updateInterestRates(cachedData, asset, 0, 0); + reserve.updateInterestRates(reserveCache, asset, 0, 0); emit Swap(asset, msg.sender, rateMode); } @@ -340,21 +340,22 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage **/ function rebalanceStableBorrowRate(address asset, address user) external override whenNotPaused { DataTypes.ReserveData storage reserve = _reserves[asset]; - CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); + DataTypes.ReserveCache memory reserveCache = reserve.cache(); - IERC20 stableDebtToken = IERC20(cachedData.stableDebtTokenAddress); - IERC20 variableDebtToken = IERC20(cachedData.variableDebtTokenAddress); + IERC20 stableDebtToken = IERC20(reserveCache.stableDebtTokenAddress); + IERC20 variableDebtToken = IERC20(reserveCache.variableDebtTokenAddress); uint256 stableDebt = IERC20(stableDebtToken).balanceOf(user); ValidationLogic.validateRebalanceStableBorrowRate( reserve, + reserveCache, asset, stableDebtToken, variableDebtToken, - cachedData.aTokenAddress + reserveCache.aTokenAddress ); - reserve.updateState(cachedData); + reserve.updateState(reserveCache); IStableDebtToken(address(stableDebtToken)).burn(user, stableDebt); IStableDebtToken(address(stableDebtToken)).mint( @@ -364,7 +365,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage reserve.currentStableBorrowRate ); - reserve.updateInterestRates(cachedData, asset, 0, 0); + reserve.updateInterestRates(reserveCache, asset, 0, 0); emit RebalanceStableBorrowRate(asset, user); } @@ -380,8 +381,9 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage whenNotPaused { DataTypes.ReserveData storage reserve = _reserves[asset]; + DataTypes.ReserveCache memory reserveCache = reserve.cache(); - ValidationLogic.validateSetUseReserveAsCollateral(reserve); + ValidationLogic.validateSetUseReserveAsCollateral(reserve, reserveCache); _usersConfig[msg.sender].setUsingAsCollateral(reserve.id, useAsCollateral); @@ -512,15 +514,15 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage if (DataTypes.InterestRateMode(modes[vars.i]) == DataTypes.InterestRateMode.NONE) { DataTypes.ReserveData storage reserve = _reserves[vars.currentAsset]; - CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); + DataTypes.ReserveCache memory reserveCache = reserve.cache(); - reserve.updateState(cachedData); + reserve.updateState(reserveCache); reserve.cumulateToLiquidityIndex( IERC20(vars.currentATokenAddress).totalSupply(), vars.currentPremium ); reserve.updateInterestRates( - cachedData, + reserveCache, vars.currentAsset, vars.currentAmountPlusPremium, 0 @@ -894,12 +896,12 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage function _executeBorrow(ExecuteBorrowParams memory vars) internal { DataTypes.ReserveData storage reserve = _reserves[vars.asset]; DataTypes.UserConfigurationMap storage userConfig = _usersConfig[vars.onBehalfOf]; - CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); + DataTypes.ReserveCache memory reserveCache = reserve.cache(); - reserve.updateState(cachedData); + reserve.updateState(reserveCache); ValidationLogic.validateBorrow( - cachedData, + reserveCache, vars.asset, vars.onBehalfOf, vars.amount, @@ -918,27 +920,27 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage if (DataTypes.InterestRateMode(vars.interestRateMode) == DataTypes.InterestRateMode.STABLE) { currentStableRate = reserve.currentStableBorrowRate; - isFirstBorrowing = IStableDebtToken(cachedData.stableDebtTokenAddress).mint( + isFirstBorrowing = IStableDebtToken(reserveCache.stableDebtTokenAddress).mint( vars.user, vars.onBehalfOf, vars.amount, currentStableRate ); - cachedData.newPrincipalStableDebt = cachedData.newTotalStableDebt = cachedData + reserveCache.newPrincipalStableDebt = reserveCache.newTotalStableDebt = reserveCache .oldTotalStableDebt .add(vars.amount); } else { - isFirstBorrowing = IVariableDebtToken(cachedData.variableDebtTokenAddress).mint( + isFirstBorrowing = IVariableDebtToken(reserveCache.variableDebtTokenAddress).mint( vars.user, vars.onBehalfOf, vars.amount, - cachedData.newVariableBorrowIndex + reserveCache.newVariableBorrowIndex ); - cachedData.newScaledVariableDebt = cachedData.newScaledVariableDebt.add( - vars.amount.rayDiv(cachedData.newVariableBorrowIndex) + reserveCache.newScaledVariableDebt = reserveCache.newScaledVariableDebt.add( + vars.amount.rayDiv(reserveCache.newVariableBorrowIndex) ); } @@ -947,14 +949,14 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage } reserve.updateInterestRates( - cachedData, + reserveCache, vars.asset, 0, vars.releaseUnderlying ? vars.amount : 0 ); if (vars.releaseUnderlying) { - IAToken(cachedData.aTokenAddress).transferUnderlyingTo(vars.user, vars.amount); + IAToken(reserveCache.aTokenAddress).transferUnderlyingTo(vars.user, vars.amount); } emit Borrow( @@ -977,18 +979,18 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage uint16 referralCode ) internal { DataTypes.ReserveData storage reserve = _reserves[asset]; - CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); + DataTypes.ReserveCache memory reserveCache = reserve.cache(); - reserve.updateState(cachedData); + reserve.updateState(reserveCache); - ValidationLogic.validateDeposit(reserve, cachedData, amount); + ValidationLogic.validateDeposit(reserve, reserveCache, amount); - reserve.updateInterestRates(cachedData, asset, amount, 0); + reserve.updateInterestRates(reserveCache, asset, amount, 0); - IERC20(asset).safeTransferFrom(msg.sender, cachedData.aTokenAddress, amount); + IERC20(asset).safeTransferFrom(msg.sender, reserveCache.aTokenAddress, amount); bool isFirstDeposit = - IAToken(cachedData.aTokenAddress).mint(onBehalfOf, amount, cachedData.newLiquidityIndex); + IAToken(reserveCache.aTokenAddress).mint(onBehalfOf, amount, reserveCache.newLiquidityIndex); if (isFirstDeposit) { _usersConfig[onBehalfOf].setUsingAsCollateral(reserve.id, true); @@ -1005,13 +1007,13 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage ) internal returns (uint256) { DataTypes.ReserveData storage reserve = _reserves[asset]; DataTypes.UserConfigurationMap storage userConfig = _usersConfig[msg.sender]; - CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); + DataTypes.ReserveCache memory reserveCache = reserve.cache(); - reserve.updateState(cachedData); + reserve.updateState(reserveCache); uint256 userBalance = - IAToken(cachedData.aTokenAddress).scaledBalanceOf(msg.sender).rayMul( - cachedData.newLiquidityIndex + IAToken(reserveCache.aTokenAddress).scaledBalanceOf(msg.sender).rayMul( + reserveCache.newLiquidityIndex ); uint256 amountToWithdraw = amount; @@ -1020,15 +1022,15 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage amountToWithdraw = userBalance; } - ValidationLogic.validateWithdraw(reserve, amountToWithdraw, userBalance); + ValidationLogic.validateWithdraw(reserve, reserveCache, amountToWithdraw, userBalance); - reserve.updateInterestRates(cachedData, asset, 0, amountToWithdraw); + reserve.updateInterestRates(reserveCache, asset, 0, amountToWithdraw); - IAToken(cachedData.aTokenAddress).burn( + IAToken(reserveCache.aTokenAddress).burn( msg.sender, to, amountToWithdraw, - cachedData.newLiquidityIndex + reserveCache.newLiquidityIndex ); if (userConfig.isUsingAsCollateral(reserve.id)) { @@ -1061,7 +1063,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage address onBehalfOf ) internal returns (uint256) { DataTypes.ReserveData storage reserve = _reserves[asset]; - CachingHelper.CachedData memory cachedData = CachingHelper.fetchData(reserve); + DataTypes.ReserveCache memory reserveCache = reserve.cache(); (uint256 stableDebt, uint256 variableDebt) = Helpers.getUserCurrentDebt(onBehalfOf, reserve); @@ -1069,6 +1071,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage ValidationLogic.validateRepay( reserve, + reserveCache, amount, interestRateMode, onBehalfOf, @@ -1083,33 +1086,33 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage paybackAmount = amount; } - reserve.updateState(cachedData); + reserve.updateState(reserveCache); if (interestRateMode == DataTypes.InterestRateMode.STABLE) { - IStableDebtToken(cachedData.stableDebtTokenAddress).burn(onBehalfOf, paybackAmount); - cachedData.newPrincipalStableDebt = cachedData.newTotalStableDebt = cachedData + IStableDebtToken(reserveCache.stableDebtTokenAddress).burn(onBehalfOf, paybackAmount); + reserveCache.newPrincipalStableDebt = reserveCache.newTotalStableDebt = reserveCache .oldTotalStableDebt .sub(paybackAmount); } else { - IVariableDebtToken(cachedData.variableDebtTokenAddress).burn( + IVariableDebtToken(reserveCache.variableDebtTokenAddress).burn( onBehalfOf, paybackAmount, - cachedData.newVariableBorrowIndex + reserveCache.newVariableBorrowIndex ); - cachedData.newScaledVariableDebt = cachedData.oldScaledVariableDebt.sub( - paybackAmount.rayDiv(cachedData.newVariableBorrowIndex) + reserveCache.newScaledVariableDebt = reserveCache.oldScaledVariableDebt.sub( + paybackAmount.rayDiv(reserveCache.newVariableBorrowIndex) ); } - reserve.updateInterestRates(cachedData, asset, paybackAmount, 0); + reserve.updateInterestRates(reserveCache, asset, paybackAmount, 0); if (stableDebt.add(variableDebt).sub(paybackAmount) == 0) { _usersConfig[onBehalfOf].setBorrowing(reserve.id, false); } - IERC20(asset).safeTransferFrom(msg.sender, cachedData.aTokenAddress, paybackAmount); + IERC20(asset).safeTransferFrom(msg.sender, reserveCache.aTokenAddress, paybackAmount); - IAToken(cachedData.aTokenAddress).handleRepayment(msg.sender, paybackAmount); + IAToken(reserveCache.aTokenAddress).handleRepayment(msg.sender, paybackAmount); emit Repay(asset, onBehalfOf, msg.sender, paybackAmount); diff --git a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol index a92045c3..2f6b0bcb 100644 --- a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol +++ b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol @@ -18,7 +18,6 @@ import {Errors} from '../libraries/helpers/Errors.sol'; import {ValidationLogic} from '../libraries/logic/ValidationLogic.sol'; import {DataTypes} from '../libraries/types/DataTypes.sol'; import {LendingPoolStorage} from './LendingPoolStorage.sol'; -import {CachingHelper} from '../libraries/helpers/CachingHelper.sol'; /** * @title LendingPoolCollateralManager contract @@ -101,11 +100,16 @@ contract LendingPoolCollateralManager is _addressesProvider.getPriceOracle() ); + DataTypes.ReserveCache memory debtReserveCache = debtReserve.cache(); + DataTypes.ReserveCache memory collateralReserveCache = collateralReserve.cache(); + (vars.userStableDebt, vars.userVariableDebt) = Helpers.getUserCurrentDebt(user, debtReserve); (vars.errorCode, vars.errorMsg) = ValidationLogic.validateLiquidationCall( collateralReserve, debtReserve, + debtReserveCache, + collateralReserveCache, userConfig, vars.healthFactor, vars.userStableDebt, @@ -161,44 +165,42 @@ contract LendingPoolCollateralManager is } } - CachingHelper.CachedData memory debtReserveCachedData = CachingHelper.fetchData(debtReserve); - - debtReserve.updateState(debtReserveCachedData); + debtReserve.updateState(debtReserveCache); if (vars.userVariableDebt >= vars.actualDebtToLiquidate) { - IVariableDebtToken(debtReserveCachedData.variableDebtTokenAddress).burn( + IVariableDebtToken(debtReserveCache.variableDebtTokenAddress).burn( user, vars.actualDebtToLiquidate, - debtReserveCachedData.newVariableBorrowIndex + debtReserveCache.newVariableBorrowIndex ); - debtReserveCachedData.newScaledVariableDebt = debtReserveCachedData.oldScaledVariableDebt.sub( - vars.actualDebtToLiquidate.rayDiv(debtReserveCachedData.newVariableBorrowIndex) + debtReserveCache.newScaledVariableDebt = debtReserveCache.oldScaledVariableDebt.sub( + vars.actualDebtToLiquidate.rayDiv(debtReserveCache.newVariableBorrowIndex) ); } else { // If the user doesn't have variable debt, no need to try to burn variable debt tokens if (vars.userVariableDebt > 0) { - IVariableDebtToken(debtReserveCachedData.variableDebtTokenAddress).burn( + IVariableDebtToken(debtReserveCache.variableDebtTokenAddress).burn( user, vars.userVariableDebt, - debtReserveCachedData.newVariableBorrowIndex + debtReserveCache.newVariableBorrowIndex ); - debtReserveCachedData.newScaledVariableDebt = debtReserveCachedData + debtReserveCache.newScaledVariableDebt = debtReserveCache .oldScaledVariableDebt - .sub(vars.userVariableDebt.rayDiv(debtReserveCachedData.newVariableBorrowIndex)); + .sub(vars.userVariableDebt.rayDiv(debtReserveCache.newVariableBorrowIndex)); } - IStableDebtToken(debtReserveCachedData.stableDebtTokenAddress).burn( + IStableDebtToken(debtReserveCache.stableDebtTokenAddress).burn( user, vars.actualDebtToLiquidate.sub(vars.userVariableDebt) ); - debtReserveCachedData.newPrincipalStableDebt = debtReserveCachedData - .newTotalStableDebt = debtReserveCachedData.oldTotalStableDebt.sub( + debtReserveCache.newPrincipalStableDebt = debtReserveCache + .newTotalStableDebt = debtReserveCache.oldTotalStableDebt.sub( vars.actualDebtToLiquidate.sub(vars.userVariableDebt) ); } debtReserve.updateInterestRates( - debtReserveCachedData, + debtReserveCache, debtAsset, vars.actualDebtToLiquidate, 0 @@ -214,12 +216,9 @@ contract LendingPoolCollateralManager is emit ReserveUsedAsCollateralEnabled(collateralAsset, msg.sender); } } else { - CachingHelper.CachedData memory collateralReserveCachedData = - CachingHelper.fetchData(collateralReserve); - - collateralReserve.updateState(collateralReserveCachedData); + collateralReserve.updateState(collateralReserveCache); collateralReserve.updateInterestRates( - collateralReserveCachedData, + collateralReserveCache, collateralAsset, 0, vars.maxCollateralToLiquidate diff --git a/contracts/protocol/libraries/configuration/ReserveConfiguration.sol b/contracts/protocol/libraries/configuration/ReserveConfiguration.sol index 389f5091..012e4cbd 100644 --- a/contracts/protocol/libraries/configuration/ReserveConfiguration.sol +++ b/contracts/protocol/libraries/configuration/ReserveConfiguration.sol @@ -104,6 +104,18 @@ library ReserveConfiguration { return (self.data & ~LIQUIDATION_THRESHOLD_MASK) >> LIQUIDATION_THRESHOLD_START_BIT_POSITION; } + /** + * @dev Gets the liquidation threshold of the reserve + * @param self The reserve configuration + * @return The liquidation threshold + **/ + function getLiquidationThresholdMemory(DataTypes.ReserveConfigurationMap memory self) + internal + view + returns (uint256) + { + return (self.data & ~LIQUIDATION_THRESHOLD_MASK) >> LIQUIDATION_THRESHOLD_START_BIT_POSITION; + } /** * @dev Sets the liquidation bonus of the reserve * @param self The reserve configuration diff --git a/contracts/protocol/libraries/helpers/CachingHelper.sol b/contracts/protocol/libraries/helpers/CachingHelper.sol deleted file mode 100644 index 06908ee9..00000000 --- a/contracts/protocol/libraries/helpers/CachingHelper.sol +++ /dev/null @@ -1,73 +0,0 @@ -pragma solidity 0.6.12; - -pragma experimental ABIEncoderV2; - -import {DataTypes} from '../types/DataTypes.sol'; -import {IVariableDebtToken} from '../../../interfaces/IVariableDebtToken.sol'; -import {IStableDebtToken} from '../../../interfaces/IStableDebtToken.sol'; - -library CachingHelper { - struct CachedData { - uint256 oldScaledVariableDebt; - uint256 oldTotalVariableDebt; - uint256 newScaledVariableDebt; - uint256 newTotalVariableDebt; - uint256 oldPrincipalStableDebt; - uint256 oldAvgStableBorrowRate; - uint256 oldTotalStableDebt; - uint256 newPrincipalStableDebt; - uint256 newAvgStableBorrowRate; - uint256 newTotalStableDebt; - uint256 oldLiquidityIndex; - uint256 newLiquidityIndex; - uint256 oldVariableBorrowIndex; - uint256 newVariableBorrowIndex; - uint256 oldLiquidityRate; - uint256 oldVariableBorrowRate; - DataTypes.ReserveConfigurationMap reserveConfiguration; - address aTokenAddress; - address stableDebtTokenAddress; - address variableDebtTokenAddress; - uint40 reserveLastUpdateTimestamp; - uint40 stableDebtLastUpdateTimestamp; - } - - function fetchData(DataTypes.ReserveData storage reserveData) - internal - view - returns (CachingHelper.CachedData memory) - { - CachedData memory cachedData; - - cachedData.reserveConfiguration = reserveData.configuration; - cachedData.oldLiquidityIndex = reserveData.liquidityIndex; - cachedData.oldVariableBorrowIndex = reserveData.variableBorrowIndex; - cachedData.oldLiquidityRate = reserveData.currentLiquidityRate; - cachedData.oldVariableBorrowRate = reserveData.currentVariableBorrowRate; - - cachedData.aTokenAddress = reserveData.aTokenAddress; - cachedData.stableDebtTokenAddress = reserveData.stableDebtTokenAddress; - cachedData.variableDebtTokenAddress = reserveData.variableDebtTokenAddress; - - cachedData.reserveLastUpdateTimestamp = reserveData.lastUpdateTimestamp; - - cachedData.oldScaledVariableDebt = cachedData.newScaledVariableDebt = IVariableDebtToken( - cachedData - .variableDebtTokenAddress - ) - .scaledTotalSupply(); - - ( - cachedData.oldPrincipalStableDebt, - cachedData.oldTotalStableDebt, - cachedData.oldAvgStableBorrowRate, - cachedData.stableDebtLastUpdateTimestamp - ) = IStableDebtToken(cachedData.stableDebtTokenAddress).getSupplyData(); - - cachedData.newPrincipalStableDebt = cachedData.oldPrincipalStableDebt; - cachedData.newTotalStableDebt = cachedData.oldTotalStableDebt; - cachedData.newAvgStableBorrowRate = cachedData.oldAvgStableBorrowRate; - - return cachedData; - } -} diff --git a/contracts/protocol/libraries/logic/ReserveLogic.sol b/contracts/protocol/libraries/logic/ReserveLogic.sol index ac5ff510..2db7fe34 100644 --- a/contracts/protocol/libraries/logic/ReserveLogic.sol +++ b/contracts/protocol/libraries/logic/ReserveLogic.sol @@ -14,7 +14,6 @@ import {WadRayMath} from '../math/WadRayMath.sol'; import {PercentageMath} from '../math/PercentageMath.sol'; import {Errors} from '../helpers/Errors.sol'; import {DataTypes} from '../types/DataTypes.sol'; -import {CachingHelper} from '../helpers/CachingHelper.sol'; /** * @title ReserveLogic library @@ -110,11 +109,10 @@ library ReserveLogic { **/ function updateState( DataTypes.ReserveData storage reserve, - CachingHelper.CachedData memory cachedData + DataTypes.ReserveCache memory reserveCache ) internal { - _updateIndexes(reserve, cachedData); - - _accrueToTreasury(reserve, cachedData); + _updateIndexes(reserve, reserveCache); + _accrueToTreasury(reserve, reserveCache); } /** @@ -181,20 +179,20 @@ library ReserveLogic { **/ function updateInterestRates( DataTypes.ReserveData storage reserve, - CachingHelper.CachedData memory cachedData, + DataTypes.ReserveCache memory reserveCache, address reserveAddress, uint256 liquidityAdded, uint256 liquidityTaken ) internal { UpdateInterestRatesLocalVars memory vars; - if (cachedData.oldTotalStableDebt != cachedData.newTotalStableDebt) { - cachedData.newAvgStableBorrowRate = IStableDebtToken(cachedData.stableDebtTokenAddress) + if (reserveCache.oldTotalStableDebt != reserveCache.newTotalStableDebt) { + reserveCache.newAvgStableBorrowRate = IStableDebtToken(reserveCache.stableDebtTokenAddress) .getAverageStableRate(); } - cachedData.newTotalVariableDebt = cachedData.newScaledVariableDebt.rayMul( - cachedData.newVariableBorrowIndex + reserveCache.newTotalVariableDebt = reserveCache.newScaledVariableDebt.rayMul( + reserveCache.newVariableBorrowIndex ); ( @@ -203,13 +201,13 @@ library ReserveLogic { vars.newVariableRate ) = IReserveInterestRateStrategy(reserve.interestRateStrategyAddress).calculateInterestRates( reserveAddress, - cachedData.aTokenAddress, + reserveCache.aTokenAddress, liquidityAdded, liquidityTaken, - cachedData.newTotalStableDebt, - cachedData.newTotalVariableDebt, - cachedData.newAvgStableBorrowRate, - cachedData.reserveConfiguration.getReserveFactorMemory() + reserveCache.newTotalStableDebt, + reserveCache.newTotalVariableDebt, + reserveCache.newAvgStableBorrowRate, + reserveCache.reserveConfiguration.getReserveFactorMemory() ); require(vars.newLiquidityRate <= type(uint128).max, Errors.RL_LIQUIDITY_RATE_OVERFLOW); require(vars.newStableRate <= type(uint128).max, Errors.RL_STABLE_BORROW_RATE_OVERFLOW); @@ -224,8 +222,8 @@ library ReserveLogic { vars.newLiquidityRate, vars.newStableRate, vars.newVariableRate, - cachedData.newLiquidityIndex, - cachedData.newVariableBorrowIndex + reserveCache.newLiquidityIndex, + reserveCache.newVariableBorrowIndex ); } @@ -247,43 +245,45 @@ library ReserveLogic { * @dev Mints part of the repaid interest to the reserve treasury as a function of the reserveFactor for the * specific asset. * @param reserve The reserve reserve to be updated - * @param cachedData The caching layer for the reserve data + * @param reserveCache The caching layer for the reserve data **/ function _accrueToTreasury( DataTypes.ReserveData storage reserve, - CachingHelper.CachedData memory cachedData + DataTypes.ReserveCache memory reserveCache ) internal { MintToTreasuryLocalVars memory vars; - vars.reserveFactor = cachedData.reserveConfiguration.getReserveFactorMemory(); + vars.reserveFactor = reserveCache.reserveConfiguration.getReserveFactorMemory(); if (vars.reserveFactor == 0) { return; } //calculate the last principal variable debt - vars.previousVariableDebt = cachedData.oldScaledVariableDebt.rayMul( - cachedData.oldVariableBorrowIndex + vars.previousVariableDebt = reserveCache.oldScaledVariableDebt.rayMul( + reserveCache.oldVariableBorrowIndex ); //calculate the new total supply after accumulation of the index - vars.currentVariableDebt = cachedData.oldScaledVariableDebt.rayMul( - cachedData.newVariableBorrowIndex + vars.currentVariableDebt = reserveCache.oldScaledVariableDebt.rayMul( + reserveCache.newVariableBorrowIndex ); //calculate the stable debt until the last timestamp update vars.cumulatedStableInterest = MathUtils.calculateCompoundedInterest( - cachedData.oldAvgStableBorrowRate, - cachedData.stableDebtLastUpdateTimestamp, - cachedData.reserveLastUpdateTimestamp + reserveCache.oldAvgStableBorrowRate, + reserveCache.stableDebtLastUpdateTimestamp, + reserveCache.reserveLastUpdateTimestamp ); - vars.previousStableDebt = cachedData.oldPrincipalStableDebt.rayMul(vars.cumulatedStableInterest); + vars.previousStableDebt = reserveCache.oldPrincipalStableDebt.rayMul( + vars.cumulatedStableInterest + ); //debt accrued is the sum of the current debt minus the sum of the debt at the last update vars.totalDebtAccrued = vars .currentVariableDebt - .add(cachedData.oldTotalStableDebt) + .add(reserveCache.oldTotalStableDebt) .sub(vars.previousVariableDebt) .sub(vars.previousStableDebt); @@ -291,7 +291,7 @@ library ReserveLogic { if (vars.amountToMint != 0) { reserve.accruedToTreasury = reserve.accruedToTreasury.add( - vars.amountToMint.rayDiv(cachedData.newLiquidityIndex) + vars.amountToMint.rayDiv(reserveCache.newLiquidityIndex) ); } } @@ -299,52 +299,90 @@ library ReserveLogic { /** * @dev Updates the reserve indexes and the timestamp of the update * @param reserve The reserve reserve to be updated - * @param cachedData The cache layer holding the cached protocol data + * @param reserveCache The cache layer holding the cached protocol data **/ function _updateIndexes( DataTypes.ReserveData storage reserve, - CachingHelper.CachedData memory cachedData + DataTypes.ReserveCache memory reserveCache ) internal { - cachedData.newLiquidityIndex = cachedData.oldLiquidityIndex; - cachedData.newVariableBorrowIndex = cachedData.oldVariableBorrowIndex; + reserveCache.newLiquidityIndex = reserveCache.oldLiquidityIndex; + reserveCache.newVariableBorrowIndex = reserveCache.oldVariableBorrowIndex; //only cumulating if there is any income being produced - if (cachedData.oldLiquidityRate > 0) { + if (reserveCache.oldLiquidityRate > 0) { uint256 cumulatedLiquidityInterest = MathUtils.calculateLinearInterest( - cachedData.oldLiquidityRate, - cachedData.reserveLastUpdateTimestamp + reserveCache.oldLiquidityRate, + reserveCache.reserveLastUpdateTimestamp ); - cachedData.newLiquidityIndex = cumulatedLiquidityInterest.rayMul( - cachedData.oldLiquidityIndex + reserveCache.newLiquidityIndex = cumulatedLiquidityInterest.rayMul( + reserveCache.oldLiquidityIndex ); require( - cachedData.newLiquidityIndex <= type(uint128).max, + reserveCache.newLiquidityIndex <= type(uint128).max, Errors.RL_LIQUIDITY_INDEX_OVERFLOW ); - - reserve.liquidityIndex = uint128(cachedData.newLiquidityIndex); + reserve.liquidityIndex = uint128(reserveCache.newLiquidityIndex); //as the liquidity rate might come only from stable rate loans, we need to ensure //that there is actual variable debt before accumulating - if (cachedData.oldScaledVariableDebt != 0) { + if (reserveCache.oldScaledVariableDebt != 0) { uint256 cumulatedVariableBorrowInterest = MathUtils.calculateCompoundedInterest( - cachedData.oldVariableBorrowRate, - cachedData.reserveLastUpdateTimestamp + reserveCache.oldVariableBorrowRate, + reserveCache.reserveLastUpdateTimestamp ); - cachedData.newVariableBorrowIndex = cumulatedVariableBorrowInterest.rayMul( - cachedData.oldVariableBorrowIndex + reserveCache.newVariableBorrowIndex = cumulatedVariableBorrowInterest.rayMul( + reserveCache.oldVariableBorrowIndex ); require( - cachedData.newVariableBorrowIndex <= type(uint128).max, + reserveCache.newVariableBorrowIndex <= type(uint128).max, Errors.RL_VARIABLE_BORROW_INDEX_OVERFLOW ); - reserve.variableBorrowIndex = uint128(cachedData.newVariableBorrowIndex); + reserve.variableBorrowIndex = uint128(reserveCache.newVariableBorrowIndex); } } //solium-disable-next-line reserve.lastUpdateTimestamp = uint40(block.timestamp); } + + function cache(DataTypes.ReserveData storage reserve) + internal + view + returns (DataTypes.ReserveCache memory) + { + DataTypes.ReserveCache memory reserveCache; + + reserveCache.reserveConfiguration = reserve.configuration; + reserveCache.oldLiquidityIndex = reserve.liquidityIndex; + reserveCache.oldVariableBorrowIndex = reserve.variableBorrowIndex; + reserveCache.oldLiquidityRate = reserve.currentLiquidityRate; + reserveCache.oldVariableBorrowRate = reserve.currentVariableBorrowRate; + + reserveCache.aTokenAddress = reserve.aTokenAddress; + reserveCache.stableDebtTokenAddress = reserve.stableDebtTokenAddress; + reserveCache.variableDebtTokenAddress = reserve.variableDebtTokenAddress; + + reserveCache.reserveLastUpdateTimestamp = reserve.lastUpdateTimestamp; + + reserveCache.oldScaledVariableDebt = reserveCache.newScaledVariableDebt = IVariableDebtToken( + reserveCache + .variableDebtTokenAddress + ) + .scaledTotalSupply(); + + ( + reserveCache.oldPrincipalStableDebt, + reserveCache.oldTotalStableDebt, + reserveCache.oldAvgStableBorrowRate, + reserveCache.stableDebtLastUpdateTimestamp + ) = IStableDebtToken(reserveCache.stableDebtTokenAddress).getSupplyData(); + + reserveCache.newPrincipalStableDebt = reserveCache.oldPrincipalStableDebt; + reserveCache.newTotalStableDebt = reserveCache.oldTotalStableDebt; + reserveCache.newAvgStableBorrowRate = reserveCache.oldAvgStableBorrowRate; + + return reserveCache; + } } diff --git a/contracts/protocol/libraries/logic/ValidationLogic.sol b/contracts/protocol/libraries/logic/ValidationLogic.sol index 94cc3248..43629f1f 100644 --- a/contracts/protocol/libraries/logic/ValidationLogic.sol +++ b/contracts/protocol/libraries/logic/ValidationLogic.sol @@ -12,7 +12,6 @@ import {SafeERC20} from '../../../dependencies/openzeppelin/contracts/SafeERC20. import {ReserveConfiguration} from '../configuration/ReserveConfiguration.sol'; import {UserConfiguration} from '../configuration/UserConfiguration.sol'; import {Errors} from '../helpers/Errors.sol'; -import {CachingHelper} from '../helpers/CachingHelper.sol'; import {Helpers} from '../helpers/Helpers.sol'; import {IReserveInterestRateStrategy} from '../../../interfaces/IReserveInterestRateStrategy.sol'; import {IVariableDebtToken} from '../../../interfaces/IVariableDebtToken.sol'; @@ -45,13 +44,13 @@ library ValidationLogic { */ function validateDeposit( DataTypes.ReserveData storage reserve, - CachingHelper.CachedData memory cachedData, + DataTypes.ReserveCache memory reserveCache, uint256 amount ) internal view { (bool isActive, bool isFrozen, , , bool isPaused) = - cachedData.reserveConfiguration.getFlagsMemory(); - (, , , uint256 reserveDecimals, ) = cachedData.reserveConfiguration.getParamsMemory(); - uint256 supplyCap = cachedData.reserveConfiguration.getSupplyCapMemory(); + reserveCache.reserveConfiguration.getFlagsMemory(); + (, , , uint256 reserveDecimals, ) = reserveCache.reserveConfiguration.getParamsMemory(); + uint256 supplyCap = reserveCache.reserveConfiguration.getSupplyCapMemory(); require(amount != 0, Errors.VL_INVALID_AMOUNT); require(isActive, Errors.VL_NO_ACTIVE_RESERVE); @@ -59,9 +58,9 @@ library ValidationLogic { require(!isFrozen, Errors.VL_RESERVE_FROZEN); require( supplyCap == 0 || - IAToken(cachedData.aTokenAddress) + IAToken(reserveCache.aTokenAddress) .scaledTotalSupply() - .rayMul(cachedData.newLiquidityIndex) + .rayMul(reserveCache.newLiquidityIndex) .add(amount) .div(10**reserveDecimals) < supplyCap, @@ -77,13 +76,14 @@ library ValidationLogic { */ function validateWithdraw( DataTypes.ReserveData storage reserve, + DataTypes.ReserveCache memory reserveCache, uint256 amount, uint256 userBalance ) external view { require(amount != 0, Errors.VL_INVALID_AMOUNT); require(amount <= userBalance, Errors.VL_NOT_ENOUGH_AVAILABLE_USER_BALANCE); - (bool isActive, , , , bool isPaused) = reserve.configuration.getFlags(); + (bool isActive, , , , bool isPaused) = reserveCache.reserveConfiguration.getFlagsMemory(); require(isActive, Errors.VL_NO_ACTIVE_RESERVE); require(!isPaused, Errors.VL_RESERVE_PAUSED); } @@ -122,7 +122,7 @@ library ValidationLogic { */ function validateBorrow( - CachingHelper.CachedData memory cachedData, + DataTypes.ReserveCache memory reserveCache, address asset, address userAddress, uint256 amount, @@ -136,7 +136,7 @@ library ValidationLogic { ) external view { ValidateBorrowLocalVars memory vars; - (, , , vars.reserveDecimals, ) = cachedData.reserveConfiguration.getParamsMemory(); + (, , , vars.reserveDecimals, ) = reserveCache.reserveConfiguration.getParamsMemory(); ( vars.isActive, @@ -144,7 +144,7 @@ library ValidationLogic { vars.borrowingEnabled, vars.stableRateBorrowingEnabled, vars.isPaused - ) = cachedData.reserveConfiguration.getFlagsMemory(); + ) = reserveCache.reserveConfiguration.getFlagsMemory(); require(vars.isActive, Errors.VL_NO_ACTIVE_RESERVE); require(!vars.isPaused, Errors.VL_RESERVE_PAUSED); @@ -160,15 +160,15 @@ library ValidationLogic { Errors.VL_INVALID_INTEREST_RATE_MODE_SELECTED ); - vars.borrowCap = cachedData.reserveConfiguration.getBorrowCapMemory(); + vars.borrowCap = reserveCache.reserveConfiguration.getBorrowCapMemory(); if (vars.borrowCap > 0) { { - vars.totalSupplyVariableDebt = cachedData.oldScaledVariableDebt.rayMul( - cachedData.newVariableBorrowIndex + vars.totalSupplyVariableDebt = reserveCache.oldScaledVariableDebt.rayMul( + reserveCache.newVariableBorrowIndex ); - vars.totalDebt = cachedData.oldTotalStableDebt.add(vars.totalSupplyVariableDebt).add( + vars.totalDebt = reserveCache.oldTotalStableDebt.add(vars.totalSupplyVariableDebt).add( amount ); require( @@ -228,12 +228,12 @@ library ValidationLogic { require( !userConfig.isUsingAsCollateral(reservesData[asset].id) || - cachedData.reserveConfiguration.getLtvMemory() == 0 || - amount > IERC20(cachedData.aTokenAddress).balanceOf(userAddress), + reserveCache.reserveConfiguration.getLtvMemory() == 0 || + amount > IERC20(reserveCache.aTokenAddress).balanceOf(userAddress), Errors.VL_COLLATERAL_SAME_AS_BORROWING_CURRENCY ); - vars.availableLiquidity = IERC20(asset).balanceOf(cachedData.aTokenAddress); + vars.availableLiquidity = IERC20(asset).balanceOf(reserveCache.aTokenAddress); //calculate the max available loan size in stable rate mode as a percentage of the //available liquidity @@ -253,13 +253,14 @@ library ValidationLogic { */ function validateRepay( DataTypes.ReserveData storage reserve, + DataTypes.ReserveCache memory reserveCache, uint256 amountSent, DataTypes.InterestRateMode rateMode, address onBehalfOf, uint256 stableDebt, uint256 variableDebt ) external view { - (bool isActive, , , , bool isPaused) = reserve.configuration.getFlags(); + (bool isActive, , , , bool isPaused) = reserveCache.reserveConfiguration.getFlagsMemory(); require(isActive, Errors.VL_NO_ACTIVE_RESERVE); require(!isPaused, Errors.VL_RESERVE_PAUSED); @@ -289,13 +290,14 @@ library ValidationLogic { */ function validateSwapRateMode( DataTypes.ReserveData storage reserve, + DataTypes.ReserveCache memory reserveCache, DataTypes.UserConfigurationMap storage userConfig, uint256 stableDebt, uint256 variableDebt, DataTypes.InterestRateMode currentRateMode ) external view { (bool isActive, bool isFrozen, , bool stableRateEnabled, bool isPaused) = - reserve.configuration.getFlags(); + reserveCache.reserveConfiguration.getFlagsMemory(); require(isActive, Errors.VL_NO_ACTIVE_RESERVE); require(!isPaused, Errors.VL_RESERVE_PAUSED); @@ -316,8 +318,8 @@ library ValidationLogic { require( !userConfig.isUsingAsCollateral(reserve.id) || - reserve.configuration.getLtv() == 0 || - stableDebt.add(variableDebt) > IERC20(reserve.aTokenAddress).balanceOf(msg.sender), + reserveCache.reserveConfiguration.getLtvMemory() == 0 || + stableDebt.add(variableDebt) > IERC20(reserveCache.aTokenAddress).balanceOf(msg.sender), Errors.VL_COLLATERAL_SAME_AS_BORROWING_CURRENCY ); } else { @@ -335,12 +337,13 @@ library ValidationLogic { */ function validateRebalanceStableBorrowRate( DataTypes.ReserveData storage reserve, + DataTypes.ReserveCache memory reserveCache, address reserveAddress, IERC20 stableDebtToken, IERC20 variableDebtToken, address aTokenAddress ) external view { - (bool isActive, , , , bool isPaused) = reserve.configuration.getFlags(); + (bool isActive, , , , bool isPaused) = reserveCache.reserveConfiguration.getFlagsMemory(); require(isActive, Errors.VL_NO_ACTIVE_RESERVE); require(!isPaused, Errors.VL_RESERVE_PAUSED); @@ -354,7 +357,7 @@ library ValidationLogic { //if the liquidity rate is below REBALANCE_UP_THRESHOLD of the max variable APR at 95% usage, //then we allow rebalancing of the stable rate positions. - uint256 currentLiquidityRate = reserve.currentLiquidityRate; + uint256 currentLiquidityRate = reserveCache.oldLiquidityRate; uint256 maxVariableBorrowRate = IReserveInterestRateStrategy(reserve.interestRateStrategyAddress).getMaxVariableBorrowRate(); @@ -370,10 +373,14 @@ library ValidationLogic { * @dev Validates the action of setting an asset as collateral * @param reserve The state of the reserve that the user is enabling or disabling as collateral */ - function validateSetUseReserveAsCollateral(DataTypes.ReserveData storage reserve) external view { - uint256 underlyingBalance = IERC20(reserve.aTokenAddress).balanceOf(msg.sender); - bool isPaused = reserve.configuration.getPaused(); + function validateSetUseReserveAsCollateral( + DataTypes.ReserveData storage reserve, + DataTypes.ReserveCache memory reserveCache + ) external view { + uint256 underlyingBalance = IERC20(reserveCache.aTokenAddress).balanceOf(msg.sender); + (bool isActive, , , , bool isPaused) = reserveCache.reserveConfiguration.getFlagsMemory(); + require(isActive, Errors.VL_NO_ACTIVE_RESERVE); require(!isPaused, Errors.VL_RESERVE_PAUSED); require(underlyingBalance > 0, Errors.VL_UNDERLYING_BALANCE_NOT_GREATER_THAN_0); @@ -407,20 +414,26 @@ library ValidationLogic { function validateLiquidationCall( DataTypes.ReserveData storage collateralReserve, DataTypes.ReserveData storage principalReserve, + DataTypes.ReserveCache memory collateralReserveCache, + DataTypes.ReserveCache memory principalReserveCache, DataTypes.UserConfigurationMap storage userConfig, uint256 userHealthFactor, uint256 userStableDebt, uint256 userVariableDebt ) internal view returns (uint256, string memory) { - if ( - !collateralReserve.configuration.getActive() || !principalReserve.configuration.getActive() - ) { + (bool collateralReserveActive, , , , bool collateralReservePaused) = + collateralReserveCache.reserveConfiguration.getFlagsMemory(); + + (bool principalReserveActive, , , , bool principalReservePaused) = + collateralReserveCache.reserveConfiguration.getFlagsMemory(); + + if (!collateralReserveActive || !principalReserveActive) { return ( uint256(Errors.CollateralManagerErrors.NO_ACTIVE_RESERVE), Errors.VL_NO_ACTIVE_RESERVE ); } - if (collateralReserve.configuration.getPaused() || principalReserve.configuration.getPaused()) { + if (collateralReservePaused || principalReservePaused) { return (uint256(Errors.CollateralManagerErrors.PAUSED_RESERVE), Errors.VL_RESERVE_PAUSED); } @@ -432,7 +445,7 @@ library ValidationLogic { } bool isCollateralEnabled = - collateralReserve.configuration.getLiquidationThreshold() > 0 && + collateralReserveCache.reserveConfiguration.getLiquidationThresholdMemory() > 0 && userConfig.isUsingAsCollateral(collateralReserve.id); //if collateral isn't enabled as collateral by user, it cannot be liquidated diff --git a/contracts/protocol/libraries/types/DataTypes.sol b/contracts/protocol/libraries/types/DataTypes.sol index 5daa68b1..fd05fa89 100644 --- a/contracts/protocol/libraries/types/DataTypes.sol +++ b/contracts/protocol/libraries/types/DataTypes.sol @@ -51,4 +51,29 @@ library DataTypes { } enum InterestRateMode {NONE, STABLE, VARIABLE} + + struct ReserveCache { + uint256 oldScaledVariableDebt; + uint256 oldTotalVariableDebt; + uint256 newScaledVariableDebt; + uint256 newTotalVariableDebt; + uint256 oldPrincipalStableDebt; + uint256 oldAvgStableBorrowRate; + uint256 oldTotalStableDebt; + uint256 newPrincipalStableDebt; + uint256 newAvgStableBorrowRate; + uint256 newTotalStableDebt; + uint256 oldLiquidityIndex; + uint256 newLiquidityIndex; + uint256 oldVariableBorrowIndex; + uint256 newVariableBorrowIndex; + uint256 oldLiquidityRate; + uint256 oldVariableBorrowRate; + DataTypes.ReserveConfigurationMap reserveConfiguration; + address aTokenAddress; + address stableDebtTokenAddress; + address variableDebtTokenAddress; + uint40 reserveLastUpdateTimestamp; + uint40 stableDebtLastUpdateTimestamp; + } } diff --git a/package-lock.json b/package-lock.json index ad482fe2..7f3c76fd 100644 --- a/package-lock.json +++ b/package-lock.json @@ -11142,14 +11142,6 @@ "requires": { "min-document": "^2.19.0", "process": "^0.11.10" - }, - "dependencies": { - "process": { - "version": "0.5.2", - "resolved": "https://registry.npmjs.org/process/-/process-0.5.2.tgz", - "integrity": "sha1-FjjYqONML0QKkduVq5rrZ3/Bhc8=", - "dev": true - } } }, "got": { @@ -12794,6 +12786,12 @@ "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==", "dev": true }, + "process": { + "version": "0.11.10", + "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", + "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=", + "dev": true + }, "process-nextick-args": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", From b8fb9e592fcfaee4f38aead0135f46df10658e02 Mon Sep 17 00:00:00 2001 From: emilio Date: Tue, 8 Jun 2021 10:44:16 +0200 Subject: [PATCH 05/13] refactor: updated cache field names --- .../protocol/lendingpool/LendingPool.sol | 46 +++++----- .../LendingPoolCollateralManager.sol | 18 ++-- .../protocol/libraries/logic/ReserveLogic.sol | 84 +++++++++---------- .../libraries/logic/ValidationLogic.sol | 14 ++-- .../protocol/libraries/types/DataTypes.sol | 31 ++++--- 5 files changed, 96 insertions(+), 97 deletions(-) diff --git a/contracts/protocol/lendingpool/LendingPool.sol b/contracts/protocol/lendingpool/LendingPool.sol index 1c5f4208..24a9ae4b 100644 --- a/contracts/protocol/lendingpool/LendingPool.sol +++ b/contracts/protocol/lendingpool/LendingPool.sol @@ -289,27 +289,27 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage if (interestRateMode == DataTypes.InterestRateMode.STABLE) { IStableDebtToken(reserveCache.stableDebtTokenAddress).burn(msg.sender, stableDebt); - reserveCache.newPrincipalStableDebt = reserveCache.newTotalStableDebt = reserveCache - .oldTotalStableDebt + reserveCache.nextPrincipalStableDebt = reserveCache.nextTotalStableDebt = reserveCache + .currTotalStableDebt .sub(stableDebt); IVariableDebtToken(reserveCache.variableDebtTokenAddress).mint( msg.sender, msg.sender, stableDebt, - reserveCache.newVariableBorrowIndex + reserveCache.nextVariableBorrowIndex ); - reserveCache.newScaledVariableDebt = reserveCache.oldScaledVariableDebt.add( - stableDebt.rayDiv(reserveCache.newVariableBorrowIndex) + reserveCache.nextScaledVariableDebt = reserveCache.currScaledVariableDebt.add( + stableDebt.rayDiv(reserveCache.nextVariableBorrowIndex) ); } else { IVariableDebtToken(reserveCache.variableDebtTokenAddress).burn( msg.sender, variableDebt, - reserveCache.newVariableBorrowIndex + reserveCache.nextVariableBorrowIndex ); - reserveCache.newScaledVariableDebt = reserveCache.oldScaledVariableDebt.sub( - variableDebt.rayDiv(reserveCache.newVariableBorrowIndex) + reserveCache.nextScaledVariableDebt = reserveCache.currScaledVariableDebt.sub( + variableDebt.rayDiv(reserveCache.nextVariableBorrowIndex) ); IStableDebtToken(reserveCache.stableDebtTokenAddress).mint( @@ -319,8 +319,8 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage reserve.currentStableBorrowRate ); - reserveCache.newPrincipalStableDebt = reserveCache.newTotalStableDebt = reserveCache - .oldTotalStableDebt + reserveCache.nextPrincipalStableDebt = reserveCache.nextTotalStableDebt = reserveCache + .currTotalStableDebt .add(stableDebt); } @@ -927,8 +927,8 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage currentStableRate ); - reserveCache.newPrincipalStableDebt = reserveCache.newTotalStableDebt = reserveCache - .oldTotalStableDebt + reserveCache.nextPrincipalStableDebt = reserveCache.nextTotalStableDebt = reserveCache + .currTotalStableDebt .add(vars.amount); } else { @@ -936,11 +936,11 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage vars.user, vars.onBehalfOf, vars.amount, - reserveCache.newVariableBorrowIndex + reserveCache.nextVariableBorrowIndex ); - reserveCache.newScaledVariableDebt = reserveCache.newScaledVariableDebt.add( - vars.amount.rayDiv(reserveCache.newVariableBorrowIndex) + reserveCache.nextScaledVariableDebt = reserveCache.nextScaledVariableDebt.add( + vars.amount.rayDiv(reserveCache.nextVariableBorrowIndex) ); } @@ -990,7 +990,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage IERC20(asset).safeTransferFrom(msg.sender, reserveCache.aTokenAddress, amount); bool isFirstDeposit = - IAToken(reserveCache.aTokenAddress).mint(onBehalfOf, amount, reserveCache.newLiquidityIndex); + IAToken(reserveCache.aTokenAddress).mint(onBehalfOf, amount, reserveCache.nextLiquidityIndex); if (isFirstDeposit) { _usersConfig[onBehalfOf].setUsingAsCollateral(reserve.id, true); @@ -1013,7 +1013,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage uint256 userBalance = IAToken(reserveCache.aTokenAddress).scaledBalanceOf(msg.sender).rayMul( - reserveCache.newLiquidityIndex + reserveCache.nextLiquidityIndex ); uint256 amountToWithdraw = amount; @@ -1030,7 +1030,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage msg.sender, to, amountToWithdraw, - reserveCache.newLiquidityIndex + reserveCache.nextLiquidityIndex ); if (userConfig.isUsingAsCollateral(reserve.id)) { @@ -1090,17 +1090,17 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage if (interestRateMode == DataTypes.InterestRateMode.STABLE) { IStableDebtToken(reserveCache.stableDebtTokenAddress).burn(onBehalfOf, paybackAmount); - reserveCache.newPrincipalStableDebt = reserveCache.newTotalStableDebt = reserveCache - .oldTotalStableDebt + reserveCache.nextPrincipalStableDebt = reserveCache.nextTotalStableDebt = reserveCache + .currTotalStableDebt .sub(paybackAmount); } else { IVariableDebtToken(reserveCache.variableDebtTokenAddress).burn( onBehalfOf, paybackAmount, - reserveCache.newVariableBorrowIndex + reserveCache.nextVariableBorrowIndex ); - reserveCache.newScaledVariableDebt = reserveCache.oldScaledVariableDebt.sub( - paybackAmount.rayDiv(reserveCache.newVariableBorrowIndex) + reserveCache.nextScaledVariableDebt = reserveCache.currScaledVariableDebt.sub( + paybackAmount.rayDiv(reserveCache.nextVariableBorrowIndex) ); } diff --git a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol index 2f6b0bcb..19908705 100644 --- a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol +++ b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol @@ -171,10 +171,10 @@ contract LendingPoolCollateralManager is IVariableDebtToken(debtReserveCache.variableDebtTokenAddress).burn( user, vars.actualDebtToLiquidate, - debtReserveCache.newVariableBorrowIndex + debtReserveCache.nextVariableBorrowIndex ); - debtReserveCache.newScaledVariableDebt = debtReserveCache.oldScaledVariableDebt.sub( - vars.actualDebtToLiquidate.rayDiv(debtReserveCache.newVariableBorrowIndex) + debtReserveCache.nextScaledVariableDebt = debtReserveCache.currScaledVariableDebt.sub( + vars.actualDebtToLiquidate.rayDiv(debtReserveCache.nextVariableBorrowIndex) ); } else { // If the user doesn't have variable debt, no need to try to burn variable debt tokens @@ -182,19 +182,19 @@ contract LendingPoolCollateralManager is IVariableDebtToken(debtReserveCache.variableDebtTokenAddress).burn( user, vars.userVariableDebt, - debtReserveCache.newVariableBorrowIndex + debtReserveCache.nextVariableBorrowIndex ); - debtReserveCache.newScaledVariableDebt = debtReserveCache - .oldScaledVariableDebt - .sub(vars.userVariableDebt.rayDiv(debtReserveCache.newVariableBorrowIndex)); + debtReserveCache.nextScaledVariableDebt = debtReserveCache + .currScaledVariableDebt + .sub(vars.userVariableDebt.rayDiv(debtReserveCache.nextVariableBorrowIndex)); } IStableDebtToken(debtReserveCache.stableDebtTokenAddress).burn( user, vars.actualDebtToLiquidate.sub(vars.userVariableDebt) ); - debtReserveCache.newPrincipalStableDebt = debtReserveCache - .newTotalStableDebt = debtReserveCache.oldTotalStableDebt.sub( + debtReserveCache.nextPrincipalStableDebt = debtReserveCache + .nextTotalStableDebt = debtReserveCache.currTotalStableDebt.sub( vars.actualDebtToLiquidate.sub(vars.userVariableDebt) ); } diff --git a/contracts/protocol/libraries/logic/ReserveLogic.sol b/contracts/protocol/libraries/logic/ReserveLogic.sol index 2db7fe34..1db225ac 100644 --- a/contracts/protocol/libraries/logic/ReserveLogic.sol +++ b/contracts/protocol/libraries/logic/ReserveLogic.sol @@ -186,13 +186,13 @@ library ReserveLogic { ) internal { UpdateInterestRatesLocalVars memory vars; - if (reserveCache.oldTotalStableDebt != reserveCache.newTotalStableDebt) { - reserveCache.newAvgStableBorrowRate = IStableDebtToken(reserveCache.stableDebtTokenAddress) + if (reserveCache.currTotalStableDebt != reserveCache.nextTotalStableDebt) { + reserveCache.nextAvgStableBorrowRate = IStableDebtToken(reserveCache.stableDebtTokenAddress) .getAverageStableRate(); } - reserveCache.newTotalVariableDebt = reserveCache.newScaledVariableDebt.rayMul( - reserveCache.newVariableBorrowIndex + reserveCache.nextTotalVariableDebt = reserveCache.nextScaledVariableDebt.rayMul( + reserveCache.nextVariableBorrowIndex ); ( @@ -204,9 +204,9 @@ library ReserveLogic { reserveCache.aTokenAddress, liquidityAdded, liquidityTaken, - reserveCache.newTotalStableDebt, - reserveCache.newTotalVariableDebt, - reserveCache.newAvgStableBorrowRate, + reserveCache.nextTotalStableDebt, + reserveCache.nextTotalVariableDebt, + reserveCache.nextAvgStableBorrowRate, reserveCache.reserveConfiguration.getReserveFactorMemory() ); require(vars.newLiquidityRate <= type(uint128).max, Errors.RL_LIQUIDITY_RATE_OVERFLOW); @@ -222,8 +222,8 @@ library ReserveLogic { vars.newLiquidityRate, vars.newStableRate, vars.newVariableRate, - reserveCache.newLiquidityIndex, - reserveCache.newVariableBorrowIndex + reserveCache.nextLiquidityIndex, + reserveCache.nextVariableBorrowIndex ); } @@ -260,30 +260,30 @@ library ReserveLogic { } //calculate the last principal variable debt - vars.previousVariableDebt = reserveCache.oldScaledVariableDebt.rayMul( - reserveCache.oldVariableBorrowIndex + vars.previousVariableDebt = reserveCache.currScaledVariableDebt.rayMul( + reserveCache.currVariableBorrowIndex ); //calculate the new total supply after accumulation of the index - vars.currentVariableDebt = reserveCache.oldScaledVariableDebt.rayMul( - reserveCache.newVariableBorrowIndex + vars.currentVariableDebt = reserveCache.currScaledVariableDebt.rayMul( + reserveCache.nextVariableBorrowIndex ); //calculate the stable debt until the last timestamp update vars.cumulatedStableInterest = MathUtils.calculateCompoundedInterest( - reserveCache.oldAvgStableBorrowRate, + reserveCache.currAvgStableBorrowRate, reserveCache.stableDebtLastUpdateTimestamp, reserveCache.reserveLastUpdateTimestamp ); - vars.previousStableDebt = reserveCache.oldPrincipalStableDebt.rayMul( + vars.previousStableDebt = reserveCache.currPrincipalStableDebt.rayMul( vars.cumulatedStableInterest ); //debt accrued is the sum of the current debt minus the sum of the debt at the last update vars.totalDebtAccrued = vars .currentVariableDebt - .add(reserveCache.oldTotalStableDebt) + .add(reserveCache.currTotalStableDebt) .sub(vars.previousVariableDebt) .sub(vars.previousStableDebt); @@ -291,7 +291,7 @@ library ReserveLogic { if (vars.amountToMint != 0) { reserve.accruedToTreasury = reserve.accruedToTreasury.add( - vars.amountToMint.rayDiv(reserveCache.newLiquidityIndex) + vars.amountToMint.rayDiv(reserveCache.nextLiquidityIndex) ); } } @@ -305,41 +305,41 @@ library ReserveLogic { DataTypes.ReserveData storage reserve, DataTypes.ReserveCache memory reserveCache ) internal { - reserveCache.newLiquidityIndex = reserveCache.oldLiquidityIndex; - reserveCache.newVariableBorrowIndex = reserveCache.oldVariableBorrowIndex; + reserveCache.nextLiquidityIndex = reserveCache.currLiquidityIndex; + reserveCache.nextVariableBorrowIndex = reserveCache.currVariableBorrowIndex; //only cumulating if there is any income being produced - if (reserveCache.oldLiquidityRate > 0) { + if (reserveCache.currLiquidityRate > 0) { uint256 cumulatedLiquidityInterest = MathUtils.calculateLinearInterest( - reserveCache.oldLiquidityRate, + reserveCache.currLiquidityRate, reserveCache.reserveLastUpdateTimestamp ); - reserveCache.newLiquidityIndex = cumulatedLiquidityInterest.rayMul( - reserveCache.oldLiquidityIndex + reserveCache.nextLiquidityIndex = cumulatedLiquidityInterest.rayMul( + reserveCache.currLiquidityIndex ); require( - reserveCache.newLiquidityIndex <= type(uint128).max, + reserveCache.nextLiquidityIndex <= type(uint128).max, Errors.RL_LIQUIDITY_INDEX_OVERFLOW ); - reserve.liquidityIndex = uint128(reserveCache.newLiquidityIndex); + reserve.liquidityIndex = uint128(reserveCache.nextLiquidityIndex); //as the liquidity rate might come only from stable rate loans, we need to ensure //that there is actual variable debt before accumulating - if (reserveCache.oldScaledVariableDebt != 0) { + if (reserveCache.currScaledVariableDebt != 0) { uint256 cumulatedVariableBorrowInterest = MathUtils.calculateCompoundedInterest( - reserveCache.oldVariableBorrowRate, + reserveCache.currVariableBorrowRate, reserveCache.reserveLastUpdateTimestamp ); - reserveCache.newVariableBorrowIndex = cumulatedVariableBorrowInterest.rayMul( - reserveCache.oldVariableBorrowIndex + reserveCache.nextVariableBorrowIndex = cumulatedVariableBorrowInterest.rayMul( + reserveCache.currVariableBorrowIndex ); require( - reserveCache.newVariableBorrowIndex <= type(uint128).max, + reserveCache.nextVariableBorrowIndex <= type(uint128).max, Errors.RL_VARIABLE_BORROW_INDEX_OVERFLOW ); - reserve.variableBorrowIndex = uint128(reserveCache.newVariableBorrowIndex); + reserve.variableBorrowIndex = uint128(reserveCache.nextVariableBorrowIndex); } } @@ -355,10 +355,10 @@ library ReserveLogic { DataTypes.ReserveCache memory reserveCache; reserveCache.reserveConfiguration = reserve.configuration; - reserveCache.oldLiquidityIndex = reserve.liquidityIndex; - reserveCache.oldVariableBorrowIndex = reserve.variableBorrowIndex; - reserveCache.oldLiquidityRate = reserve.currentLiquidityRate; - reserveCache.oldVariableBorrowRate = reserve.currentVariableBorrowRate; + reserveCache.currLiquidityIndex = reserve.liquidityIndex; + reserveCache.currVariableBorrowIndex = reserve.variableBorrowIndex; + reserveCache.currLiquidityRate = reserve.currentLiquidityRate; + reserveCache.currVariableBorrowRate = reserve.currentVariableBorrowRate; reserveCache.aTokenAddress = reserve.aTokenAddress; reserveCache.stableDebtTokenAddress = reserve.stableDebtTokenAddress; @@ -366,22 +366,22 @@ library ReserveLogic { reserveCache.reserveLastUpdateTimestamp = reserve.lastUpdateTimestamp; - reserveCache.oldScaledVariableDebt = reserveCache.newScaledVariableDebt = IVariableDebtToken( + reserveCache.currScaledVariableDebt = reserveCache.nextScaledVariableDebt = IVariableDebtToken( reserveCache .variableDebtTokenAddress ) .scaledTotalSupply(); ( - reserveCache.oldPrincipalStableDebt, - reserveCache.oldTotalStableDebt, - reserveCache.oldAvgStableBorrowRate, + reserveCache.currPrincipalStableDebt, + reserveCache.currTotalStableDebt, + reserveCache.currAvgStableBorrowRate, reserveCache.stableDebtLastUpdateTimestamp ) = IStableDebtToken(reserveCache.stableDebtTokenAddress).getSupplyData(); - reserveCache.newPrincipalStableDebt = reserveCache.oldPrincipalStableDebt; - reserveCache.newTotalStableDebt = reserveCache.oldTotalStableDebt; - reserveCache.newAvgStableBorrowRate = reserveCache.oldAvgStableBorrowRate; + reserveCache.nextPrincipalStableDebt = reserveCache.currPrincipalStableDebt; + reserveCache.nextTotalStableDebt = reserveCache.currTotalStableDebt; + reserveCache.nextAvgStableBorrowRate = reserveCache.currAvgStableBorrowRate; return reserveCache; } diff --git a/contracts/protocol/libraries/logic/ValidationLogic.sol b/contracts/protocol/libraries/logic/ValidationLogic.sol index 43629f1f..37f0c6a8 100644 --- a/contracts/protocol/libraries/logic/ValidationLogic.sol +++ b/contracts/protocol/libraries/logic/ValidationLogic.sol @@ -60,7 +60,7 @@ library ValidationLogic { supplyCap == 0 || IAToken(reserveCache.aTokenAddress) .scaledTotalSupply() - .rayMul(reserveCache.newLiquidityIndex) + .rayMul(reserveCache.nextLiquidityIndex) .add(amount) .div(10**reserveDecimals) < supplyCap, @@ -79,7 +79,7 @@ library ValidationLogic { DataTypes.ReserveCache memory reserveCache, uint256 amount, uint256 userBalance - ) external view { + ) internal view { require(amount != 0, Errors.VL_INVALID_AMOUNT); require(amount <= userBalance, Errors.VL_NOT_ENOUGH_AVAILABLE_USER_BALANCE); @@ -162,13 +162,13 @@ library ValidationLogic { vars.borrowCap = reserveCache.reserveConfiguration.getBorrowCapMemory(); - if (vars.borrowCap > 0) { + if (vars.borrowCap != 0) { { - vars.totalSupplyVariableDebt = reserveCache.oldScaledVariableDebt.rayMul( - reserveCache.newVariableBorrowIndex + vars.totalSupplyVariableDebt = reserveCache.currScaledVariableDebt.rayMul( + reserveCache.nextVariableBorrowIndex ); - vars.totalDebt = reserveCache.oldTotalStableDebt.add(vars.totalSupplyVariableDebt).add( + vars.totalDebt = reserveCache.currTotalStableDebt.add(vars.totalSupplyVariableDebt).add( amount ); require( @@ -357,7 +357,7 @@ library ValidationLogic { //if the liquidity rate is below REBALANCE_UP_THRESHOLD of the max variable APR at 95% usage, //then we allow rebalancing of the stable rate positions. - uint256 currentLiquidityRate = reserveCache.oldLiquidityRate; + uint256 currentLiquidityRate = reserveCache.currLiquidityRate; uint256 maxVariableBorrowRate = IReserveInterestRateStrategy(reserve.interestRateStrategyAddress).getMaxVariableBorrowRate(); diff --git a/contracts/protocol/libraries/types/DataTypes.sol b/contracts/protocol/libraries/types/DataTypes.sol index fd05fa89..4a2ce981 100644 --- a/contracts/protocol/libraries/types/DataTypes.sol +++ b/contracts/protocol/libraries/types/DataTypes.sol @@ -53,22 +53,21 @@ library DataTypes { enum InterestRateMode {NONE, STABLE, VARIABLE} struct ReserveCache { - uint256 oldScaledVariableDebt; - uint256 oldTotalVariableDebt; - uint256 newScaledVariableDebt; - uint256 newTotalVariableDebt; - uint256 oldPrincipalStableDebt; - uint256 oldAvgStableBorrowRate; - uint256 oldTotalStableDebt; - uint256 newPrincipalStableDebt; - uint256 newAvgStableBorrowRate; - uint256 newTotalStableDebt; - uint256 oldLiquidityIndex; - uint256 newLiquidityIndex; - uint256 oldVariableBorrowIndex; - uint256 newVariableBorrowIndex; - uint256 oldLiquidityRate; - uint256 oldVariableBorrowRate; + uint256 currScaledVariableDebt; + uint256 nextScaledVariableDebt; + uint256 nextTotalVariableDebt; + uint256 currPrincipalStableDebt; + uint256 currAvgStableBorrowRate; + uint256 currTotalStableDebt; + uint256 nextPrincipalStableDebt; + uint256 nextAvgStableBorrowRate; + uint256 nextTotalStableDebt; + uint256 currLiquidityIndex; + uint256 nextLiquidityIndex; + uint256 currVariableBorrowIndex; + uint256 nextVariableBorrowIndex; + uint256 currLiquidityRate; + uint256 currVariableBorrowRate; DataTypes.ReserveConfigurationMap reserveConfiguration; address aTokenAddress; address stableDebtTokenAddress; From 61217d1ee5ef81e1cf2bb496b37005725ff700a2 Mon Sep 17 00:00:00 2001 From: emilio Date: Thu, 10 Jun 2021 18:18:01 +0200 Subject: [PATCH 06/13] refactor: further refactored the caching logic --- .../protocol/lendingpool/LendingPool.sol | 42 ++++----------- .../LendingPoolCollateralManager.sol | 30 +++++------ .../protocol/libraries/logic/ReserveLogic.sol | 52 +++++++++++++------ package-lock.json | 2 +- 4 files changed, 60 insertions(+), 66 deletions(-) diff --git a/contracts/protocol/lendingpool/LendingPool.sol b/contracts/protocol/lendingpool/LendingPool.sol index 24a9ae4b..f349d412 100644 --- a/contracts/protocol/lendingpool/LendingPool.sol +++ b/contracts/protocol/lendingpool/LendingPool.sol @@ -49,6 +49,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage using WadRayMath for uint256; using PercentageMath for uint256; using SafeERC20 for IERC20; + using ReserveLogic for DataTypes.ReserveCache; uint256 public constant LENDINGPOOL_REVISION = 0x2; @@ -288,40 +289,26 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage if (interestRateMode == DataTypes.InterestRateMode.STABLE) { IStableDebtToken(reserveCache.stableDebtTokenAddress).burn(msg.sender, stableDebt); - - reserveCache.nextPrincipalStableDebt = reserveCache.nextTotalStableDebt = reserveCache - .currTotalStableDebt - .sub(stableDebt); - IVariableDebtToken(reserveCache.variableDebtTokenAddress).mint( msg.sender, msg.sender, stableDebt, reserveCache.nextVariableBorrowIndex ); - reserveCache.nextScaledVariableDebt = reserveCache.currScaledVariableDebt.add( - stableDebt.rayDiv(reserveCache.nextVariableBorrowIndex) - ); + reserveCache.refreshDebt(0, stableDebt, stableDebt, 0); } else { IVariableDebtToken(reserveCache.variableDebtTokenAddress).burn( msg.sender, variableDebt, reserveCache.nextVariableBorrowIndex ); - reserveCache.nextScaledVariableDebt = reserveCache.currScaledVariableDebt.sub( - variableDebt.rayDiv(reserveCache.nextVariableBorrowIndex) - ); - IStableDebtToken(reserveCache.stableDebtTokenAddress).mint( msg.sender, msg.sender, variableDebt, reserve.currentStableBorrowRate ); - - reserveCache.nextPrincipalStableDebt = reserveCache.nextTotalStableDebt = reserveCache - .currTotalStableDebt - .add(stableDebt); + reserveCache.refreshDebt(variableDebt, 0, 0, variableDebt); } reserve.updateInterestRates(reserveCache, asset, 0, 0); @@ -365,6 +352,8 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage reserve.currentStableBorrowRate ); + reserveCache.refreshDebt(stableDebt, stableDebt, 0, 0); + reserve.updateInterestRates(reserveCache, asset, 0, 0); emit RebalanceStableBorrowRate(asset, user); @@ -915,8 +904,8 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage ); uint256 currentStableRate = 0; - bool isFirstBorrowing = false; + if (DataTypes.InterestRateMode(vars.interestRateMode) == DataTypes.InterestRateMode.STABLE) { currentStableRate = reserve.currentStableBorrowRate; @@ -926,11 +915,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage vars.amount, currentStableRate ); - - reserveCache.nextPrincipalStableDebt = reserveCache.nextTotalStableDebt = reserveCache - .currTotalStableDebt - .add(vars.amount); - + reserveCache.refreshDebt(vars.amount, 0, 0, 0); } else { isFirstBorrowing = IVariableDebtToken(reserveCache.variableDebtTokenAddress).mint( vars.user, @@ -938,10 +923,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage vars.amount, reserveCache.nextVariableBorrowIndex ); - - reserveCache.nextScaledVariableDebt = reserveCache.nextScaledVariableDebt.add( - vars.amount.rayDiv(reserveCache.nextVariableBorrowIndex) - ); + reserveCache.refreshDebt(0, 0, vars.amount, 0); } if (isFirstBorrowing) { @@ -1090,18 +1072,14 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage if (interestRateMode == DataTypes.InterestRateMode.STABLE) { IStableDebtToken(reserveCache.stableDebtTokenAddress).burn(onBehalfOf, paybackAmount); - reserveCache.nextPrincipalStableDebt = reserveCache.nextTotalStableDebt = reserveCache - .currTotalStableDebt - .sub(paybackAmount); + reserveCache.refreshDebt(0, paybackAmount, 0, 0); } else { IVariableDebtToken(reserveCache.variableDebtTokenAddress).burn( onBehalfOf, paybackAmount, reserveCache.nextVariableBorrowIndex ); - reserveCache.nextScaledVariableDebt = reserveCache.currScaledVariableDebt.sub( - paybackAmount.rayDiv(reserveCache.nextVariableBorrowIndex) - ); + reserveCache.refreshDebt(0, 0, 0, paybackAmount); } reserve.updateInterestRates(reserveCache, asset, paybackAmount, 0); diff --git a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol index 19908705..b757f9de 100644 --- a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol +++ b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol @@ -10,6 +10,7 @@ import {IPriceOracleGetter} from '../../interfaces/IPriceOracleGetter.sol'; import {ILendingPoolCollateralManager} from '../../interfaces/ILendingPoolCollateralManager.sol'; import {VersionedInitializable} from '../libraries/aave-upgradeability/VersionedInitializable.sol'; import {GenericLogic} from '../libraries/logic/GenericLogic.sol'; +import {ReserveLogic} from '../libraries/logic/ReserveLogic.sol'; import {Helpers} from '../libraries/helpers/Helpers.sol'; import {WadRayMath} from '../libraries/math/WadRayMath.sol'; import {PercentageMath} from '../libraries/math/PercentageMath.sol'; @@ -35,6 +36,7 @@ contract LendingPoolCollateralManager is using SafeMath for uint256; using WadRayMath for uint256; using PercentageMath for uint256; + using ReserveLogic for DataTypes.ReserveCache; uint256 internal constant LIQUIDATION_CLOSE_FACTOR_PERCENT = 5000; @@ -173,9 +175,8 @@ contract LendingPoolCollateralManager is vars.actualDebtToLiquidate, debtReserveCache.nextVariableBorrowIndex ); - debtReserveCache.nextScaledVariableDebt = debtReserveCache.currScaledVariableDebt.sub( - vars.actualDebtToLiquidate.rayDiv(debtReserveCache.nextVariableBorrowIndex) - ); + debtReserveCache.refreshDebt(0, 0, 0, vars.actualDebtToLiquidate); + debtReserve.updateInterestRates(debtReserveCache, debtAsset, vars.actualDebtToLiquidate, 0); } else { // If the user doesn't have variable debt, no need to try to burn variable debt tokens if (vars.userVariableDebt > 0) { @@ -184,27 +185,20 @@ contract LendingPoolCollateralManager is vars.userVariableDebt, debtReserveCache.nextVariableBorrowIndex ); - debtReserveCache.nextScaledVariableDebt = debtReserveCache - .currScaledVariableDebt - .sub(vars.userVariableDebt.rayDiv(debtReserveCache.nextVariableBorrowIndex)); } IStableDebtToken(debtReserveCache.stableDebtTokenAddress).burn( user, vars.actualDebtToLiquidate.sub(vars.userVariableDebt) ); - - debtReserveCache.nextPrincipalStableDebt = debtReserveCache - .nextTotalStableDebt = debtReserveCache.currTotalStableDebt.sub( - vars.actualDebtToLiquidate.sub(vars.userVariableDebt) + debtReserveCache.refreshDebt( + 0, + vars.actualDebtToLiquidate.sub(vars.userVariableDebt), + 0, + vars.userVariableDebt ); - } - debtReserve.updateInterestRates( - debtReserveCache, - debtAsset, - vars.actualDebtToLiquidate, - 0 - ); + debtReserve.updateInterestRates(debtReserveCache, debtAsset, vars.actualDebtToLiquidate, 0); + } if (receiveAToken) { vars.liquidatorPreviousATokenBalance = IERC20(vars.collateralAtoken).balanceOf(msg.sender); @@ -216,7 +210,7 @@ contract LendingPoolCollateralManager is emit ReserveUsedAsCollateralEnabled(collateralAsset, msg.sender); } } else { - collateralReserve.updateState(collateralReserveCache); + collateralReserve.updateState(collateralReserveCache); collateralReserve.updateInterestRates( collateralReserveCache, collateralAsset, diff --git a/contracts/protocol/libraries/logic/ReserveLogic.sol b/contracts/protocol/libraries/logic/ReserveLogic.sol index 1db225ac..305559e2 100644 --- a/contracts/protocol/libraries/logic/ReserveLogic.sol +++ b/contracts/protocol/libraries/logic/ReserveLogic.sol @@ -186,10 +186,6 @@ library ReserveLogic { ) internal { UpdateInterestRatesLocalVars memory vars; - if (reserveCache.currTotalStableDebt != reserveCache.nextTotalStableDebt) { - reserveCache.nextAvgStableBorrowRate = IStableDebtToken(reserveCache.stableDebtTokenAddress) - .getAverageStableRate(); - } reserveCache.nextTotalVariableDebt = reserveCache.nextScaledVariableDebt.rayMul( reserveCache.nextVariableBorrowIndex @@ -228,11 +224,9 @@ library ReserveLogic { } struct MintToTreasuryLocalVars { - uint256 currentStableDebt; - uint256 principalStableDebt; - uint256 previousStableDebt; - uint256 currentVariableDebt; - uint256 previousVariableDebt; + uint256 prevTotalStableDebt; + uint256 prevTotalVariableDebt; + uint256 currTotalVariableDebt; uint256 avgStableRate; uint256 cumulatedStableInterest; uint256 totalDebtAccrued; @@ -260,12 +254,12 @@ library ReserveLogic { } //calculate the last principal variable debt - vars.previousVariableDebt = reserveCache.currScaledVariableDebt.rayMul( + vars.prevTotalVariableDebt = reserveCache.currScaledVariableDebt.rayMul( reserveCache.currVariableBorrowIndex ); //calculate the new total supply after accumulation of the index - vars.currentVariableDebt = reserveCache.currScaledVariableDebt.rayMul( + vars.currTotalVariableDebt = reserveCache.currScaledVariableDebt.rayMul( reserveCache.nextVariableBorrowIndex ); @@ -276,16 +270,16 @@ library ReserveLogic { reserveCache.reserveLastUpdateTimestamp ); - vars.previousStableDebt = reserveCache.currPrincipalStableDebt.rayMul( + vars.prevTotalStableDebt = reserveCache.currPrincipalStableDebt.rayMul( vars.cumulatedStableInterest ); //debt accrued is the sum of the current debt minus the sum of the debt at the last update vars.totalDebtAccrued = vars - .currentVariableDebt + .currTotalVariableDebt .add(reserveCache.currTotalStableDebt) - .sub(vars.previousVariableDebt) - .sub(vars.previousStableDebt); + .sub(vars.prevTotalVariableDebt) + .sub(vars.prevTotalStableDebt); vars.amountToMint = vars.totalDebtAccrued.percentMul(vars.reserveFactor); @@ -385,4 +379,32 @@ library ReserveLogic { return reserveCache; } + + function refreshDebt( + DataTypes.ReserveCache memory cache, + uint256 stableDebtMinted, + uint256 stableDebtBurned, + uint256 variableDebtMinted, + uint256 variableDebtBurned + ) internal { + uint256 scaledVariableDebtMinted = variableDebtMinted.rayDiv(cache.nextVariableBorrowIndex); + uint256 scaledVariableDebtBurned = variableDebtBurned.rayDiv(cache.nextVariableBorrowIndex); + + if (cache.currTotalStableDebt.add(stableDebtMinted) > stableDebtBurned) { + cache.nextPrincipalStableDebt = cache.nextTotalStableDebt = cache + .currTotalStableDebt + .add(stableDebtMinted) + .sub(stableDebtBurned); + if (stableDebtMinted != 0 || stableDebtBurned != 0) { + cache.nextAvgStableBorrowRate = IStableDebtToken(cache.stableDebtTokenAddress) + .getAverageStableRate(); + } + } else { + cache.nextPrincipalStableDebt = cache.nextTotalStableDebt = cache.nextAvgStableBorrowRate = 0; + } + + cache.nextScaledVariableDebt = cache.currScaledVariableDebt.add(scaledVariableDebtMinted).sub( + scaledVariableDebtBurned + ); + } } diff --git a/package-lock.json b/package-lock.json index 7f3c76fd..e5198127 100644 --- a/package-lock.json +++ b/package-lock.json @@ -14793,7 +14793,7 @@ } }, "ethereumjs-abi": { - "version": "git+https://github.com/ethereumjs/ethereumjs-abi.git#1a27c59c15ab1e95ee8e5c4ed6ad814c49cc439e", + "version": "git+https://github.com/ethereumjs/ethereumjs-abi.git#ee3994657fa7a427238e6ba92a84d0b529bbcde0", "from": "git+https://github.com/ethereumjs/ethereumjs-abi.git", "dev": true, "requires": { From 760be1cb423889e867ff674b188384dec876186a Mon Sep 17 00:00:00 2001 From: emilio Date: Fri, 11 Jun 2021 11:27:19 +0200 Subject: [PATCH 07/13] refactor: further refactored cache, changed linkage behavior of GenericLogic --- .../protocol/lendingpool/LendingPool.sol | 12 +-- .../LendingPoolCollateralManager.sol | 52 +++++----- .../configuration/ReserveConfiguration.sol | 19 +--- .../protocol/libraries/logic/GenericLogic.sol | 32 ++++++ .../protocol/libraries/logic/ReserveLogic.sol | 39 ++++---- .../libraries/logic/ValidationLogic.sol | 98 +++++++++++-------- helpers/contracts-deployments.ts | 3 +- 7 files changed, 145 insertions(+), 110 deletions(-) diff --git a/contracts/protocol/lendingpool/LendingPool.sol b/contracts/protocol/lendingpool/LendingPool.sol index e2f1509f..3f87e74e 100644 --- a/contracts/protocol/lendingpool/LendingPool.sol +++ b/contracts/protocol/lendingpool/LendingPool.sol @@ -20,8 +20,8 @@ import {Errors} from '../libraries/helpers/Errors.sol'; import {WadRayMath} from '../libraries/math/WadRayMath.sol'; import {PercentageMath} from '../libraries/math/PercentageMath.sol'; import {ReserveLogic} from '../libraries/logic/ReserveLogic.sol'; -import {GenericLogic} from '../libraries/logic/GenericLogic.sol'; import {ValidationLogic} from '../libraries/logic/ValidationLogic.sol'; +import {GenericLogic} from '../libraries/logic/GenericLogic.sol'; import {ReserveConfiguration} from '../libraries/configuration/ReserveConfiguration.sol'; import {UserConfiguration} from '../libraries/configuration/UserConfiguration.sol'; import {DataTypes} from '../libraries/types/DataTypes.sol'; @@ -190,7 +190,6 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage uint16 referralCode, address onBehalfOf ) external override whenNotPaused { - DataTypes.ReserveData storage reserve = _reserves[asset]; _executeBorrow( ExecuteBorrowParams( asset, @@ -372,7 +371,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage DataTypes.ReserveData storage reserve = _reserves[asset]; DataTypes.ReserveCache memory reserveCache = reserve.cache(); - ValidationLogic.validateSetUseReserveAsCollateral(reserve, reserveCache); + ValidationLogic.validateSetUseReserveAsCollateral(reserveCache); _usersConfig[msg.sender].setUsingAsCollateral(reserve.id, useAsCollateral); @@ -619,7 +618,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage ltv, currentLiquidationThreshold, healthFactor - ) = GenericLogic.calculateUserAccountData( + ) = GenericLogic.getUserAccountData( user, _reserves, _usersConfig[user], @@ -990,7 +989,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage reserve.updateState(reserveCache); - ValidationLogic.validateDeposit(reserve, reserveCache, amount); + ValidationLogic.validateDeposit(reserveCache, amount); reserve.updateInterestRates(reserveCache, asset, amount, 0); @@ -1029,7 +1028,7 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage amountToWithdraw = userBalance; } - ValidationLogic.validateWithdraw(reserve, reserveCache, amountToWithdraw, userBalance); + ValidationLogic.validateWithdraw(reserveCache, amountToWithdraw, userBalance); reserve.updateInterestRates(reserveCache, asset, 0, amountToWithdraw); @@ -1077,7 +1076,6 @@ contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage DataTypes.InterestRateMode interestRateMode = DataTypes.InterestRateMode(rateMode); ValidationLogic.validateRepay( - reserve, reserveCache, amount, interestRateMode, diff --git a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol index b757f9de..e530a9a4 100644 --- a/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol +++ b/contracts/protocol/lendingpool/LendingPoolCollateralManager.sol @@ -1,6 +1,8 @@ // SPDX-License-Identifier: agpl-3.0 pragma solidity 0.6.12; +pragma experimental ABIEncoderV2; + import {SafeMath} from '../../dependencies/openzeppelin/contracts//SafeMath.sol'; import {IERC20} from '../../dependencies/openzeppelin/contracts//IERC20.sol'; import {IAToken} from '../../interfaces/IAToken.sol'; @@ -9,7 +11,6 @@ import {IVariableDebtToken} from '../../interfaces/IVariableDebtToken.sol'; import {IPriceOracleGetter} from '../../interfaces/IPriceOracleGetter.sol'; import {ILendingPoolCollateralManager} from '../../interfaces/ILendingPoolCollateralManager.sol'; import {VersionedInitializable} from '../libraries/aave-upgradeability/VersionedInitializable.sol'; -import {GenericLogic} from '../libraries/logic/GenericLogic.sol'; import {ReserveLogic} from '../libraries/logic/ReserveLogic.sol'; import {Helpers} from '../libraries/helpers/Helpers.sol'; import {WadRayMath} from '../libraries/math/WadRayMath.sol'; @@ -54,6 +55,7 @@ contract LendingPoolCollateralManager is uint256 healthFactor; uint256 liquidatorPreviousATokenBalance; IAToken collateralAtoken; + IPriceOracleGetter oracle; bool isCollateralEnabled; DataTypes.InterestRateMode borrowRateMode; uint256 errorCode; @@ -89,33 +91,25 @@ contract LendingPoolCollateralManager is ) external override returns (uint256, string memory) { DataTypes.ReserveData storage collateralReserve = _reserves[collateralAsset]; DataTypes.ReserveData storage debtReserve = _reserves[debtAsset]; + DataTypes.ReserveCache memory debtReserveCache = debtReserve.cache(); DataTypes.UserConfigurationMap storage userConfig = _usersConfig[user]; LiquidationCallLocalVars memory vars; - (, , , , vars.healthFactor) = GenericLogic.calculateUserAccountData( + + (vars.userStableDebt, vars.userVariableDebt) = Helpers.getUserCurrentDebt(user, debtReserve); + vars.oracle = IPriceOracleGetter(_addressesProvider.getPriceOracle()); + + (vars.errorCode, vars.errorMsg) = ValidationLogic.validateLiquidationCall( + collateralReserve, + debtReserveCache, + vars.userStableDebt.add(vars.userVariableDebt), user, _reserves, userConfig, _reservesList, _reservesCount, - _addressesProvider.getPriceOracle() - ); - - DataTypes.ReserveCache memory debtReserveCache = debtReserve.cache(); - DataTypes.ReserveCache memory collateralReserveCache = collateralReserve.cache(); - - (vars.userStableDebt, vars.userVariableDebt) = Helpers.getUserCurrentDebt(user, debtReserve); - - (vars.errorCode, vars.errorMsg) = ValidationLogic.validateLiquidationCall( - collateralReserve, - debtReserve, - debtReserveCache, - collateralReserveCache, - userConfig, - vars.healthFactor, - vars.userStableDebt, - vars.userVariableDebt + address(vars.oracle) ); if (Errors.CollateralManagerErrors(vars.errorCode) != Errors.CollateralManagerErrors.NO_ERROR) { @@ -139,11 +133,12 @@ contract LendingPoolCollateralManager is vars.debtAmountNeeded ) = _calculateAvailableCollateralToLiquidate( collateralReserve, - debtReserve, + debtReserveCache, collateralAsset, debtAsset, vars.actualDebtToLiquidate, - vars.userCollateralBalance + vars.userCollateralBalance, + vars.oracle ); // If debtAmountNeeded < actualDebtToLiquidate, there isn't enough @@ -210,6 +205,7 @@ contract LendingPoolCollateralManager is emit ReserveUsedAsCollateralEnabled(collateralAsset, msg.sender); } } else { + DataTypes.ReserveCache memory collateralReserveCache = collateralReserve.cache(); collateralReserve.updateState(collateralReserveCache); collateralReserve.updateInterestRates( collateralReserveCache, @@ -223,7 +219,7 @@ contract LendingPoolCollateralManager is user, msg.sender, vars.maxCollateralToLiquidate, - collateralReserve.liquidityIndex + collateralReserveCache.nextLiquidityIndex ); } @@ -237,7 +233,7 @@ contract LendingPoolCollateralManager is // Transfers the debt asset being repaid to the aToken, where the liquidity is kept IERC20(debtAsset).safeTransferFrom( msg.sender, - debtReserve.aTokenAddress, + debtReserveCache.aTokenAddress, vars.actualDebtToLiquidate ); @@ -270,7 +266,7 @@ contract LendingPoolCollateralManager is * - This function needs to be called after all the checks to validate the liquidation have been performed, * otherwise it might fail. * @param collateralReserve The data of the collateral reserve - * @param debtReserve The data of the debt reserve + * @param debtReserveCache The cached data of the debt reserve * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover @@ -281,15 +277,15 @@ contract LendingPoolCollateralManager is **/ function _calculateAvailableCollateralToLiquidate( DataTypes.ReserveData storage collateralReserve, - DataTypes.ReserveData storage debtReserve, + DataTypes.ReserveCache memory debtReserveCache, address collateralAsset, address debtAsset, uint256 debtToCover, - uint256 userCollateralBalance + uint256 userCollateralBalance, + IPriceOracleGetter oracle ) internal view returns (uint256, uint256) { uint256 collateralAmount = 0; uint256 debtAmountNeeded = 0; - IPriceOracleGetter oracle = IPriceOracleGetter(_addressesProvider.getPriceOracle()); AvailableCollateralToLiquidateLocalVars memory vars; @@ -299,7 +295,7 @@ contract LendingPoolCollateralManager is (, , vars.liquidationBonus, vars.collateralDecimals, ) = collateralReserve .configuration .getParams(); - vars.debtAssetDecimals = debtReserve.configuration.getDecimals(); + vars.debtAssetDecimals = debtReserveCache.reserveConfiguration.getDecimalsMemory(); // This is the maximum possible amount of the selected collateral that can be liquidated, given the // max amount of liquidatable debt diff --git a/contracts/protocol/libraries/configuration/ReserveConfiguration.sol b/contracts/protocol/libraries/configuration/ReserveConfiguration.sol index 012e4cbd..b369aaee 100644 --- a/contracts/protocol/libraries/configuration/ReserveConfiguration.sol +++ b/contracts/protocol/libraries/configuration/ReserveConfiguration.sol @@ -70,7 +70,7 @@ library ReserveConfiguration { * @param self The reserve configuration * @return The loan to value **/ - function getLtvMemory(DataTypes.ReserveConfigurationMap memory self) internal view returns (uint256) { + function getLtvMemory(DataTypes.ReserveConfigurationMap memory self) internal pure returns (uint256) { return self.data & ~LTV_MASK; } @@ -104,18 +104,6 @@ library ReserveConfiguration { return (self.data & ~LIQUIDATION_THRESHOLD_MASK) >> LIQUIDATION_THRESHOLD_START_BIT_POSITION; } - /** - * @dev Gets the liquidation threshold of the reserve - * @param self The reserve configuration - * @return The liquidation threshold - **/ - function getLiquidationThresholdMemory(DataTypes.ReserveConfigurationMap memory self) - internal - view - returns (uint256) - { - return (self.data & ~LIQUIDATION_THRESHOLD_MASK) >> LIQUIDATION_THRESHOLD_START_BIT_POSITION; - } /** * @dev Sets the liquidation bonus of the reserve * @param self The reserve configuration @@ -172,7 +160,6 @@ library ReserveConfiguration { return (self.data & ~DECIMALS_MASK) >> RESERVE_DECIMALS_START_BIT_POSITION; } - /** * @dev Gets the decimals of the underlying asset of the reserve * @param self The reserve configuration @@ -180,7 +167,7 @@ library ReserveConfiguration { **/ function getDecimalsMemory(DataTypes.ReserveConfigurationMap memory self) internal - view + pure returns (uint256) { return (self.data & ~DECIMALS_MASK) >> RESERVE_DECIMALS_START_BIT_POSITION; @@ -336,7 +323,7 @@ library ReserveConfiguration { **/ function getReserveFactorMemory(DataTypes.ReserveConfigurationMap memory self) internal - view + pure returns (uint256) { return (self.data & ~RESERVE_FACTOR_MASK) >> RESERVE_FACTOR_START_BIT_POSITION; diff --git a/contracts/protocol/libraries/logic/GenericLogic.sol b/contracts/protocol/libraries/logic/GenericLogic.sol index 549328a8..fb867ce2 100644 --- a/contracts/protocol/libraries/logic/GenericLogic.sol +++ b/contracts/protocol/libraries/logic/GenericLogic.sol @@ -198,4 +198,36 @@ library GenericLogic { availableBorrowsETH = availableBorrowsETH.sub(totalDebtInETH); return availableBorrowsETH; } + + /** + * @dev proxy call for calculateUserAccountData as external function. + * Used in LendingPool to work around contract size limit issues + * @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 debt of the user in ETH, the avg ltv, liquidation threshold and the HF + **/ + function getUserAccountData( + address user, + mapping(address => DataTypes.ReserveData) storage reservesData, + DataTypes.UserConfigurationMap memory userConfig, + mapping(uint256 => address) storage reserves, + uint256 reservesCount, + address oracle + ) + external + view + returns ( + uint256, + uint256, + uint256, + uint256, + uint256 + ) + { + return + calculateUserAccountData(user, reservesData, userConfig, reserves, reservesCount, oracle); + } } diff --git a/contracts/protocol/libraries/logic/ReserveLogic.sol b/contracts/protocol/libraries/logic/ReserveLogic.sol index 305559e2..86679f9a 100644 --- a/contracts/protocol/libraries/logic/ReserveLogic.sol +++ b/contracts/protocol/libraries/logic/ReserveLogic.sol @@ -186,7 +186,6 @@ library ReserveLogic { ) internal { UpdateInterestRatesLocalVars memory vars; - reserveCache.nextTotalVariableDebt = reserveCache.nextScaledVariableDebt.rayMul( reserveCache.nextVariableBorrowIndex ); @@ -386,25 +385,29 @@ library ReserveLogic { uint256 stableDebtBurned, uint256 variableDebtMinted, uint256 variableDebtBurned - ) internal { - uint256 scaledVariableDebtMinted = variableDebtMinted.rayDiv(cache.nextVariableBorrowIndex); - uint256 scaledVariableDebtBurned = variableDebtBurned.rayDiv(cache.nextVariableBorrowIndex); - - if (cache.currTotalStableDebt.add(stableDebtMinted) > stableDebtBurned) { - cache.nextPrincipalStableDebt = cache.nextTotalStableDebt = cache - .currTotalStableDebt - .add(stableDebtMinted) - .sub(stableDebtBurned); - if (stableDebtMinted != 0 || stableDebtBurned != 0) { - cache.nextAvgStableBorrowRate = IStableDebtToken(cache.stableDebtTokenAddress) - .getAverageStableRate(); + ) internal view { + if (stableDebtMinted != 0 || stableDebtBurned != 0) { + if (cache.currTotalStableDebt.add(stableDebtMinted) > stableDebtBurned) { + cache.nextPrincipalStableDebt = cache.nextTotalStableDebt = cache + .currTotalStableDebt + .add(stableDebtMinted) + .sub(stableDebtBurned); + if (stableDebtMinted != 0 || stableDebtBurned != 0) { + cache.nextAvgStableBorrowRate = IStableDebtToken(cache.stableDebtTokenAddress) + .getAverageStableRate(); + } + } else { + cache.nextPrincipalStableDebt = cache.nextTotalStableDebt = cache + .nextAvgStableBorrowRate = 0; } - } else { - cache.nextPrincipalStableDebt = cache.nextTotalStableDebt = cache.nextAvgStableBorrowRate = 0; } - cache.nextScaledVariableDebt = cache.currScaledVariableDebt.add(scaledVariableDebtMinted).sub( - scaledVariableDebtBurned - ); + if (variableDebtMinted != 0 || variableDebtBurned != 0) { + uint256 scaledVariableDebtMinted = variableDebtMinted.rayDiv(cache.nextVariableBorrowIndex); + uint256 scaledVariableDebtBurned = variableDebtBurned.rayDiv(cache.nextVariableBorrowIndex); + cache.nextScaledVariableDebt = cache.currScaledVariableDebt.add(scaledVariableDebtMinted).sub( + scaledVariableDebtBurned + ); + } } } diff --git a/contracts/protocol/libraries/logic/ValidationLogic.sol b/contracts/protocol/libraries/logic/ValidationLogic.sol index dc141a6c..21a6324d 100644 --- a/contracts/protocol/libraries/logic/ValidationLogic.sol +++ b/contracts/protocol/libraries/logic/ValidationLogic.sol @@ -16,6 +16,7 @@ import {Helpers} from '../helpers/Helpers.sol'; import {IReserveInterestRateStrategy} from '../../../interfaces/IReserveInterestRateStrategy.sol'; import {IVariableDebtToken} from '../../../interfaces/IVariableDebtToken.sol'; import {IStableDebtToken} from '../../../interfaces/IStableDebtToken.sol'; +import {IScaledBalanceToken} from '../../../interfaces/IScaledBalanceToken.sol'; import {IAToken} from '../../../interfaces/IAToken.sol'; import {DataTypes} from '../types/DataTypes.sol'; import {IPriceOracleGetter} from '../../../interfaces/IPriceOracleGetter.sol'; @@ -39,14 +40,13 @@ library ValidationLogic { /** * @dev Validates a deposit action - * @param reserve The reserve object on which the user is depositing + * @param reserveCache The cached data of the reserve * @param amount The amount to be deposited */ - function validateDeposit( - DataTypes.ReserveData storage reserve, - DataTypes.ReserveCache memory reserveCache, - uint256 amount - ) internal view { + function validateDeposit(DataTypes.ReserveCache memory reserveCache, uint256 amount) + internal + view + { (bool isActive, bool isFrozen, , , bool isPaused) = reserveCache.reserveConfiguration.getFlagsMemory(); (, , , uint256 reserveDecimals, ) = reserveCache.reserveConfiguration.getParamsMemory(); @@ -70,16 +70,15 @@ library ValidationLogic { /** * @dev Validates a withdraw action - * @param reserve The reserve object + * @param reserveCache The cached data of the reserve * @param amount The amount to be withdrawn * @param userBalance The balance of the user */ function validateWithdraw( - DataTypes.ReserveData storage reserve, DataTypes.ReserveCache memory reserveCache, uint256 amount, uint256 userBalance - ) internal view { + ) internal pure { require(amount != 0, Errors.VL_INVALID_AMOUNT); require(amount <= userBalance, Errors.VL_NOT_ENOUGH_AVAILABLE_USER_BALANCE); @@ -245,21 +244,20 @@ library ValidationLogic { /** * @dev Validates a repay action - * @param reserve The reserve state from which the user is repaying + * @param reserveCache The cached data 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 stableDebt The borrow balance of the user * @param variableDebt The borrow balance of the user */ function validateRepay( - DataTypes.ReserveData storage reserve, DataTypes.ReserveCache memory reserveCache, uint256 amountSent, DataTypes.InterestRateMode rateMode, address onBehalfOf, uint256 stableDebt, uint256 variableDebt - ) external view { + ) internal view { (bool isActive, , , , bool isPaused) = reserveCache.reserveConfiguration.getFlagsMemory(); require(isActive, Errors.VL_NO_ACTIVE_RESERVE); require(!isPaused, Errors.VL_RESERVE_PAUSED); @@ -371,12 +369,12 @@ library ValidationLogic { /** * @dev Validates the action of setting an asset as collateral - * @param reserve The state of the reserve that the user is enabling or disabling as collateral + * @param reserveCache The cached data of the reserve */ - function validateSetUseReserveAsCollateral( - DataTypes.ReserveData storage reserve, - DataTypes.ReserveCache memory reserveCache - ) external view { + function validateSetUseReserveAsCollateral(DataTypes.ReserveCache memory reserveCache) + external + view + { uint256 underlyingBalance = IERC20(reserveCache.aTokenAddress).balanceOf(msg.sender); (bool isActive, , , , bool isPaused) = reserveCache.reserveConfiguration.getFlagsMemory(); @@ -395,68 +393,88 @@ library ValidationLogic { address[] memory assets, uint256[] memory amounts, mapping(address => DataTypes.ReserveData) storage reservesData - ) external view { + ) internal view { for (uint256 i = 0; i < assets.length; i++) { require(!reservesData[assets[i]].configuration.getPaused(), Errors.VL_RESERVE_PAUSED); } require(assets.length == amounts.length, Errors.VL_INCONSISTENT_FLASHLOAN_PARAMS); } + struct ValidateLiquidationCallLocalVars { + uint256 healthFactor; + bool collateralReserveActive; + bool collateralReservePaused; + bool principalReserveActive; + bool principalReservePaused; + bool isCollateralEnabled; + } + /** * @dev Validates the liquidation action * @param collateralReserve The reserve data of the collateral - * @param principalReserve The reserve data of the principal * @param userConfig The user configuration - * @param userHealthFactor The user's health factor - * @param userStableDebt Total stable debt balance of the user - * @param userVariableDebt Total variable debt balance of the user + * @param totalDebt Total debt balance of the user **/ function validateLiquidationCall( DataTypes.ReserveData storage collateralReserve, - DataTypes.ReserveData storage principalReserve, - DataTypes.ReserveCache memory collateralReserveCache, DataTypes.ReserveCache memory principalReserveCache, + uint256 totalDebt, + address user, + mapping(address => DataTypes.ReserveData) storage reservesData, DataTypes.UserConfigurationMap storage userConfig, - uint256 userHealthFactor, - uint256 userStableDebt, - uint256 userVariableDebt + mapping(uint256 => address) storage reserves, + uint256 reservesCount, + address oracle ) internal view returns (uint256, string memory) { - (bool collateralReserveActive, , , , bool collateralReservePaused) = - collateralReserveCache.reserveConfiguration.getFlagsMemory(); + ValidateLiquidationCallLocalVars memory vars; - (bool principalReserveActive, , , , bool principalReservePaused) = - collateralReserveCache.reserveConfiguration.getFlagsMemory(); + (vars.collateralReserveActive, , , , vars.collateralReservePaused) = collateralReserve + .configuration + .getFlagsMemory(); - if (!collateralReserveActive || !principalReserveActive) { + (vars.principalReserveActive, , , , vars.principalReservePaused) = principalReserveCache + .reserveConfiguration + .getFlagsMemory(); + + if (!vars.collateralReserveActive || !vars.principalReserveActive) { return ( uint256(Errors.CollateralManagerErrors.NO_ACTIVE_RESERVE), Errors.VL_NO_ACTIVE_RESERVE ); } - if (collateralReservePaused || principalReservePaused) { + if (vars.collateralReservePaused || vars.principalReservePaused) { return (uint256(Errors.CollateralManagerErrors.PAUSED_RESERVE), Errors.VL_RESERVE_PAUSED); } - if (userHealthFactor >= GenericLogic.HEALTH_FACTOR_LIQUIDATION_THRESHOLD) { + (, , , , vars.healthFactor) = GenericLogic.calculateUserAccountData( + user, + reservesData, + userConfig, + reserves, + reservesCount, + oracle + ); + + if (vars.healthFactor >= GenericLogic.HEALTH_FACTOR_LIQUIDATION_THRESHOLD) { return ( uint256(Errors.CollateralManagerErrors.HEALTH_FACTOR_ABOVE_THRESHOLD), Errors.LPCM_HEALTH_FACTOR_NOT_BELOW_THRESHOLD ); } - bool isCollateralEnabled = - collateralReserveCache.reserveConfiguration.getLiquidationThresholdMemory() > 0 && - userConfig.isUsingAsCollateral(collateralReserve.id); + vars.isCollateralEnabled = + collateralReserve.configuration.getLiquidationThreshold() > 0 && + userConfig.isUsingAsCollateral(collateralReserve.id); //if collateral isn't enabled as collateral by user, it cannot be liquidated - if (!isCollateralEnabled) { + if (!vars.isCollateralEnabled) { return ( uint256(Errors.CollateralManagerErrors.COLLATERAL_CANNOT_BE_LIQUIDATED), Errors.LPCM_COLLATERAL_CANNOT_BE_LIQUIDATED ); } - if (userStableDebt == 0 && userVariableDebt == 0) { + if (totalDebt == 0) { return ( uint256(Errors.CollateralManagerErrors.CURRRENCY_NOT_BORROWED), Errors.LPCM_SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER @@ -482,7 +500,7 @@ library ValidationLogic { mapping(uint256 => address) storage reserves, uint256 reservesCount, address oracle - ) internal view { + ) external view { (, , , , uint256 healthFactor) = GenericLogic.calculateUserAccountData( from, diff --git a/helpers/contracts-deployments.ts b/helpers/contracts-deployments.ts index 2d764885..05f79206 100644 --- a/helpers/contracts-deployments.ts +++ b/helpers/contracts-deployments.ts @@ -188,7 +188,8 @@ export const deployAaveLibraries = async ( return { ['__$de8c0cf1a7d7c36c802af9a64fb9d86036$__']: validationLogic.address, ['__$22cd43a9dda9ce44e9b92ba393b88fb9ac$__']: reserveLogic.address, - }; + ["__$52a8a86ab43135662ff256bbc95497e8e3$__"]: genericLogic.address, + } }; export const deployLendingPool = async (verify?: boolean) => { From 8451c88174f14d4ad07334c0e075490b28cb0151 Mon Sep 17 00:00:00 2001 From: emilio Date: Fri, 11 Jun 2021 11:53:43 +0200 Subject: [PATCH 08/13] refactor:removed unneeded diff --- contracts/protocol/lendingpool/LendingPool.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/contracts/protocol/lendingpool/LendingPool.sol b/contracts/protocol/lendingpool/LendingPool.sol index 3f87e74e..a5283d11 100644 --- a/contracts/protocol/lendingpool/LendingPool.sol +++ b/contracts/protocol/lendingpool/LendingPool.sol @@ -20,8 +20,8 @@ import {Errors} from '../libraries/helpers/Errors.sol'; import {WadRayMath} from '../libraries/math/WadRayMath.sol'; import {PercentageMath} from '../libraries/math/PercentageMath.sol'; import {ReserveLogic} from '../libraries/logic/ReserveLogic.sol'; -import {ValidationLogic} from '../libraries/logic/ValidationLogic.sol'; import {GenericLogic} from '../libraries/logic/GenericLogic.sol'; +import {ValidationLogic} from '../libraries/logic/ValidationLogic.sol'; import {ReserveConfiguration} from '../libraries/configuration/ReserveConfiguration.sol'; import {UserConfiguration} from '../libraries/configuration/UserConfiguration.sol'; import {DataTypes} from '../libraries/types/DataTypes.sol'; From 065799eb29d8a2c67dfc92f855085dbb1cc98f7f Mon Sep 17 00:00:00 2001 From: emilio Date: Fri, 11 Jun 2021 17:03:52 +0200 Subject: [PATCH 09/13] comments: added comments to cache() and refreshDebt() --- .../protocol/libraries/logic/ReserveLogic.sol | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/contracts/protocol/libraries/logic/ReserveLogic.sol b/contracts/protocol/libraries/logic/ReserveLogic.sol index 86679f9a..ca6521c6 100644 --- a/contracts/protocol/libraries/logic/ReserveLogic.sol +++ b/contracts/protocol/libraries/logic/ReserveLogic.sol @@ -340,6 +340,12 @@ library ReserveLogic { reserve.lastUpdateTimestamp = uint40(block.timestamp); } + /** + * @dev Creates a cache object to avoid repeated storage reads and external contract calls + * when updating state and interest rates. + * @param reserve The reserve object for which the cache will be filled + * @return The cache object + */ function cache(DataTypes.ReserveData storage reserve) internal view @@ -372,6 +378,8 @@ library ReserveLogic { reserveCache.stableDebtLastUpdateTimestamp ) = IStableDebtToken(reserveCache.stableDebtTokenAddress).getSupplyData(); + // setting by default the debt data after the action with the same values as before + // if the action involves mint/burn of debt, the cache is updated through refreshDebt() reserveCache.nextPrincipalStableDebt = reserveCache.currPrincipalStableDebt; reserveCache.nextTotalStableDebt = reserveCache.currTotalStableDebt; reserveCache.nextAvgStableBorrowRate = reserveCache.currAvgStableBorrowRate; @@ -379,6 +387,15 @@ library ReserveLogic { return reserveCache; } + /** + * @dev Updates the debt data in the cache object. Invoked after an interaction caused minting/burning of the debt. + * MUST be invoked before updateInterestRates(). + * @param cache The cache object + * @param stableDebtMinted The stable debt minted as a consequence of the interaction + * @param stableDebtBurned The stable debt burned as a consequence of the interaction + * @param variableDebtMinted The variable debt minted as a consequence of the interaction + * @param variableDebtBurned The variable debt burned as a consequence of the interaction + */ function refreshDebt( DataTypes.ReserveCache memory cache, uint256 stableDebtMinted, From dd07e934c212563b3fa87d7f2d3797166d792615 Mon Sep 17 00:00:00 2001 From: emilio Date: Fri, 11 Jun 2021 19:45:31 +0200 Subject: [PATCH 10/13] comments: updated comments --- contracts/protocol/libraries/logic/ReserveLogic.sol | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/contracts/protocol/libraries/logic/ReserveLogic.sol b/contracts/protocol/libraries/logic/ReserveLogic.sol index ca6521c6..b44c3853 100644 --- a/contracts/protocol/libraries/logic/ReserveLogic.sol +++ b/contracts/protocol/libraries/logic/ReserveLogic.sol @@ -341,8 +341,7 @@ library ReserveLogic { } /** - * @dev Creates a cache object to avoid repeated storage reads and external contract calls - * when updating state and interest rates. + * @dev Creates a cache object to avoid repeated storage reads and external contract calls when updating state and interest rates. * @param reserve The reserve object for which the cache will be filled * @return The cache object */ @@ -378,8 +377,8 @@ library ReserveLogic { reserveCache.stableDebtLastUpdateTimestamp ) = IStableDebtToken(reserveCache.stableDebtTokenAddress).getSupplyData(); - // setting by default the debt data after the action with the same values as before - // if the action involves mint/burn of debt, the cache is updated through refreshDebt() + // by default the actions are considered as not affecting the debt balances. + // if the action involves mint/burn of debt, the cache needs to be updated through refreshDebt() reserveCache.nextPrincipalStableDebt = reserveCache.currPrincipalStableDebt; reserveCache.nextTotalStableDebt = reserveCache.currTotalStableDebt; reserveCache.nextAvgStableBorrowRate = reserveCache.currAvgStableBorrowRate; @@ -388,8 +387,8 @@ library ReserveLogic { } /** - * @dev Updates the debt data in the cache object. Invoked after an interaction caused minting/burning of the debt. - * MUST be invoked before updateInterestRates(). + * @dev Updates the debt data in the cache object. MUST be invoked before updateInterestRates() when a protocol interaction + * causes minting or burning of debt. * @param cache The cache object * @param stableDebtMinted The stable debt minted as a consequence of the interaction * @param stableDebtBurned The stable debt burned as a consequence of the interaction From 0965a99d883f631e3cebb4fa083beb8facaa98f6 Mon Sep 17 00:00:00 2001 From: emilio Date: Sun, 13 Jun 2021 21:15:06 +0200 Subject: [PATCH 11/13] refactor: fixed natspec comments and removed redunant check in refreshDebt() --- .../protocol/libraries/logic/ReserveLogic.sol | 30 +++++++++---------- 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/contracts/protocol/libraries/logic/ReserveLogic.sol b/contracts/protocol/libraries/logic/ReserveLogic.sol index b44c3853..91104182 100644 --- a/contracts/protocol/libraries/logic/ReserveLogic.sol +++ b/contracts/protocol/libraries/logic/ReserveLogic.sol @@ -341,10 +341,10 @@ library ReserveLogic { } /** - * @dev Creates a cache object to avoid repeated storage reads and external contract calls when updating state and interest rates. - * @param reserve The reserve object for which the cache will be filled - * @return The cache object - */ + * @dev Creates a cache object to avoid repeated storage reads and external contract calls when updating state and interest rates. + * @param reserve The reserve object for which the cache will be filled + * @return The cache object + */ function cache(DataTypes.ReserveData storage reserve) internal view @@ -387,14 +387,14 @@ library ReserveLogic { } /** - * @dev Updates the debt data in the cache object. MUST be invoked before updateInterestRates() when a protocol interaction - * causes minting or burning of debt. - * @param cache The cache object - * @param stableDebtMinted The stable debt minted as a consequence of the interaction - * @param stableDebtBurned The stable debt burned as a consequence of the interaction - * @param variableDebtMinted The variable debt minted as a consequence of the interaction - * @param variableDebtBurned The variable debt burned as a consequence of the interaction - */ + * @dev Updates the debt data in the cache object. MUST be invoked before updateInterestRates() when a protocol interaction + * causes minting or burning of debt. + * @param cache The cache object + * @param stableDebtMinted The stable debt minted as a consequence of the interaction + * @param stableDebtBurned The stable debt burned as a consequence of the interaction + * @param variableDebtMinted The variable debt minted as a consequence of the interaction + * @param variableDebtBurned The variable debt burned as a consequence of the interaction + */ function refreshDebt( DataTypes.ReserveCache memory cache, uint256 stableDebtMinted, @@ -408,10 +408,8 @@ library ReserveLogic { .currTotalStableDebt .add(stableDebtMinted) .sub(stableDebtBurned); - if (stableDebtMinted != 0 || stableDebtBurned != 0) { - cache.nextAvgStableBorrowRate = IStableDebtToken(cache.stableDebtTokenAddress) - .getAverageStableRate(); - } + cache.nextAvgStableBorrowRate = IStableDebtToken(cache.stableDebtTokenAddress) + .getAverageStableRate(); } else { cache.nextPrincipalStableDebt = cache.nextTotalStableDebt = cache .nextAvgStableBorrowRate = 0; From 9f71c7da8eb4d08a709e9e66f6dce40839bf6003 Mon Sep 17 00:00:00 2001 From: emilio Date: Sun, 13 Jun 2021 21:54:23 +0200 Subject: [PATCH 12/13] comments: fixed natspec comments on validation --- .../protocol/libraries/logic/ValidationLogic.sol | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/contracts/protocol/libraries/logic/ValidationLogic.sol b/contracts/protocol/libraries/logic/ValidationLogic.sol index 21a6324d..26388f46 100644 --- a/contracts/protocol/libraries/logic/ValidationLogic.sol +++ b/contracts/protocol/libraries/logic/ValidationLogic.sol @@ -109,6 +109,7 @@ library ValidationLogic { /** * @dev Validates a borrow action + * @param reserveCache the cached data of the reserve * @param asset The address of the asset to borrow * @param userAddress The address of the user * @param amount The amount to be borrowed @@ -246,6 +247,7 @@ library ValidationLogic { * @dev Validates a repay action * @param reserveCache The cached data of the reserve * @param amountSent The amount sent for the repayment. Can be an actual value or uint(-1) + * @param rateMode the interest rate mode of the debt being repaid * @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 @@ -281,10 +283,11 @@ library ValidationLogic { /** * @dev Validates a swap of borrow rate mode. * @param reserve The reserve state on which the user is swapping the rate + * @param reserveCache The cached data of the reserve * @param userConfig The user reserves configuration * @param stableDebt The stable debt of the user * @param variableDebt The variable debt of the user - * @param currentRateMode The rate mode of the borrow + * @param currentRateMode The rate mode of the debt being swapped */ function validateSwapRateMode( DataTypes.ReserveData storage reserve, @@ -328,6 +331,7 @@ library ValidationLogic { /** * @dev Validates a stable borrow rate rebalance action * @param reserve The reserve state on which the user is getting rebalanced + * @param reserveCache The cached state of the reserve * @param reserveAddress The address of the reserve * @param stableDebtToken The stable debt token instance * @param variableDebtToken The variable debt token instance @@ -412,8 +416,15 @@ library ValidationLogic { /** * @dev Validates the liquidation action * @param collateralReserve The reserve data of the collateral + * @param principalReserveCache The cached reserve data of the principal * @param userConfig The user configuration * @param totalDebt Total debt balance of the user + * @param user The address of the user being liquidated + * @param reservesData The mapping of the reserves data + * @param userConfig The user configuration mapping + * @param reserves The list of the reserves + * @param reservesCount The number of reserves in the list + * @param oracle The address of the price oracle **/ function validateLiquidationCall( DataTypes.ReserveData storage collateralReserve, From 978f6c93854c35a30d78bbdff458d915c18e7d07 Mon Sep 17 00:00:00 2001 From: emilio Date: Mon, 14 Jun 2021 15:47:13 +0200 Subject: [PATCH 13/13] refactor:removed unused/unneeded fields in the cache object --- .../protocol/libraries/logic/ReserveLogic.sol | 23 +++++++------------ .../protocol/libraries/types/DataTypes.sol | 2 -- 2 files changed, 8 insertions(+), 17 deletions(-) diff --git a/contracts/protocol/libraries/logic/ReserveLogic.sol b/contracts/protocol/libraries/logic/ReserveLogic.sol index 91104182..bbcc6fb8 100644 --- a/contracts/protocol/libraries/logic/ReserveLogic.sol +++ b/contracts/protocol/libraries/logic/ReserveLogic.sol @@ -161,9 +161,6 @@ library ReserveLogic { } struct UpdateInterestRatesLocalVars { - address stableDebtTokenAddress; - uint256 availableLiquidity; - uint256 totalStableDebt; uint256 newLiquidityRate; uint256 newStableRate; uint256 newVariableRate; @@ -186,10 +183,9 @@ library ReserveLogic { ) internal { UpdateInterestRatesLocalVars memory vars; - reserveCache.nextTotalVariableDebt = reserveCache.nextScaledVariableDebt.rayMul( + vars.totalVariableDebt = reserveCache.nextScaledVariableDebt.rayMul( reserveCache.nextVariableBorrowIndex ); - ( vars.newLiquidityRate, vars.newStableRate, @@ -200,7 +196,7 @@ library ReserveLogic { liquidityAdded, liquidityTaken, reserveCache.nextTotalStableDebt, - reserveCache.nextTotalVariableDebt, + vars.totalVariableDebt, reserveCache.nextAvgStableBorrowRate, reserveCache.reserveConfiguration.getReserveFactorMemory() ); @@ -252,12 +248,12 @@ library ReserveLogic { return; } - //calculate the last principal variable debt + //calculate the total variable debt at moment of the last interaction vars.prevTotalVariableDebt = reserveCache.currScaledVariableDebt.rayMul( reserveCache.currVariableBorrowIndex ); - //calculate the new total supply after accumulation of the index + //calculate the new total variable debt after accumulation of the interest on the index vars.currTotalVariableDebt = reserveCache.currScaledVariableDebt.rayMul( reserveCache.nextVariableBorrowIndex ); @@ -379,7 +375,6 @@ library ReserveLogic { // by default the actions are considered as not affecting the debt balances. // if the action involves mint/burn of debt, the cache needs to be updated through refreshDebt() - reserveCache.nextPrincipalStableDebt = reserveCache.currPrincipalStableDebt; reserveCache.nextTotalStableDebt = reserveCache.currTotalStableDebt; reserveCache.nextAvgStableBorrowRate = reserveCache.currAvgStableBorrowRate; @@ -404,15 +399,13 @@ library ReserveLogic { ) internal view { if (stableDebtMinted != 0 || stableDebtBurned != 0) { if (cache.currTotalStableDebt.add(stableDebtMinted) > stableDebtBurned) { - cache.nextPrincipalStableDebt = cache.nextTotalStableDebt = cache - .currTotalStableDebt - .add(stableDebtMinted) - .sub(stableDebtBurned); + cache.nextTotalStableDebt = cache.currTotalStableDebt.add(stableDebtMinted).sub( + stableDebtBurned + ); cache.nextAvgStableBorrowRate = IStableDebtToken(cache.stableDebtTokenAddress) .getAverageStableRate(); } else { - cache.nextPrincipalStableDebt = cache.nextTotalStableDebt = cache - .nextAvgStableBorrowRate = 0; + cache.nextTotalStableDebt = cache.nextAvgStableBorrowRate = 0; } } diff --git a/contracts/protocol/libraries/types/DataTypes.sol b/contracts/protocol/libraries/types/DataTypes.sol index 4a2ce981..62cd4de5 100644 --- a/contracts/protocol/libraries/types/DataTypes.sol +++ b/contracts/protocol/libraries/types/DataTypes.sol @@ -55,11 +55,9 @@ library DataTypes { struct ReserveCache { uint256 currScaledVariableDebt; uint256 nextScaledVariableDebt; - uint256 nextTotalVariableDebt; uint256 currPrincipalStableDebt; uint256 currAvgStableBorrowRate; uint256 currTotalStableDebt; - uint256 nextPrincipalStableDebt; uint256 nextAvgStableBorrowRate; uint256 nextTotalStableDebt; uint256 currLiquidityIndex;