From e5f0206f878874a97f05dbf8c2553d83489d371b Mon Sep 17 00:00:00 2001 From: The3D Date: Fri, 10 Jul 2020 10:57:30 +0200 Subject: [PATCH 1/4] Added atoken approval to LendingPool --- contracts/tokenization/AToken.sol | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/contracts/tokenization/AToken.sol b/contracts/tokenization/AToken.sol index abf0be51..ec7350a1 100644 --- a/contracts/tokenization/AToken.sol +++ b/contracts/tokenization/AToken.sol @@ -1,10 +1,11 @@ // SPDX-License-Identifier: agpl-3.0 pragma solidity ^0.6.8; -import "./ERC20.sol"; -import "../configuration/LendingPoolAddressesProvider.sol"; -import "../lendingpool/LendingPool.sol"; -import "../libraries/WadRayMath.sol"; +import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol"; +import {ERC20} from "./ERC20.sol"; +import {LendingPoolAddressesProvider} from "../configuration/LendingPoolAddressesProvider.sol"; +import {LendingPool} from "../lendingpool/LendingPool.sol"; +import {WadRayMath} from "../libraries/WadRayMath.sol"; /** * @title Aave ERC20 AToken @@ -14,6 +15,7 @@ import "../libraries/WadRayMath.sol"; */ contract AToken is ERC20 { using WadRayMath for uint256; + using SafeERC20 for ERC20; uint256 public constant UINT_MAX_VALUE = uint256(-1); @@ -151,6 +153,7 @@ contract AToken is ERC20 { addressesProvider = _addressesProvider; pool = LendingPool(payable(addressesProvider.getLendingPool())); underlyingAssetAddress = _underlyingAsset; + ERC20(underlyingAssetAddress).safeApprove(address(pool), type(uint256).max); } /** From edd7ad3b155ad784f42d1d6ba0765ae605e0d0c1 Mon Sep 17 00:00:00 2001 From: The3D Date: Fri, 10 Jul 2020 19:16:04 +0200 Subject: [PATCH 2/4] Added transfer of the funds to aTokens --- .../flashloan/base/FlashLoanReceiverBase.sol | 7 +- .../interfaces/IFlashLoanReceiver.sol | 2 +- contracts/lendingpool/LendingPool.sol | 38 +- .../LendingPoolLiquidationManager.sol | 17 +- contracts/libraries/ReserveLogic.sol | 13 +- contracts/libraries/ValidationLogic.sol | 5 +- contracts/misc/AaveProtocolTestHelpers.sol | 2 +- .../mocks/flashloan/MockFlashLoanReceiver.sol | 3 +- contracts/tokenization/AToken.sol | 1251 ++++++++--------- 9 files changed, 664 insertions(+), 674 deletions(-) diff --git a/contracts/flashloan/base/FlashLoanReceiverBase.sol b/contracts/flashloan/base/FlashLoanReceiverBase.sol index 4434ecff..7ecc06f4 100644 --- a/contracts/flashloan/base/FlashLoanReceiverBase.sol +++ b/contracts/flashloan/base/FlashLoanReceiverBase.sol @@ -21,14 +21,13 @@ abstract contract FlashLoanReceiverBase is IFlashLoanReceiver { receive() external payable {} - function transferFundsBackToPoolInternal(address _reserve, uint256 _amount) internal { + function transferFundsBackInternal(address _reserve, address _destination, uint256 _amount) internal { - address payable pool = payable(addressesProvider.getLendingPool()); - - transferInternal(pool,_reserve, _amount); + transferInternal(payable(_destination),_reserve, _amount); } function transferInternal(address payable _destination, address _reserve, uint256 _amount) internal { + if(_reserve == EthAddressLib.ethAddress()) { //solium-disable-next-line _destination.call{value: _amount}(""); diff --git a/contracts/flashloan/interfaces/IFlashLoanReceiver.sol b/contracts/flashloan/interfaces/IFlashLoanReceiver.sol index 9a6a2f7b..44d6f07e 100644 --- a/contracts/flashloan/interfaces/IFlashLoanReceiver.sol +++ b/contracts/flashloan/interfaces/IFlashLoanReceiver.sol @@ -9,5 +9,5 @@ pragma solidity ^0.6.8; **/ interface IFlashLoanReceiver { - function executeOperation(address _reserve, uint256 _amount, uint256 _fee, bytes calldata _params) external; + function executeOperation(address _reserve, address _destination, uint256 _amount, uint256 _fee, bytes calldata _params) external; } diff --git a/contracts/lendingpool/LendingPool.sol b/contracts/lendingpool/LendingPool.sol index f19ba440..595022f2 100644 --- a/contracts/lendingpool/LendingPool.sol +++ b/contracts/lendingpool/LendingPool.sol @@ -261,12 +261,13 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable { uint256 _amount, uint16 _referralCode ) external payable nonReentrant { + ReserveLogic.ReserveData storage reserve = reserves[_reserve]; UserLogic.UserReserveData storage user = usersReserveData[msg.sender][_reserve]; ValidationLogic.validateDeposit(reserve, _amount); - AToken aToken = AToken(reserve.aTokenAddress); + AToken aToken = AToken(payable(reserve.aTokenAddress)); bool isFirstDeposit = aToken.balanceOf(msg.sender) == 0; @@ -280,8 +281,8 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable { //minting AToken to user 1:1 with the specific exchange rate aToken.mintOnDeposit(msg.sender, _amount); - //transfer to the core contract - IERC20(_reserve).universalTransferFromSenderToThis(_amount, true); + //transfer to the aToken contract + IERC20(_reserve).universalTransferFrom(msg.sender, address(aToken), _amount, true); //solium-disable-next-line emit Deposit(_reserve, msg.sender, _amount, _referralCode, block.timestamp); @@ -303,16 +304,20 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable { ReserveLogic.ReserveData storage reserve = reserves[_reserve]; UserLogic.UserReserveData storage user = usersReserveData[_user][_reserve]; + AToken aToken = AToken(payable(reserve.aTokenAddress)); + ValidationLogic.validateRedeem(reserve, _reserve, _amount); + reserve.updateCumulativeIndexesAndTimestamp(); + + reserve.updateInterestRates(_reserve, 0, _amount); + if (_aTokenBalanceAfterRedeem == 0) { user.useAsCollateral = false; } - reserve.updateCumulativeIndexesAndTimestamp(); - reserve.updateInterestRates(_reserve, 0, _amount); - - IERC20(_reserve).universalTransfer(_user, _amount); + + AToken(reserve.aTokenAddress).transferUnderlyingTo(_user, _amount); //solium-disable-next-line emit RedeemUnderlying(_reserve, _user, _amount, block.timestamp); @@ -372,7 +377,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable { reserve.updateInterestRates(_reserve, 0, _amount); //if we reached this point, we can transfer - IERC20(_reserve).universalTransfer(msg.sender, _amount); + AToken(reserve.aTokenAddress).transferUnderlyingTo(msg.sender, _amount); emit Borrow( _reserve, @@ -453,7 +458,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable { reserve.updateInterestRates(_reserve, vars.paybackAmount, 0); - IERC20(_reserve).universalTransferFromSenderToThis(vars.paybackAmount, false); + IERC20(_reserve).universalTransferFrom(msg.sender, reserve.aTokenAddress, vars.paybackAmount, false); if (IERC20(_reserve).isETH()) { //send excess ETH back to the caller if needed @@ -651,6 +656,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable { uint256 protocolFeeBips; uint256 amountFee; uint256 protocolFee; + address payable aTokenAddress; } /** @@ -667,12 +673,15 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable { uint256 _amount, bytes memory _params ) public nonReentrant { + FlashLoanLocalVars memory vars; ReserveLogic.ReserveData storage reserve = reserves[_reserve]; + vars.aTokenAddress = payable(reserve.aTokenAddress); + //check that the reserve has enough available liquidity - vars.availableLiquidityBefore = IERC20(_reserve).universalBalanceOf(address(this)); + vars.availableLiquidityBefore = IERC20(_reserve).universalBalanceOf(vars.aTokenAddress); //calculate amount fee vars.amountFee = _amount.mul(FLASHLOAN_FEE_TOTAL).div(10000); @@ -680,6 +689,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable { //protocol fee is the part of the amountFee reserved for the protocol - the rest goes to depositors vars.protocolFee = vars.amountFee.mul(FLASHLOAN_FEE_PROTOCOL).div(10000); + require( vars.availableLiquidityBefore >= _amount, 'There is not enough liquidity available to borrow' @@ -695,13 +705,13 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable { address payable userPayable = address(uint160(_receiver)); //transfer funds to the receiver - IERC20(_reserve).universalTransfer(userPayable, _amount); + AToken(vars.aTokenAddress).transferUnderlyingTo(userPayable, _amount); //execute action of the receiver - receiver.executeOperation(_reserve, _amount, vars.amountFee, _params); + receiver.executeOperation(_reserve, vars.aTokenAddress, _amount, vars.amountFee, _params); //check that the actual balance of the core contract includes the returned amount - uint256 availableLiquidityAfter = IERC20(_reserve).universalBalanceOf(address(this)); + uint256 availableLiquidityAfter = IERC20(_reserve).universalBalanceOf(vars.aTokenAddress); require( availableLiquidityAfter == vars.availableLiquidityBefore.add(vars.amountFee), @@ -791,7 +801,7 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable { { ReserveLogic.ReserveData memory reserve = reserves[_reserve]; return ( - IERC20(_reserve).universalBalanceOf(address(this)), + IERC20(_reserve).universalBalanceOf(reserve.aTokenAddress), IERC20(reserve.stableDebtTokenAddress).totalSupply(), IERC20(reserve.variableDebtTokenAddress).totalSupply(), reserve.currentLiquidityRate, diff --git a/contracts/lendingpool/LendingPoolLiquidationManager.sol b/contracts/lendingpool/LendingPoolLiquidationManager.sol index 47ed18e6..6641215f 100644 --- a/contracts/lendingpool/LendingPoolLiquidationManager.sol +++ b/contracts/lendingpool/LendingPoolLiquidationManager.sol @@ -192,6 +192,9 @@ contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializabl vars.userCollateralBalance ); + vars.collateralAtoken = AToken(payable(collateralReserve.aTokenAddress)); + + //if principalAmountNeeded < vars.ActualAmountToLiquidate, there isn't enough //of _collateral to cover the actual amount that is being liquidated, hence we liquidate //a smaller amount @@ -202,7 +205,7 @@ contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializabl //if liquidator reclaims the underlying asset, we make sure there is enough available collateral in the reserve if (!_receiveAToken) { - uint256 currentAvailableCollateral = IERC20(_collateral).universalBalanceOf(address(this)); + uint256 currentAvailableCollateral = IERC20(_collateral).universalBalanceOf(address(vars.collateralAtoken)); if (currentAvailableCollateral < vars.maxCollateralToLiquidate) { return ( uint256(LiquidationErrors.NOT_ENOUGH_LIQUIDITY), @@ -219,9 +222,7 @@ contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializabl IVariableDebtToken(principalReserve.variableDebtTokenAddress).burn(_user, vars.userVariableDebt); IStableDebtToken(principalReserve.stableDebtTokenAddress).burn(_user, vars.actualAmountToLiquidate.sub(vars.userVariableDebt)); } - - vars.collateralAtoken = AToken(collateralReserve.aTokenAddress); - + //if liquidator reclaims the aToken, he receives the equivalent atoken amount if (_receiveAToken) { vars.collateralAtoken.transferOnLiquidation( @@ -233,13 +234,11 @@ contract LendingPoolLiquidationManager is ReentrancyGuard, VersionedInitializabl //otherwise receives the underlying asset //burn the equivalent amount of atoken vars.collateralAtoken.burnOnLiquidation(_user, vars.maxCollateralToLiquidate); - - IERC20(_collateral).universalTransfer(msg.sender, vars.maxCollateralToLiquidate); + vars.collateralAtoken.transferUnderlyingTo(msg.sender, vars.maxCollateralToLiquidate); } - //transfers the principal currency to the pool - IERC20(_reserve).universalTransferFromSenderToThis(vars.actualAmountToLiquidate, true); - + //transfers the principal currency to the aToken + IERC20(_reserve).universalTransferFrom(msg.sender, principalReserve.aTokenAddress, vars.actualAmountToLiquidate, true); emit LiquidationCall( _collateral, diff --git a/contracts/libraries/ReserveLogic.sol b/contracts/libraries/ReserveLogic.sol index 09545406..538edb74 100644 --- a/contracts/libraries/ReserveLogic.sol +++ b/contracts/libraries/ReserveLogic.sol @@ -15,6 +15,7 @@ import '../interfaces/ILendingRateOracle.sol'; import '../interfaces/IReserveInterestRateStrategy.sol'; import '../tokenization/AToken.sol'; import './WadRayMath.sol'; +import '@nomiclabs/buidler/console.sol'; /** * @title ReserveLogic library @@ -56,7 +57,7 @@ library ReserveLogic { /** * @dev address of the aToken representing the asset **/ - address aTokenAddress; + address payable aTokenAddress; address stableDebtTokenAddress; address variableDebtTokenAddress; /** @@ -193,7 +194,7 @@ library ReserveLogic { _self.lastVariableBorrowCumulativeIndex = WadRayMath.ray(); } - _self.aTokenAddress = _aTokenAddress; + _self.aTokenAddress = payable(_aTokenAddress); _self.stableDebtTokenAddress = _stableDebtAddress; _self.variableDebtTokenAddress = _variableDebtAddress; _self.decimals = _decimals; @@ -353,15 +354,11 @@ library ReserveLogic { uint256 _liquidityAdded, uint256 _liquidityTaken ) internal { + uint256 currentAvgStableRate = IStableDebtToken(_reserve.stableDebtTokenAddress) .getAverageStableRate(); - uint256 balance = IERC20(_reserveAddress).universalBalanceOf(address(this)); - - //if the reserve is ETH, the msg.value has already been cumulated to the balance of the reserve - if (IERC20(_reserveAddress).isETH()) { - balance = balance.sub(msg.value); - } + uint256 balance = IERC20(_reserveAddress).universalBalanceOf(_reserve.aTokenAddress); ( uint256 newLiquidityRate, diff --git a/contracts/libraries/ValidationLogic.sol b/contracts/libraries/ValidationLogic.sol index ea10d7b6..b5adf754 100644 --- a/contracts/libraries/ValidationLogic.sol +++ b/contracts/libraries/ValidationLogic.sol @@ -53,7 +53,8 @@ library ValidationLogic { require(msg.sender == _reserve.aTokenAddress, '31'); - uint256 currentAvailableLiquidity = IERC20(_reserveAddress).universalBalanceOf(address(this)); + uint256 currentAvailableLiquidity = IERC20(_reserveAddress).universalBalanceOf(address(_reserve.aTokenAddress)); + require(currentAvailableLiquidity >= _amount, '4'); } @@ -117,7 +118,7 @@ library ValidationLogic { ); //check that the amount is available in the reserve - vars.availableLiquidity = IERC20(_reserveAddress).universalBalanceOf(address(this)); + vars.availableLiquidity = IERC20(_reserveAddress).universalBalanceOf(address(_reserve.aTokenAddress)); require(vars.availableLiquidity >= _amount, '7'); diff --git a/contracts/misc/AaveProtocolTestHelpers.sol b/contracts/misc/AaveProtocolTestHelpers.sol index e48b5a5b..f0b1eac8 100644 --- a/contracts/misc/AaveProtocolTestHelpers.sol +++ b/contracts/misc/AaveProtocolTestHelpers.sol @@ -38,7 +38,7 @@ contract AaveProtocolTestHelpers { for (uint256 i = 0; i < reserves.length; i++) { (address aTokenAddress,,) = pool.getReserveTokensAddresses(reserves[i]); aTokens[i] = TokenData({ - symbol: AToken(aTokenAddress).symbol(), + symbol: AToken(payable(aTokenAddress)).symbol(), tokenAddress: aTokenAddress }); } diff --git a/contracts/mocks/flashloan/MockFlashLoanReceiver.sol b/contracts/mocks/flashloan/MockFlashLoanReceiver.sol index 688d507f..2eae3637 100644 --- a/contracts/mocks/flashloan/MockFlashLoanReceiver.sol +++ b/contracts/mocks/flashloan/MockFlashLoanReceiver.sol @@ -24,6 +24,7 @@ contract MockFlashLoanReceiver is FlashLoanReceiverBase { function executeOperation( address _reserve, + address _destination, uint256 _amount, uint256 _fee, bytes memory _params) public override { @@ -46,7 +47,7 @@ contract MockFlashLoanReceiver is FlashLoanReceiverBase { token.mint(_fee); } //returning amount + fee to the destination - transferFundsBackToPoolInternal(_reserve, _amount.add(_fee)); + transferFundsBackInternal(_reserve, _destination, _amount.add(_fee)); emit ExecutedWithSuccess(_reserve, _amount, _fee); } } \ No newline at end of file diff --git a/contracts/tokenization/AToken.sol b/contracts/tokenization/AToken.sol index ec7350a1..b123206f 100644 --- a/contracts/tokenization/AToken.sol +++ b/contracts/tokenization/AToken.sol @@ -1,11 +1,12 @@ // SPDX-License-Identifier: agpl-3.0 pragma solidity ^0.6.8; -import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol"; -import {ERC20} from "./ERC20.sol"; -import {LendingPoolAddressesProvider} from "../configuration/LendingPoolAddressesProvider.sol"; -import {LendingPool} from "../lendingpool/LendingPool.sol"; -import {WadRayMath} from "../libraries/WadRayMath.sol"; +import {ERC20} from './ERC20.sol'; +import {LendingPoolAddressesProvider} from '../configuration/LendingPoolAddressesProvider.sol'; +import {LendingPool} from '../lendingpool/LendingPool.sol'; +import {WadRayMath} from '../libraries/WadRayMath.sol'; +import {UniversalERC20} from '../libraries/UniversalERC20.sol'; +import '@nomiclabs/buidler/console.sol'; /** * @title Aave ERC20 AToken @@ -14,657 +15,639 @@ import {WadRayMath} from "../libraries/WadRayMath.sol"; * @author Aave */ contract AToken is ERC20 { - using WadRayMath for uint256; - using SafeERC20 for ERC20; + using WadRayMath for uint256; + using UniversalERC20 for ERC20; - uint256 public constant UINT_MAX_VALUE = uint256(-1); + uint256 public constant UINT_MAX_VALUE = uint256(-1); - /** - * @dev emitted after the redeem action - * @param _from the address performing the redeem - * @param _value the amount to be redeemed - * @param _fromBalanceIncrease the cumulated balance since the last update of the user - * @param _fromIndex the last index of the user - **/ - event Redeem( - address indexed _from, - uint256 _value, - uint256 _fromBalanceIncrease, - uint256 _fromIndex + /** + * @dev emitted after the redeem action + * @param _from the address performing the redeem + * @param _value the amount to be redeemed + * @param _fromBalanceIncrease the cumulated balance since the last update of the user + * @param _fromIndex the last index of the user + **/ + event Redeem( + address indexed _from, + uint256 _value, + uint256 _fromBalanceIncrease, + uint256 _fromIndex + ); + + /** + * @dev emitted after the mint action + * @param _from the address performing the mint + * @param _value the amount to be minted + * @param _fromBalanceIncrease the cumulated balance since the last update of the user + * @param _fromIndex the last index of the user + **/ + event MintOnDeposit( + address indexed _from, + uint256 _value, + uint256 _fromBalanceIncrease, + uint256 _fromIndex + ); + + /** + * @dev emitted during the liquidation action, when the liquidator reclaims the underlying + * asset + * @param _from the address from which the tokens are being burned + * @param _value the amount to be burned + * @param _fromBalanceIncrease the cumulated balance since the last update of the user + * @param _fromIndex the last index of the user + **/ + event BurnOnLiquidation( + address indexed _from, + uint256 _value, + uint256 _fromBalanceIncrease, + uint256 _fromIndex + ); + + /** + * @dev emitted during the transfer action + * @param _from the address from which the tokens are being transferred + * @param _to the adress of the destination + * @param _value the amount to be minted + * @param _fromBalanceIncrease the cumulated balance since the last update of the user + * @param _toBalanceIncrease the cumulated balance since the last update of the destination + * @param _fromIndex the last index of the user + * @param _toIndex the last index of the liquidator + **/ + event BalanceTransfer( + address indexed _from, + address indexed _to, + uint256 _value, + uint256 _fromBalanceIncrease, + uint256 _toBalanceIncrease, + uint256 _fromIndex, + uint256 _toIndex + ); + + /** + * @dev emitted when the accumulation of the interest + * by an user is redirected to another user + * @param _from the address from which the interest is being redirected + * @param _to the adress of the destination + * @param _fromBalanceIncrease the cumulated balance since the last update of the user + * @param _fromIndex the last index of the user + **/ + event InterestStreamRedirected( + address indexed _from, + address indexed _to, + uint256 _redirectedBalance, + uint256 _fromBalanceIncrease, + uint256 _fromIndex + ); + + /** + * @dev emitted when the redirected balance of an user is being updated + * @param _targetAddress the address of which the balance is being updated + * @param _targetBalanceIncrease the cumulated balance since the last update of the target + * @param _targetIndex the last index of the user + * @param _redirectedBalanceAdded the redirected balance being added + * @param _redirectedBalanceRemoved the redirected balance being removed + **/ + event RedirectedBalanceUpdated( + address indexed _targetAddress, + uint256 _targetBalanceIncrease, + uint256 _targetIndex, + uint256 _redirectedBalanceAdded, + uint256 _redirectedBalanceRemoved + ); + + event InterestRedirectionAllowanceChanged(address indexed _from, address indexed _to); + + address public underlyingAssetAddress; + + mapping(address => uint256) private userIndexes; + mapping(address => address) private interestRedirectionAddresses; + mapping(address => uint256) private redirectedBalances; + mapping(address => address) private interestRedirectionAllowances; + + LendingPoolAddressesProvider private addressesProvider; + LendingPool private pool; + + modifier onlyLendingPool { + require(msg.sender == address(pool), 'The caller of this function must be a lending pool'); + _; + } + + modifier whenTransferAllowed(address _from, uint256 _amount) { + require(isTransferAllowed(_from, _amount), 'Transfer cannot be allowed.'); + _; + } + + constructor( + LendingPoolAddressesProvider _addressesProvider, + address _underlyingAsset, + uint8 _underlyingAssetDecimals, + string memory _name, + string memory _symbol + ) public ERC20(_name, _symbol) { + _setupDecimals(_underlyingAssetDecimals); + addressesProvider = _addressesProvider; + pool = LendingPool(payable(addressesProvider.getLendingPool())); + underlyingAssetAddress = _underlyingAsset; + } + + /** + * @notice ERC20 implementation internal function backing transfer() and transferFrom() + * @dev validates the transfer before allowing it. NOTE: This is not standard ERC20 behavior + **/ + function _transfer( + address _from, + address _to, + uint256 _amount + ) internal override whenTransferAllowed(_from, _amount) { + executeTransferInternal(_from, _to, _amount); + } + + /** + * @dev redirects the interest generated to a target address. + * when the interest is redirected, the user balance is added to + * the recepient redirected balance. + * @param _to the address to which the interest will be redirected + **/ + function redirectInterestStream(address _to) external { + redirectInterestStreamInternal(msg.sender, _to); + } + + /** + * @dev redirects the interest generated by _from to a target address. + * when the interest is redirected, the user balance is added to + * the recepient redirected balance. The caller needs to have allowance on + * the interest redirection to be able to execute the function. + * @param _from the address of the user whom interest is being redirected + * @param _to the address to which the interest will be redirected + **/ + function redirectInterestStreamOf(address _from, address _to) external { + require( + msg.sender == interestRedirectionAllowances[_from], + 'Caller is not allowed to redirect the interest of the user' + ); + redirectInterestStreamInternal(_from, _to); + } + + /** + * @dev gives allowance to an address to execute the interest redirection + * on behalf of the caller. + * @param _to the address to which the interest will be redirected. Pass address(0) to reset + * the allowance. + **/ + function allowInterestRedirectionTo(address _to) external { + require(_to != msg.sender, 'User cannot give allowance to himself'); + interestRedirectionAllowances[msg.sender] = _to; + emit InterestRedirectionAllowanceChanged(msg.sender, _to); + } + + /** + * @dev redeems aToken for the underlying asset + * @param _amount the amount being redeemed + **/ + function redeem(uint256 _amount) external { + require(_amount > 0, 'Amount to redeem needs to be > 0'); + + //cumulates the balance of the user + (, uint256 currentBalance, uint256 balanceIncrease, uint256 index) = cumulateBalanceInternal( + msg.sender ); - /** - * @dev emitted after the mint action - * @param _from the address performing the mint - * @param _value the amount to be minted - * @param _fromBalanceIncrease the cumulated balance since the last update of the user - * @param _fromIndex the last index of the user - **/ - event MintOnDeposit( - address indexed _from, - uint256 _value, - uint256 _fromBalanceIncrease, - uint256 _fromIndex + uint256 amountToRedeem = _amount; + + //if amount is equal to uint(-1), the user wants to redeem everything + if (_amount == UINT_MAX_VALUE) { + amountToRedeem = currentBalance; + } + + require(amountToRedeem <= currentBalance, 'User cannot redeem more than the available balance'); + + //check that the user is allowed to redeem the amount + require(isTransferAllowed(msg.sender, amountToRedeem), 'Transfer cannot be allowed.'); + + //if the user is redirecting his interest towards someone else, + //we update the redirected balance of the redirection address by adding the accrued interest, + //and removing the amount to redeem + updateRedirectedBalanceOfRedirectionAddressInternal( + msg.sender, + balanceIncrease, + amountToRedeem ); - /** - * @dev emitted during the liquidation action, when the liquidator reclaims the underlying - * asset - * @param _from the address from which the tokens are being burned - * @param _value the amount to be burned - * @param _fromBalanceIncrease the cumulated balance since the last update of the user - * @param _fromIndex the last index of the user - **/ - event BurnOnLiquidation( - address indexed _from, - uint256 _value, - uint256 _fromBalanceIncrease, - uint256 _fromIndex + // burns tokens equivalent to the amount requested + _burn(msg.sender, amountToRedeem); + + bool userIndexReset = false; + //reset the user data if the remaining balance is 0 + if (currentBalance.sub(amountToRedeem) == 0) { + userIndexReset = resetDataOnZeroBalanceInternal(msg.sender); + } + + // executes redeem of the underlying asset + pool.redeemUnderlying( + underlyingAssetAddress, + msg.sender, + amountToRedeem, + currentBalance.sub(amountToRedeem) ); - /** - * @dev emitted during the transfer action - * @param _from the address from which the tokens are being transferred - * @param _to the adress of the destination - * @param _value the amount to be minted - * @param _fromBalanceIncrease the cumulated balance since the last update of the user - * @param _toBalanceIncrease the cumulated balance since the last update of the destination - * @param _fromIndex the last index of the user - * @param _toIndex the last index of the liquidator - **/ - event BalanceTransfer( - address indexed _from, - address indexed _to, - uint256 _value, - uint256 _fromBalanceIncrease, - uint256 _toBalanceIncrease, - uint256 _fromIndex, - uint256 _toIndex + emit Redeem(msg.sender, amountToRedeem, balanceIncrease, userIndexReset ? 0 : index); + } + + /** + * @dev mints token in the event of users depositing the underlying asset into the lending pool + * only lending pools can call this function + * @param _account the address receiving the minted tokens + * @param _amount the amount of tokens to mint + */ + function mintOnDeposit(address _account, uint256 _amount) external onlyLendingPool { + //cumulates the balance of the user + (, , uint256 balanceIncrease, uint256 index) = cumulateBalanceInternal(_account); + + //if the user is redirecting his interest towards someone else, + //we update the redirected balance of the redirection address by adding the accrued interest + //and the amount deposited + updateRedirectedBalanceOfRedirectionAddressInternal(_account, balanceIncrease.add(_amount), 0); + + //mint an equivalent amount of tokens to cover the new deposit + _mint(_account, _amount); + + emit MintOnDeposit(_account, _amount, balanceIncrease, index); + } + + /** + * @dev burns token in the event of a borrow being liquidated, in case the liquidators reclaims the underlying asset + * Transfer of the liquidated asset is executed by the lending pool contract. + * only lending pools can call this function + * @param _account the address from which burn the aTokens + * @param _value the amount to burn + **/ + function burnOnLiquidation(address _account, uint256 _value) external onlyLendingPool { + //cumulates the balance of the user being liquidated + (, uint256 accountBalance, uint256 balanceIncrease, uint256 index) = cumulateBalanceInternal( + _account ); - /** - * @dev emitted when the accumulation of the interest - * by an user is redirected to another user - * @param _from the address from which the interest is being redirected - * @param _to the adress of the destination - * @param _fromBalanceIncrease the cumulated balance since the last update of the user - * @param _fromIndex the last index of the user - **/ - event InterestStreamRedirected( - address indexed _from, - address indexed _to, - uint256 _redirectedBalance, - uint256 _fromBalanceIncrease, - uint256 _fromIndex + //adds the accrued interest and substracts the burned amount to + //the redirected balance + updateRedirectedBalanceOfRedirectionAddressInternal(_account, balanceIncrease, _value); + + //burns the requested amount of tokens + _burn(_account, _value); + + bool userIndexReset = false; + //reset the user data if the remaining balance is 0 + if (accountBalance.sub(_value) == 0) { + userIndexReset = resetDataOnZeroBalanceInternal(_account); + } + + emit BurnOnLiquidation(_account, _value, balanceIncrease, userIndexReset ? 0 : index); + } + + /** + * @dev transfers tokens in the event of a borrow being liquidated, in case the liquidators reclaims the aToken + * only lending pools can call this function + * @param _from the address from which transfer the aTokens + * @param _to the destination address + * @param _value the amount to transfer + **/ + function transferOnLiquidation( + address _from, + address _to, + uint256 _value + ) external onlyLendingPool { + //being a normal transfer, the Transfer() and BalanceTransfer() are emitted + //so no need to emit a specific event here + executeTransferInternal(_from, _to, _value); + } + + /** + * @dev calculates the balance of the user, which is the + * principal balance + interest generated by the principal balance + interest generated by the redirected balance + * @param _user the user for which the balance is being calculated + * @return the total balance of the user + **/ + function balanceOf(address _user) public override view returns (uint256) { + //current principal balance of the user + uint256 currentPrincipalBalance = super.balanceOf(_user); + //balance redirected by other users to _user for interest rate accrual + uint256 redirectedBalance = redirectedBalances[_user]; + + if (currentPrincipalBalance == 0 && redirectedBalance == 0) { + return 0; + } + //if the _user is not redirecting the interest to anybody, accrues + //the interest for himself + + if (interestRedirectionAddresses[_user] == address(0)) { + //accruing for himself means that both the principal balance and + //the redirected balance partecipate in the interest + return + calculateCumulatedBalanceInternal(_user, currentPrincipalBalance.add(redirectedBalance)) + .sub(redirectedBalance); + } else { + //if the user redirected the interest, then only the redirected + //balance generates interest. In that case, the interest generated + //by the redirected balance is added to the current principal balance. + return + currentPrincipalBalance.add( + calculateCumulatedBalanceInternal(_user, redirectedBalance).sub(redirectedBalance) + ); + } + } + + /** + * @dev returns the principal balance of the user. The principal balance is the last + * updated stored balance, which does not consider the perpetually accruing interest. + * @param _user the address of the user + * @return the principal balance of the user + **/ + function principalBalanceOf(address _user) external view returns (uint256) { + return super.balanceOf(_user); + } + + /** + * @dev calculates the total supply of the specific aToken + * since the balance of every single user increases over time, the total supply + * does that too. + * @return the current total supply + **/ + function totalSupply() public override view returns (uint256) { + uint256 currentSupplyPrincipal = super.totalSupply(); + + if (currentSupplyPrincipal == 0) { + return 0; + } + + return + currentSupplyPrincipal + .wadToRay() + .rayMul(pool.getReserveNormalizedIncome(underlyingAssetAddress)) + .rayToWad(); + } + + /** + * @dev Used to validate transfers before actually executing them. + * @param _user address of the user to check + * @param _amount the amount to check + * @return true if the _user can transfer _amount, false otherwise + **/ + function isTransferAllowed(address _user, uint256 _amount) public view returns (bool) { + return pool.balanceDecreaseAllowed(underlyingAssetAddress, _user, _amount); + } + + /** + * @dev returns the last index of the user, used to calculate the balance of the user + * @param _user address of the user + * @return the last user index + **/ + function getUserIndex(address _user) external view returns (uint256) { + return userIndexes[_user]; + } + + /** + * @dev returns the address to which the interest is redirected + * @param _user address of the user + * @return 0 if there is no redirection, an address otherwise + **/ + function getInterestRedirectionAddress(address _user) external view returns (address) { + return interestRedirectionAddresses[_user]; + } + + /** + * @dev returns the redirected balance of the user. The redirected balance is the balance + * redirected by other accounts to the user, that is accrueing interest for him. + * @param _user address of the user + * @return the total redirected balance + **/ + function getRedirectedBalance(address _user) external view returns (uint256) { + return redirectedBalances[_user]; + } + + /** + * @dev accumulates the accrued interest of the user to the principal balance + * @param _user the address of the user for which the interest is being accumulated + * @return the previous principal balance, the new principal balance, the balance increase + * and the new user index + **/ + function cumulateBalanceInternal(address _user) + internal + returns ( + uint256, + uint256, + uint256, + uint256 + ) + { + uint256 previousPrincipalBalance = super.balanceOf(_user); + + //calculate the accrued interest since the last accumulation + uint256 balanceIncrease = balanceOf(_user).sub(previousPrincipalBalance); + //mints an amount of tokens equivalent to the amount accumulated + _mint(_user, balanceIncrease); + //updates the user index + uint256 index = userIndexes[_user] = pool.getReserveNormalizedIncome(underlyingAssetAddress); + return ( + previousPrincipalBalance, + previousPrincipalBalance.add(balanceIncrease), + balanceIncrease, + index ); + } - /** - * @dev emitted when the redirected balance of an user is being updated - * @param _targetAddress the address of which the balance is being updated - * @param _targetBalanceIncrease the cumulated balance since the last update of the target - * @param _targetIndex the last index of the user - * @param _redirectedBalanceAdded the redirected balance being added - * @param _redirectedBalanceRemoved the redirected balance being removed - **/ - event RedirectedBalanceUpdated( - address indexed _targetAddress, - uint256 _targetBalanceIncrease, - uint256 _targetIndex, - uint256 _redirectedBalanceAdded, - uint256 _redirectedBalanceRemoved + /** + * @dev updates the redirected balance of the user. If the user is not redirecting his + * interest, nothing is executed. + * @param _user the address of the user for which the interest is being accumulated + * @param _balanceToAdd the amount to add to the redirected balance + * @param _balanceToRemove the amount to remove from the redirected balance + **/ + function updateRedirectedBalanceOfRedirectionAddressInternal( + address _user, + uint256 _balanceToAdd, + uint256 _balanceToRemove + ) internal { + address redirectionAddress = interestRedirectionAddresses[_user]; + //if there isn't any redirection, nothing to be done + if (redirectionAddress == address(0)) { + return; + } + + //compound balances of the redirected address + (, , uint256 balanceIncrease, uint256 index) = cumulateBalanceInternal(redirectionAddress); + + //updating the redirected balance + redirectedBalances[redirectionAddress] = redirectedBalances[redirectionAddress] + .add(_balanceToAdd) + .sub(_balanceToRemove); + + //if the interest of redirectionAddress is also being redirected, we need to update + //the redirected balance of the redirection target by adding the balance increase + address targetOfRedirectionAddress = interestRedirectionAddresses[redirectionAddress]; + + if (targetOfRedirectionAddress != address(0)) { + redirectedBalances[targetOfRedirectionAddress] = redirectedBalances[targetOfRedirectionAddress] + .add(balanceIncrease); + } + + emit RedirectedBalanceUpdated( + redirectionAddress, + balanceIncrease, + index, + _balanceToAdd, + _balanceToRemove ); + } - event InterestRedirectionAllowanceChanged( - address indexed _from, - address indexed _to + /** + * @dev calculate the interest accrued by _user on a specific balance + * @param _user the address of the user for which the interest is being accumulated + * @param _balance the balance on which the interest is calculated + * @return the interest rate accrued + **/ + function calculateCumulatedBalanceInternal(address _user, uint256 _balance) + internal + view + returns (uint256) + { + return + _balance + .wadToRay() + .rayMul(pool.getReserveNormalizedIncome(underlyingAssetAddress)) + .rayDiv(userIndexes[_user]) + .rayToWad(); + } + + /** + * @dev executes the transfer of aTokens, invoked by both _transfer() and + * transferOnLiquidation() + * @param _from the address from which transfer the aTokens + * @param _to the destination address + * @param _value the amount to transfer + **/ + function executeTransferInternal( + address _from, + address _to, + uint256 _value + ) internal { + require(_value > 0, 'Transferred amount needs to be greater than zero'); + + //cumulate the balance of the sender + ( + , + uint256 fromBalance, + uint256 fromBalanceIncrease, + uint256 fromIndex + ) = cumulateBalanceInternal(_from); + + //cumulate the balance of the receiver + (, , uint256 toBalanceIncrease, uint256 toIndex) = cumulateBalanceInternal(_to); + + //if the sender is redirecting his interest towards someone else, + //adds to the redirected balance the accrued interest and removes the amount + //being transferred + updateRedirectedBalanceOfRedirectionAddressInternal(_from, fromBalanceIncrease, _value); + + //if the receiver is redirecting his interest towards someone else, + //adds to the redirected balance the accrued interest and the amount + //being transferred + updateRedirectedBalanceOfRedirectionAddressInternal(_to, toBalanceIncrease.add(_value), 0); + + //performs the transfer + super._transfer(_from, _to, _value); + + bool fromIndexReset = false; + //reset the user data if the remaining balance is 0 + if (fromBalance.sub(_value) == 0) { + fromIndexReset = resetDataOnZeroBalanceInternal(_from); + } + + emit BalanceTransfer( + _from, + _to, + _value, + fromBalanceIncrease, + toBalanceIncrease, + fromIndexReset ? 0 : fromIndex, + toIndex ); + } - address public underlyingAssetAddress; + /** + * @dev executes the redirection of the interest from one address to another. + * immediately after redirection, the destination address will start to accrue interest. + * @param _from the address from which transfer the aTokens + * @param _to the destination address + **/ + function redirectInterestStreamInternal(address _from, address _to) internal { + address currentRedirectionAddress = interestRedirectionAddresses[_from]; - mapping (address => uint256) private userIndexes; - mapping (address => address) private interestRedirectionAddresses; - mapping (address => uint256) private redirectedBalances; - mapping (address => address) private interestRedirectionAllowances; + require(_to != currentRedirectionAddress, 'Interest is already redirected to the user'); - LendingPoolAddressesProvider private addressesProvider; - LendingPool private pool; + //accumulates the accrued interest to the principal + ( + uint256 previousPrincipalBalance, + uint256 fromBalance, + uint256 balanceIncrease, + uint256 fromIndex + ) = cumulateBalanceInternal(_from); - modifier onlyLendingPool { - require( - msg.sender == address(pool), - "The caller of this function must be a lending pool" - ); - _; + require(fromBalance > 0, 'Interest stream can only be redirected if there is a valid balance'); + + //if the user is already redirecting the interest to someone, before changing + //the redirection address we substract the redirected balance of the previous + //recipient + if (currentRedirectionAddress != address(0)) { + updateRedirectedBalanceOfRedirectionAddressInternal(_from, 0, previousPrincipalBalance); } - modifier whenTransferAllowed(address _from, uint256 _amount) { - require(isTransferAllowed(_from, _amount), "Transfer cannot be allowed."); - _; + //if the user is redirecting the interest back to himself, + //we simply set to 0 the interest redirection address + if (_to == _from) { + interestRedirectionAddresses[_from] = address(0); + emit InterestStreamRedirected(_from, address(0), fromBalance, balanceIncrease, fromIndex); + return; } - constructor( - LendingPoolAddressesProvider _addressesProvider, - address _underlyingAsset, - uint8 _underlyingAssetDecimals, - string memory _name, - string memory _symbol - ) public ERC20(_name, _symbol) { - _setupDecimals(_underlyingAssetDecimals); - addressesProvider = _addressesProvider; - pool = LendingPool(payable(addressesProvider.getLendingPool())); - underlyingAssetAddress = _underlyingAsset; - ERC20(underlyingAssetAddress).safeApprove(address(pool), type(uint256).max); - } - - /** - * @notice ERC20 implementation internal function backing transfer() and transferFrom() - * @dev validates the transfer before allowing it. NOTE: This is not standard ERC20 behavior - **/ - function _transfer(address _from, address _to, uint256 _amount) internal override whenTransferAllowed(_from, _amount) { - - executeTransferInternal(_from, _to, _amount); - } - - - /** - * @dev redirects the interest generated to a target address. - * when the interest is redirected, the user balance is added to - * the recepient redirected balance. - * @param _to the address to which the interest will be redirected - **/ - function redirectInterestStream(address _to) external { - redirectInterestStreamInternal(msg.sender, _to); - } - - /** - * @dev redirects the interest generated by _from to a target address. - * when the interest is redirected, the user balance is added to - * the recepient redirected balance. The caller needs to have allowance on - * the interest redirection to be able to execute the function. - * @param _from the address of the user whom interest is being redirected - * @param _to the address to which the interest will be redirected - **/ - function redirectInterestStreamOf(address _from, address _to) external { - require( - msg.sender == interestRedirectionAllowances[_from], - "Caller is not allowed to redirect the interest of the user" - ); - redirectInterestStreamInternal(_from,_to); - } - - /** - * @dev gives allowance to an address to execute the interest redirection - * on behalf of the caller. - * @param _to the address to which the interest will be redirected. Pass address(0) to reset - * the allowance. - **/ - function allowInterestRedirectionTo(address _to) external { - require(_to != msg.sender, "User cannot give allowance to himself"); - interestRedirectionAllowances[msg.sender] = _to; - emit InterestRedirectionAllowanceChanged( - msg.sender, - _to - ); - } - - /** - * @dev redeems aToken for the underlying asset - * @param _amount the amount being redeemed - **/ - function redeem(uint256 _amount) external { - - require(_amount > 0, "Amount to redeem needs to be > 0"); - - //cumulates the balance of the user - (, - uint256 currentBalance, - uint256 balanceIncrease, - uint256 index) = cumulateBalanceInternal(msg.sender); - - uint256 amountToRedeem = _amount; - - //if amount is equal to uint(-1), the user wants to redeem everything - if(_amount == UINT_MAX_VALUE){ - amountToRedeem = currentBalance; - } - - require(amountToRedeem <= currentBalance, "User cannot redeem more than the available balance"); - - //check that the user is allowed to redeem the amount - require(isTransferAllowed(msg.sender, amountToRedeem), "Transfer cannot be allowed."); - - //if the user is redirecting his interest towards someone else, - //we update the redirected balance of the redirection address by adding the accrued interest, - //and removing the amount to redeem - updateRedirectedBalanceOfRedirectionAddressInternal(msg.sender, balanceIncrease, amountToRedeem); - - // burns tokens equivalent to the amount requested - _burn(msg.sender, amountToRedeem); - - bool userIndexReset = false; - //reset the user data if the remaining balance is 0 - if(currentBalance.sub(amountToRedeem) == 0){ - userIndexReset = resetDataOnZeroBalanceInternal(msg.sender); - } - - // executes redeem of the underlying asset - pool.redeemUnderlying( - underlyingAssetAddress, - msg.sender, - amountToRedeem, - currentBalance.sub(amountToRedeem) - ); - - emit Redeem(msg.sender, amountToRedeem, balanceIncrease, userIndexReset ? 0 : index); - } - - /** - * @dev mints token in the event of users depositing the underlying asset into the lending pool - * only lending pools can call this function - * @param _account the address receiving the minted tokens - * @param _amount the amount of tokens to mint - */ - function mintOnDeposit(address _account, uint256 _amount) external onlyLendingPool { - - //cumulates the balance of the user - (, - , - uint256 balanceIncrease, - uint256 index) = cumulateBalanceInternal(_account); - - //if the user is redirecting his interest towards someone else, - //we update the redirected balance of the redirection address by adding the accrued interest - //and the amount deposited - updateRedirectedBalanceOfRedirectionAddressInternal(_account, balanceIncrease.add(_amount), 0); - - //mint an equivalent amount of tokens to cover the new deposit - _mint(_account, _amount); - - emit MintOnDeposit(_account, _amount, balanceIncrease, index); - } - - /** - * @dev burns token in the event of a borrow being liquidated, in case the liquidators reclaims the underlying asset - * Transfer of the liquidated asset is executed by the lending pool contract. - * only lending pools can call this function - * @param _account the address from which burn the aTokens - * @param _value the amount to burn - **/ - function burnOnLiquidation(address _account, uint256 _value) external onlyLendingPool { - - //cumulates the balance of the user being liquidated - (,uint256 accountBalance,uint256 balanceIncrease,uint256 index) = cumulateBalanceInternal(_account); - - //adds the accrued interest and substracts the burned amount to - //the redirected balance - updateRedirectedBalanceOfRedirectionAddressInternal(_account, balanceIncrease, _value); - - //burns the requested amount of tokens - _burn(_account, _value); - - bool userIndexReset = false; - //reset the user data if the remaining balance is 0 - if(accountBalance.sub(_value) == 0){ - userIndexReset = resetDataOnZeroBalanceInternal(_account); - } - - emit BurnOnLiquidation(_account, _value, balanceIncrease, userIndexReset ? 0 : index); - } - - /** - * @dev transfers tokens in the event of a borrow being liquidated, in case the liquidators reclaims the aToken - * only lending pools can call this function - * @param _from the address from which transfer the aTokens - * @param _to the destination address - * @param _value the amount to transfer - **/ - function transferOnLiquidation(address _from, address _to, uint256 _value) external onlyLendingPool { - - //being a normal transfer, the Transfer() and BalanceTransfer() are emitted - //so no need to emit a specific event here - executeTransferInternal(_from, _to, _value); - } - - /** - * @dev calculates the balance of the user, which is the - * principal balance + interest generated by the principal balance + interest generated by the redirected balance - * @param _user the user for which the balance is being calculated - * @return the total balance of the user - **/ - function balanceOf(address _user) public override view returns(uint256) { - - //current principal balance of the user - uint256 currentPrincipalBalance = super.balanceOf(_user); - //balance redirected by other users to _user for interest rate accrual - uint256 redirectedBalance = redirectedBalances[_user]; - - if(currentPrincipalBalance == 0 && redirectedBalance == 0){ - return 0; - } - //if the _user is not redirecting the interest to anybody, accrues - //the interest for himself - - if(interestRedirectionAddresses[_user] == address(0)){ - - //accruing for himself means that both the principal balance and - //the redirected balance partecipate in the interest - return calculateCumulatedBalanceInternal( - _user, - currentPrincipalBalance.add(redirectedBalance) - ) - .sub(redirectedBalance); - } - else { - //if the user redirected the interest, then only the redirected - //balance generates interest. In that case, the interest generated - //by the redirected balance is added to the current principal balance. - return currentPrincipalBalance.add( - calculateCumulatedBalanceInternal( - _user, - redirectedBalance - ) - .sub(redirectedBalance) - ); - } - } - - /** - * @dev returns the principal balance of the user. The principal balance is the last - * updated stored balance, which does not consider the perpetually accruing interest. - * @param _user the address of the user - * @return the principal balance of the user - **/ - function principalBalanceOf(address _user) external view returns(uint256) { - return super.balanceOf(_user); - } - - - /** - * @dev calculates the total supply of the specific aToken - * since the balance of every single user increases over time, the total supply - * does that too. - * @return the current total supply - **/ - function totalSupply() public override view returns(uint256) { - - uint256 currentSupplyPrincipal = super.totalSupply(); - - if(currentSupplyPrincipal == 0){ - return 0; - } - - return currentSupplyPrincipal - .wadToRay() - .rayMul(pool.getReserveNormalizedIncome(underlyingAssetAddress)) - .rayToWad(); - } - - - /** - * @dev Used to validate transfers before actually executing them. - * @param _user address of the user to check - * @param _amount the amount to check - * @return true if the _user can transfer _amount, false otherwise - **/ - function isTransferAllowed(address _user, uint256 _amount) public view returns (bool) { - return pool.balanceDecreaseAllowed(underlyingAssetAddress, _user, _amount); - } - - /** - * @dev returns the last index of the user, used to calculate the balance of the user - * @param _user address of the user - * @return the last user index - **/ - function getUserIndex(address _user) external view returns(uint256) { - return userIndexes[_user]; - } - - - /** - * @dev returns the address to which the interest is redirected - * @param _user address of the user - * @return 0 if there is no redirection, an address otherwise - **/ - function getInterestRedirectionAddress(address _user) external view returns(address) { - return interestRedirectionAddresses[_user]; - } - - /** - * @dev returns the redirected balance of the user. The redirected balance is the balance - * redirected by other accounts to the user, that is accrueing interest for him. - * @param _user address of the user - * @return the total redirected balance - **/ - function getRedirectedBalance(address _user) external view returns(uint256) { - return redirectedBalances[_user]; - } - - /** - * @dev accumulates the accrued interest of the user to the principal balance - * @param _user the address of the user for which the interest is being accumulated - * @return the previous principal balance, the new principal balance, the balance increase - * and the new user index - **/ - function cumulateBalanceInternal(address _user) - internal - returns(uint256, uint256, uint256, uint256) { - - uint256 previousPrincipalBalance = super.balanceOf(_user); - - //calculate the accrued interest since the last accumulation - uint256 balanceIncrease = balanceOf(_user).sub(previousPrincipalBalance); - //mints an amount of tokens equivalent to the amount accumulated - _mint(_user, balanceIncrease); - //updates the user index - uint256 index = userIndexes[_user] = pool.getReserveNormalizedIncome(underlyingAssetAddress); - return ( - previousPrincipalBalance, - previousPrincipalBalance.add(balanceIncrease), - balanceIncrease, - index - ); - } - - /** - * @dev updates the redirected balance of the user. If the user is not redirecting his - * interest, nothing is executed. - * @param _user the address of the user for which the interest is being accumulated - * @param _balanceToAdd the amount to add to the redirected balance - * @param _balanceToRemove the amount to remove from the redirected balance - **/ - function updateRedirectedBalanceOfRedirectionAddressInternal( - address _user, - uint256 _balanceToAdd, - uint256 _balanceToRemove - ) internal { - - address redirectionAddress = interestRedirectionAddresses[_user]; - //if there isn't any redirection, nothing to be done - if(redirectionAddress == address(0)){ - return; - } - - //compound balances of the redirected address - (,,uint256 balanceIncrease, uint256 index) = cumulateBalanceInternal(redirectionAddress); - - //updating the redirected balance - redirectedBalances[redirectionAddress] = redirectedBalances[redirectionAddress] - .add(_balanceToAdd) - .sub(_balanceToRemove); - - //if the interest of redirectionAddress is also being redirected, we need to update - //the redirected balance of the redirection target by adding the balance increase - address targetOfRedirectionAddress = interestRedirectionAddresses[redirectionAddress]; - - if(targetOfRedirectionAddress != address(0)){ - redirectedBalances[targetOfRedirectionAddress] = redirectedBalances[targetOfRedirectionAddress].add(balanceIncrease); - } - - emit RedirectedBalanceUpdated( - redirectionAddress, - balanceIncrease, - index, - _balanceToAdd, - _balanceToRemove - ); - } - - /** - * @dev calculate the interest accrued by _user on a specific balance - * @param _user the address of the user for which the interest is being accumulated - * @param _balance the balance on which the interest is calculated - * @return the interest rate accrued - **/ - function calculateCumulatedBalanceInternal( - address _user, - uint256 _balance - ) internal view returns (uint256) { - return _balance - .wadToRay() - .rayMul(pool.getReserveNormalizedIncome(underlyingAssetAddress)) - .rayDiv(userIndexes[_user]) - .rayToWad(); - } - - /** - * @dev executes the transfer of aTokens, invoked by both _transfer() and - * transferOnLiquidation() - * @param _from the address from which transfer the aTokens - * @param _to the destination address - * @param _value the amount to transfer - **/ - function executeTransferInternal( - address _from, - address _to, - uint256 _value - ) internal { - - require(_value > 0, "Transferred amount needs to be greater than zero"); - - //cumulate the balance of the sender - (, - uint256 fromBalance, - uint256 fromBalanceIncrease, - uint256 fromIndex - ) = cumulateBalanceInternal(_from); - - //cumulate the balance of the receiver - (, - , - uint256 toBalanceIncrease, - uint256 toIndex - ) = cumulateBalanceInternal(_to); - - //if the sender is redirecting his interest towards someone else, - //adds to the redirected balance the accrued interest and removes the amount - //being transferred - updateRedirectedBalanceOfRedirectionAddressInternal(_from, fromBalanceIncrease, _value); - - //if the receiver is redirecting his interest towards someone else, - //adds to the redirected balance the accrued interest and the amount - //being transferred - updateRedirectedBalanceOfRedirectionAddressInternal(_to, toBalanceIncrease.add(_value), 0); - - //performs the transfer - super._transfer(_from, _to, _value); - - bool fromIndexReset = false; - //reset the user data if the remaining balance is 0 - if(fromBalance.sub(_value) == 0){ - fromIndexReset = resetDataOnZeroBalanceInternal(_from); - } - - emit BalanceTransfer( - _from, - _to, - _value, - fromBalanceIncrease, - toBalanceIncrease, - fromIndexReset ? 0 : fromIndex, - toIndex - ); - } - - /** - * @dev executes the redirection of the interest from one address to another. - * immediately after redirection, the destination address will start to accrue interest. - * @param _from the address from which transfer the aTokens - * @param _to the destination address - **/ - function redirectInterestStreamInternal( - address _from, - address _to - ) internal { - - address currentRedirectionAddress = interestRedirectionAddresses[_from]; - - require(_to != currentRedirectionAddress, "Interest is already redirected to the user"); - - //accumulates the accrued interest to the principal - (uint256 previousPrincipalBalance, - uint256 fromBalance, - uint256 balanceIncrease, - uint256 fromIndex) = cumulateBalanceInternal(_from); - - require(fromBalance > 0, "Interest stream can only be redirected if there is a valid balance"); - - //if the user is already redirecting the interest to someone, before changing - //the redirection address we substract the redirected balance of the previous - //recipient - if(currentRedirectionAddress != address(0)){ - updateRedirectedBalanceOfRedirectionAddressInternal(_from,0, previousPrincipalBalance); - } - - //if the user is redirecting the interest back to himself, - //we simply set to 0 the interest redirection address - if(_to == _from) { - interestRedirectionAddresses[_from] = address(0); - emit InterestStreamRedirected( - _from, - address(0), - fromBalance, - balanceIncrease, - fromIndex - ); - return; - } - - //first set the redirection address to the new recipient - interestRedirectionAddresses[_from] = _to; - - //adds the user balance to the redirected balance of the destination - updateRedirectedBalanceOfRedirectionAddressInternal(_from,fromBalance,0); - - emit InterestStreamRedirected( - _from, - _to, - fromBalance, - balanceIncrease, - fromIndex - ); - } - - /** - * @dev function to reset the interest stream redirection and the user index, if the - * user has no balance left. - * @param _user the address of the user - * @return true if the user index has also been reset, false otherwise. useful to emit the proper user index value - **/ - function resetDataOnZeroBalanceInternal(address _user) internal returns(bool) { - - //if the user has 0 principal balance, the interest stream redirection gets reset - interestRedirectionAddresses[_user] = address(0); - - //emits a InterestStreamRedirected event to notify that the redirection has been reset - emit InterestStreamRedirected(_user, address(0),0,0,0); - - //if the redirected balance is also 0, we clear up the user index - if(redirectedBalances[_user] == 0){ - userIndexes[_user] = 0; - return true; - } - else{ - return false; - } + //first set the redirection address to the new recipient + interestRedirectionAddresses[_from] = _to; + + //adds the user balance to the redirected balance of the destination + updateRedirectedBalanceOfRedirectionAddressInternal(_from, fromBalance, 0); + + emit InterestStreamRedirected(_from, _to, fromBalance, balanceIncrease, fromIndex); + } + + /** + * @dev function to reset the interest stream redirection and the user index, if the + * user has no balance left. + * @param _user the address of the user + * @return true if the user index has also been reset, false otherwise. useful to emit the proper user index value + **/ + function resetDataOnZeroBalanceInternal(address _user) internal returns (bool) { + //if the user has 0 principal balance, the interest stream redirection gets reset + interestRedirectionAddresses[_user] = address(0); + + //emits a InterestStreamRedirected event to notify that the redirection has been reset + emit InterestStreamRedirected(_user, address(0), 0, 0, 0); + + //if the redirected balance is also 0, we clear up the user index + if (redirectedBalances[_user] == 0) { + userIndexes[_user] = 0; + return true; + } else { + return false; } + } + + function transferUnderlyingTo(address _user, uint256 _amount) + external + onlyLendingPool + returns (uint256) + { + ERC20(underlyingAssetAddress).universalTransfer(_user, _amount); + } + + receive() external payable{ + require(ERC20(underlyingAssetAddress).isETH(), "Transfers are only allowed if the underlying asset is ETH"); + } } From 56fa10bd8fbbcb26b3cdbe35c6ac2f7cd1d38428 Mon Sep 17 00:00:00 2001 From: The3D Date: Mon, 13 Jul 2020 15:19:47 +0200 Subject: [PATCH 3/4] Fixes tests on flashloans --- .../flashloan/base/FlashLoanReceiverBase.sol | 7 +----- contracts/lendingpool/LendingPool.sol | 6 ++++- .../mocks/flashloan/MockFlashLoanReceiver.sol | 2 ++ contracts/tokenization/AToken.sol | 23 +++++++++++++++---- 4 files changed, 27 insertions(+), 11 deletions(-) diff --git a/contracts/flashloan/base/FlashLoanReceiverBase.sol b/contracts/flashloan/base/FlashLoanReceiverBase.sol index 0a23e137..229a45d2 100644 --- a/contracts/flashloan/base/FlashLoanReceiverBase.sol +++ b/contracts/flashloan/base/FlashLoanReceiverBase.sol @@ -6,6 +6,7 @@ import '@openzeppelin/contracts/token/ERC20/IERC20.sol'; import '../interfaces/IFlashLoanReceiver.sol'; import '../../interfaces/ILendingPoolAddressesProvider.sol'; import '../../libraries/UniversalERC20.sol'; +import '@nomiclabs/buidler/console.sol'; abstract contract FlashLoanReceiverBase is IFlashLoanReceiver { using UniversalERC20 for IERC20; @@ -32,12 +33,6 @@ abstract contract FlashLoanReceiverBase is IFlashLoanReceiver { address _reserve, uint256 _amount ) internal { - if (IERC20(_reserve).isETH()) { - //solium-disable-next-line - _destination.call{value: _amount}(''); - return; - } - IERC20(_reserve).universalTransfer(_destination, _amount); } diff --git a/contracts/lendingpool/LendingPool.sol b/contracts/lendingpool/LendingPool.sol index ace8920c..3588117a 100644 --- a/contracts/lendingpool/LendingPool.sol +++ b/contracts/lendingpool/LendingPool.sol @@ -710,7 +710,11 @@ contract LendingPool is ReentrancyGuard, VersionedInitializable { vars.protocolFee ); - IERC20(_reserve).universalTransfer(addressesProvider.getTokenDistributor(), vars.protocolFee); + //transfer funds to the receiver + AToken(vars.aTokenAddress).transferUnderlyingTo( + addressesProvider.getTokenDistributor(), + vars.protocolFee + ); //solium-disable-next-line emit FlashLoan(_receiver, _reserve, _amount, vars.amountFee, vars.protocolFee, block.timestamp); diff --git a/contracts/mocks/flashloan/MockFlashLoanReceiver.sol b/contracts/mocks/flashloan/MockFlashLoanReceiver.sol index b165c265..53379d92 100644 --- a/contracts/mocks/flashloan/MockFlashLoanReceiver.sol +++ b/contracts/mocks/flashloan/MockFlashLoanReceiver.sol @@ -50,8 +50,10 @@ contract MockFlashLoanReceiver is FlashLoanReceiverBase { if (!IERC20(_reserve).isETH()) { token.mint(_fee); } + //returning amount + fee to the destination transferFundsBackInternal(_reserve, _destination, _amount.add(_fee)); + emit ExecutedWithSuccess(_reserve, _amount, _fee); } } diff --git a/contracts/tokenization/AToken.sol b/contracts/tokenization/AToken.sol index b123206f..4cf22532 100644 --- a/contracts/tokenization/AToken.sol +++ b/contracts/tokenization/AToken.sol @@ -639,15 +639,30 @@ contract AToken is ERC20 { } } - function transferUnderlyingTo(address _user, uint256 _amount) + /** + * @dev transfers the underlying asset to the target. Used by the lendingpool to transfer + * assets in borrow(), redeem() and flashLoan() + * @param _target the target of the transfer + * @param _amount the amount to transfer + * @return the amount transferred + **/ + + function transferUnderlyingTo(address _target, uint256 _amount) external onlyLendingPool returns (uint256) { - ERC20(underlyingAssetAddress).universalTransfer(_user, _amount); + ERC20(underlyingAssetAddress).universalTransfer(_target, _amount); + return _amount; } - receive() external payable{ - require(ERC20(underlyingAssetAddress).isETH(), "Transfers are only allowed if the underlying asset is ETH"); + /** + * @dev receive() function for aTokens who hold ETH as the underlying asset + **/ + receive() external payable { + require( + ERC20(underlyingAssetAddress).isETH(), + 'Transfers are only allowed if the underlying asset is ETH' + ); } } From 40e3cd4f31ddcc38f1fa85a62861047e73bb6215 Mon Sep 17 00:00:00 2001 From: The3D Date: Mon, 13 Jul 2020 16:43:26 +0200 Subject: [PATCH 4/4] added tests for transferUnderlyingTo --- test/atoken-modifiers.spec.ts | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/test/atoken-modifiers.spec.ts b/test/atoken-modifiers.spec.ts index 7a258d54..c3f54a51 100644 --- a/test/atoken-modifiers.spec.ts +++ b/test/atoken-modifiers.spec.ts @@ -25,4 +25,11 @@ makeSuite('AToken: Modifiers', (testEnv: TestEnv) => { aDai.transferOnLiquidation(deployer.address, users[0].address, '1') ).to.be.revertedWith(INVALID_POOL_CALLER_MSG_1); }); + + it('Tries to invoke transferUnderlyingTo not being the LendingPool', async () => { + const {deployer, users, aDai} = testEnv; + await expect(aDai.transferUnderlyingTo(deployer.address, '1')).to.be.revertedWith( + INVALID_POOL_CALLER_MSG_1 + ); + }); });