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

refactoring tokenization folder to fit current guideline, small gas optimizations

Browse Source
This commit is contained in:
andyk 2020-08-21 13:38:08 +03:00
parent d2848105f7
commit 94d8f38597
14 changed files with 478 additions and 460 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
contracts/lendingpool/LendingPool.sol
View File

@ -9,7 +9,7 @@ import {
VersionedInitializable
} from '../libraries/openzeppelin-upgradeability/VersionedInitializable.sol';
import {LendingPoolAddressesProvider} from '../configuration/LendingPoolAddressesProvider.sol';
import {IAToken} from '../interfaces/IAToken.sol';
import {IAToken} from '../tokenization/interfaces/IAToken.sol';
import {Helpers} from '../libraries/helpers/Helpers.sol';
import {WadRayMath} from '../libraries/math/WadRayMath.sol';
import {ReserveLogic} from '../libraries/logic/ReserveLogic.sol';

2
contracts/lendingpool/LendingPoolLiquidationManager.sol
View File

@ -9,7 +9,7 @@ import {
VersionedInitializable
} from '../libraries/openzeppelin-upgradeability/VersionedInitializable.sol';
import {LendingPoolAddressesProvider} from '../configuration/LendingPoolAddressesProvider.sol';
import {IAToken} from '../interfaces/IAToken.sol';
import {IAToken} from '../tokenization/interfaces/IAToken.sol';
import {IStableDebtToken} from '../tokenization/interfaces/IStableDebtToken.sol';
import {IVariableDebtToken} from '../tokenization/interfaces/IVariableDebtToken.sol';
import {IPriceOracleGetter} from '../interfaces/IPriceOracleGetter.sol';

442
contracts/tokenization/AToken.sol
View File

@ -8,7 +8,7 @@ import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/SafeERC20.sol';
import {
VersionedInitializable
} from '../libraries/openzeppelin-upgradeability/VersionedInitializable.sol';
import {IAToken, IERC20} from '../interfaces/IAToken.sol';
import {IAToken, IERC20} from './interfaces/IAToken.sol';
/**
* @title Aave ERC20 AToken
@ -24,116 +24,111 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
/**
* @dev emitted after aTokens are burned
* @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
* @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 Burn(
address indexed _from,
address indexed _target,
uint256 _value,
uint256 _fromBalanceIncrease,
uint256 _fromIndex
address indexed from,
address indexed target,
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
* @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 Mint(
address indexed _from,
uint256 _value,
uint256 _fromBalanceIncrease,
uint256 _fromIndex
);
event Mint(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
* @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
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
* @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
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
* @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
address indexed targetAddress,
uint256 targetBalanceIncrease,
uint256 targetIndex,
uint256 redirectedBalanceAdded,
uint256 redirectedBalanceRemoved
);
event InterestRedirectionAllowanceChanged(address indexed _from, address indexed _to);
event InterestRedirectionAllowanceChanged(address indexed from, address indexed to);
address public immutable underlyingAssetAddress;
address public immutable UNDERLYING_ASSET_ADDRESS;
mapping(address => uint256) private userIndexes;
mapping(address => address) private interestRedirectionAddresses;
mapping(address => uint256) private redirectedBalances;
mapping(address => address) private interestRedirectionAllowances;
mapping(address => uint256) private _userIndexes;
mapping(address => address) private _interestRedirectionAddresses;
mapping(address => uint256) private _redirectedBalances;
mapping(address => address) private _interestRedirectionAllowances;
LendingPool private immutable pool;
LendingPool private immutable _pool;
uint256 public constant ATOKEN_REVISION = 0x1;
modifier onlyLendingPool {
require(msg.sender == address(pool), 'The caller of this function must be a lending pool');
require(msg.sender == address(_pool), 'The caller of this function must be a lending pool');
_;
}
modifier whenTransferAllowed(address _from, uint256 _amount) {
require(isTransferAllowed(_from, _amount), 'Transfer cannot be allowed.');
modifier whenTransferAllowed(address from, uint256 amount) {
require(isTransferAllowed(from, amount), 'Transfer cannot be allowed.');
_;
}
constructor(
LendingPool _pool,
address _underlyingAssetAddress,
string memory _tokenName,
string memory _tokenSymbol
) public ERC20(_tokenName, _tokenSymbol) {
pool = _pool;
underlyingAssetAddress = _underlyingAssetAddress;
LendingPool pool,
address underlyingAssetAddress,
string memory tokenName,
string memory tokenSymbol
) public ERC20(tokenName, tokenSymbol) {
_pool = pool;
UNDERLYING_ASSET_ADDRESS = underlyingAssetAddress;
}
function getRevision() internal virtual override pure returns (uint256) {
@ -141,13 +136,13 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
}
function initialize(
uint8 _underlyingAssetDecimals,
string calldata _tokenName,
string calldata _tokenSymbol
uint8 underlyingAssetDecimals,
string calldata tokenName,
string calldata tokenSymbol
) external virtual initializer {
_name = _tokenName;
_symbol = _tokenSymbol;
_setupDecimals(_underlyingAssetDecimals);
_name = tokenName;
_symbol = tokenSymbol;
_setupDecimals(underlyingAssetDecimals);
}
/**
@ -155,163 +150,164 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
* @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);
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
* @param to the address to which the interest will be redirected
**/
function redirectInterestStream(address _to) external override {
redirectInterestStreamInternal(msg.sender, _to);
function redirectInterestStream(address to) external override {
redirectInterestStreamInternal(msg.sender, to);
}
/**
* @dev redirects the interest generated by _from to a target address.
* @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
* @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 override {
function redirectInterestStreamOf(address from, address to) external override {
require(
msg.sender == interestRedirectionAllowances[_from],
msg.sender == _interestRedirectionAllowances[from],
'Caller is not allowed to redirect the interest of the user'
);
redirectInterestStreamInternal(_from, _to);
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
* @param to the address to which the interest will be redirected. Pass address(0) to reset
* the allowance.
**/
function allowInterestRedirectionTo(address _to) external override {
require(_to != msg.sender, 'User cannot give allowance to himself');
interestRedirectionAllowances[msg.sender] = _to;
emit InterestRedirectionAllowanceChanged(msg.sender, _to);
function allowInterestRedirectionTo(address to) external override {
require(to != msg.sender, 'User cannot give allowance to himself');
_interestRedirectionAllowances[msg.sender] = to;
emit InterestRedirectionAllowanceChanged(msg.sender, to);
}
/**
* @dev burns the aTokens and sends the equivalent amount of underlying to the target.
* only lending pools can call this function
* @param _amount the amount being burned
* @param amount the amount being burned
**/
function burn(
address _user,
address _underlyingTarget,
uint256 _amount
address user,
address underlyingTarget,
uint256 amount
) external override onlyLendingPool {
//cumulates the balance of the user
(, uint256 currentBalance, uint256 balanceIncrease) = calculateBalanceIncreaseInternal(_user);
(, uint256 currentBalance, uint256 balanceIncrease) = calculateBalanceIncreaseInternal(user);
//if the user is redirecting his interest towards someone else,
//we update the redirected balance of the redirection address by adding the accrued interest,
//and removing the amount to redeem
updateRedirectedBalanceOfRedirectionAddressInternal(_user, balanceIncrease, _amount);
updateRedirectedBalanceOfRedirectionAddressInternal(user, balanceIncrease, amount);
if (balanceIncrease > _amount) {
_mint(_user, balanceIncrease.sub(_amount));
if (balanceIncrease > amount) {
_mint(user, balanceIncrease.sub(amount));
} else {
_burn(_user, _amount.sub(balanceIncrease));
_burn(user, amount.sub(balanceIncrease));
}
uint256 userIndex = 0;
//reset the user data if the remaining balance is 0
if (currentBalance.sub(_amount) == 0) {
resetDataOnZeroBalanceInternal(_user);
if (currentBalance.sub(amount) == 0) {
resetDataOnZeroBalanceInternal(user);
} else {
//updates the user index
userIndex = userIndexes[_user] = pool.getReserveNormalizedIncome(underlyingAssetAddress);
userIndex = _userIndexes[user] = _pool.getReserveNormalizedIncome(UNDERLYING_ASSET_ADDRESS);
}
//transfers the underlying to the target
ERC20(underlyingAssetAddress).safeTransfer(_underlyingTarget, _amount);
ERC20(UNDERLYING_ASSET_ADDRESS).safeTransfer(underlyingTarget, amount);
emit Burn(msg.sender, _underlyingTarget, _amount, balanceIncrease, userIndex);
emit Burn(msg.sender, underlyingTarget, amount, balanceIncrease, userIndex);
}
/**
* @dev mints aTokens to _user
* @dev mints aTokens to user
* only lending pools can call this function
* @param _user the address receiving the minted tokens
* @param _amount the amount of tokens to mint
* @param user the address receiving the minted tokens
* @param amount the amount of tokens to mint
*/
function mint(address _user, uint256 _amount) external override onlyLendingPool {
function mint(address user, uint256 amount) external override onlyLendingPool {
//cumulates the balance of the user
(, , uint256 balanceIncrease) = calculateBalanceIncreaseInternal(_user);
(, , uint256 balanceIncrease) = calculateBalanceIncreaseInternal(user);
//updates the user index
uint256 index = userIndexes[_user] = pool.getReserveNormalizedIncome(underlyingAssetAddress);
uint256 index = _userIndexes[user] = _pool.getReserveNormalizedIncome(UNDERLYING_ASSET_ADDRESS);
//if the user is redirecting his interest towards someone else,
//we update the redirected balance of the redirection address by adding the accrued interest
//and the amount deposited
updateRedirectedBalanceOfRedirectionAddressInternal(_user, balanceIncrease.add(_amount), 0);
updateRedirectedBalanceOfRedirectionAddressInternal(user, balanceIncrease.add(amount), 0);
//mint an equivalent amount of tokens to cover the new deposit
_mint(_user, _amount.add(balanceIncrease));
_mint(user, amount.add(balanceIncrease));
emit Mint(_user, _amount, balanceIncrease, index);
emit Mint(user, amount, balanceIncrease, 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
* @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
address from,
address to,
uint256 value
) external override onlyLendingPool {
//being a normal transfer, the Transfer() and BalanceTransfer() are emitted
//so no need to emit a specific event here
executeTransferInternal(_from, _to, _value);
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
* @param user the user for which the balance is being calculated
* @return the total balance of the user
**/
function balanceOf(address _user) public override(ERC20, IERC20) view returns (uint256) {
function balanceOf(address user) public override(ERC20, IERC20) 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];
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
//if the user is not redirecting the interest to anybody, accrues
//the interest for himself
if (interestRedirectionAddresses[_user] == address(0)) {
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);
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)
calculateCumulatedBalanceInternal(user, redirectedBalance).sub(redirectedBalance)
);
}
}
@ -319,11 +315,11 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
/**
* @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
* @param user the address of the user
* @return the principal balance of the user
**/
function principalBalanceOf(address _user) external override view returns (uint256) {
return super.balanceOf(_user);
function principalBalanceOf(address user) external override view returns (uint256) {
return super.balanceOf(user);
}
/**
@ -342,54 +338,54 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
return
currentSupplyPrincipal
.wadToRay()
.rayMul(pool.getReserveNormalizedIncome(underlyingAssetAddress))
.rayMul(_pool.getReserveNormalizedIncome(UNDERLYING_ASSET_ADDRESS))
.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
* @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 override view returns (bool) {
return pool.balanceDecreaseAllowed(underlyingAssetAddress, _user, _amount);
function isTransferAllowed(address user, uint256 amount) public override view returns (bool) {
return _pool.balanceDecreaseAllowed(UNDERLYING_ASSET_ADDRESS, user, amount);
}
/**
* @dev returns the last index of the user, used to calculate the balance of the user
* @param _user address of the user
* @param user address of the user
* @return the last user index
**/
function getUserIndex(address _user) external override view returns (uint256) {
return userIndexes[_user];
function getUserIndex(address user) external override view returns (uint256) {
return _userIndexes[user];
}
/**
* @dev returns the address to which the interest is redirected
* @param _user address of the user
* @param user address of the user
* @return 0 if there is no redirection, an address otherwise
**/
function getInterestRedirectionAddress(address _user) external override view returns (address) {
return interestRedirectionAddresses[_user];
function getInterestRedirectionAddress(address user) external override 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
* @param user address of the user
* @return the total redirected balance
**/
function getRedirectedBalance(address _user) external override view returns (uint256) {
return redirectedBalances[_user];
function getRedirectedBalance(address user) external override view returns (uint256) {
return _redirectedBalances[user];
}
/**
* @dev calculates the increase in balance since the last user action
* @param _user the address of the user
* @param user the address of the user
* @return the last user principal balance, the current balance and the balance increase
**/
function calculateBalanceIncreaseInternal(address _user)
function calculateBalanceIncreaseInternal(address user)
internal
view
returns (
@ -398,12 +394,12 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
uint256
)
{
uint256 currentBalance = balanceOf(_user);
uint256 currentBalance = balanceOf(user);
uint256 balanceIncrease = 0;
uint256 previousBalance = 0;
if (currentBalance != 0) {
previousBalance = super.balanceOf(_user);
previousBalance = super.balanceOf(user);
//calculate the accrued interest since the last accumulation
balanceIncrease = currentBalance.sub(previousBalance);
}
@ -413,11 +409,11 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
/**
* @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
* @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)
function cumulateBalanceInternal(address user)
internal
returns (
uint256,
@ -430,12 +426,12 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
uint256 previousBalance,
uint256 currentBalance,
uint256 balanceIncrease
) = calculateBalanceIncreaseInternal(_user);
) = calculateBalanceIncreaseInternal(user);
_mint(_user, balanceIncrease);
_mint(user, balanceIncrease);
//updates the user index
uint256 index = userIndexes[_user] = pool.getReserveNormalizedIncome(underlyingAssetAddress);
uint256 index = _userIndexes[user] = _pool.getReserveNormalizedIncome(UNDERLYING_ASSET_ADDRESS);
return (previousBalance, currentBalance, balanceIncrease, index);
}
@ -443,16 +439,16 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
/**
* @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
* @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
address user,
uint256 balanceToAdd,
uint256 balanceToRemove
) internal {
address redirectionAddress = interestRedirectionAddresses[_user];
address redirectionAddress = _interestRedirectionAddresses[user];
//if there isn't any redirection, nothing to be done
if (redirectionAddress == address(0)) {
return;
@ -462,13 +458,13 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
(, , uint256 balanceIncrease, uint256 index) = cumulateBalanceInternal(redirectionAddress);
//updating the redirected balance
redirectedBalances[redirectionAddress] = redirectedBalances[redirectionAddress]
.add(_balanceToAdd)
.sub(_balanceToRemove);
_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];
address targetOfRedirectionAddress = _interestRedirectionAddresses[redirectionAddress];
// if the redirection address is also redirecting the interest, we accumulate his balance
// and update his chain of redirection
@ -480,43 +476,43 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
redirectionAddress,
balanceIncrease,
index,
_balanceToAdd,
_balanceToRemove
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
* @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)
function calculateCumulatedBalanceInternal(address user, uint256 balance)
internal
view
returns (uint256)
{
return
_balance
balance
.wadToRay()
.rayMul(pool.getReserveNormalizedIncome(underlyingAssetAddress))
.rayDiv(userIndexes[_user])
.rayMul(_pool.getReserveNormalizedIncome(UNDERLYING_ASSET_ADDRESS))
.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
* @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
address from,
address to,
uint256 value
) internal {
require(_value > 0, 'Transferred amount needs to be greater than zero');
require(value > 0, 'Transferred amount needs to be greater than zero');
//cumulate the balance of the sender
(
@ -524,34 +520,34 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
uint256 fromBalance,
uint256 fromBalanceIncrease,
uint256 fromIndex
) = cumulateBalanceInternal(_from);
) = cumulateBalanceInternal(from);
//cumulate the balance of the receiver
(, , uint256 toBalanceIncrease, uint256 toIndex) = cumulateBalanceInternal(_to);
(, , 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);
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);
updateRedirectedBalanceOfRedirectionAddressInternal(to, toBalanceIncrease.add(value), 0);
//performs the transfer
super._transfer(_from, _to, _value);
super._transfer(from, to, value);
bool fromIndexReset = false;
//reset the user data if the remaining balance is 0
if (fromBalance.sub(_value) == 0 && _from != _to) {
fromIndexReset = resetDataOnZeroBalanceInternal(_from);
if (fromBalance.sub(value) == 0 && from != to) {
fromIndexReset = resetDataOnZeroBalanceInternal(from);
}
emit BalanceTransfer(
_from,
_to,
_value,
from,
to,
value,
fromBalanceIncrease,
toBalanceIncrease,
fromIndexReset ? 0 : fromIndex,
@ -562,13 +558,13 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
/**
* @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
* @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];
function redirectInterestStreamInternal(address from, address to) internal {
address currentRedirectionAddress = _interestRedirectionAddresses[from];
require(_to != currentRedirectionAddress, 'Interest is already redirected to the user');
require(to != currentRedirectionAddress, 'Interest is already redirected to the user');
//accumulates the accrued interest to the principal
(
@ -576,7 +572,7 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
uint256 fromBalance,
uint256 balanceIncrease,
uint256 fromIndex
) = cumulateBalanceInternal(_from);
) = cumulateBalanceInternal(from);
require(fromBalance > 0, 'Interest stream can only be redirected if there is a valid balance');
@ -584,42 +580,42 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
//the redirection address we substract the redirected balance of the previous
//recipient
if (currentRedirectionAddress != address(0)) {
updateRedirectedBalanceOfRedirectionAddressInternal(_from, 0, previousPrincipalBalance);
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);
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;
_interestRedirectionAddresses[from] = to;
//adds the user balance to the redirected balance of the destination
updateRedirectedBalanceOfRedirectionAddressInternal(_from, fromBalance, 0);
updateRedirectedBalanceOfRedirectionAddressInternal(from, fromBalance, 0);
emit InterestStreamRedirected(_from, _to, fromBalance, balanceIncrease, fromIndex);
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
* @param user the address of the user
* @return true if the user index has also been reset, false otherwise. useful to emit the proper user index value
**/
function resetDataOnZeroBalanceInternal(address _user) internal returns (bool) {
function resetDataOnZeroBalanceInternal(address user) internal returns (bool) {
//if the user has 0 principal balance, the interest stream redirection gets reset
interestRedirectionAddresses[_user] = address(0);
_interestRedirectionAddresses[user] = address(0);
//emits a InterestStreamRedirected event to notify that the redirection has been reset
emit InterestStreamRedirected(_user, address(0), 0, 0, 0);
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;
if (_redirectedBalances[user] == 0) {
_userIndexes[user] = 0;
return true;
} else {
return false;
@ -629,19 +625,19 @@ contract AToken is VersionedInitializable, ERC20, IAToken {
/**
* @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
* @param target the target of the transfer
* @param amount the amount to transfer
* @return the amount transferred
**/
function transferUnderlyingTo(address _target, uint256 _amount)
function transferUnderlyingTo(address target, uint256 amount)
external
override
onlyLendingPool
returns (uint256)
{
ERC20(underlyingAssetAddress).safeTransfer(_target, _amount);
return _amount;
ERC20(UNDERLYING_ASSET_ADDRESS).safeTransfer(target, amount);
return amount;
}
/**

143
contracts/tokenization/StableDebtToken.sol
View File

@ -31,48 +31,48 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
uint256 private avgStableRate;
mapping(address => UserData) usersData;
mapping(address => UserData) private _usersData;
/**
* @dev emitted when new stable debt is minted
* @param _user the address of the user
* @param _amount the amount minted
* @param _previousBalance the previous balance of the user
* @param _currentBalance the current balance of the user
* @param _balanceIncrease the debt increase since the last update
* @param _newRate the rate of the debt after the minting
* @param user the address of the user
* @param amount the amount minted
* @param previousBalance the previous balance of the user
* @param currentBalance the current balance of the user
* @param balanceIncrease the debt increase since the last update
* @param newRate the rate of the debt after the minting
**/
event MintDebt(
address _user,
uint256 _amount,
uint256 _previousBalance,
uint256 _currentBalance,
uint256 _balanceIncrease,
uint256 _newRate
address user,
uint256 amount,
uint256 previousBalance,
uint256 currentBalance,
uint256 balanceIncrease,
uint256 newRate
);
/**
* @dev emitted when new stable debt is burned
* @param _user the address of the user
* @param _amount the amount minted
* @param _previousBalance the previous balance of the user
* @param _currentBalance the current balance of the user
* @param _balanceIncrease the debt increase since the last update
* @param user the address of the user
* @param amount the amount minted
* @param previousBalance the previous balance of the user
* @param currentBalance the current balance of the user
* @param balanceIncrease the debt increase since the last update
**/
event BurnDebt(
address _user,
uint256 _amount,
uint256 _previousBalance,
uint256 _currentBalance,
uint256 _balanceIncrease
address user,
uint256 amount,
uint256 previousBalance,
uint256 currentBalance,
uint256 balanceIncrease
);
constructor(
address _pool,
address _underlyingAsset,
string memory _name,
string memory _symbol
) public DebtTokenBase(_pool, _underlyingAsset, _name, _symbol) {}
address pool,
address underlyingAsset,
string memory name,
string memory symbol
) public DebtTokenBase(pool, underlyingAsset, name, symbol) {}
/**
* @dev gets the revision of the stable debt token implementation
@ -94,17 +94,17 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
* @dev returns the timestamp of the last user action
* @return the last update timestamp
**/
function getUserLastUpdated(address _user) external virtual override view returns (uint40) {
return usersData[_user].lastUpdateTimestamp;
function getUserLastUpdated(address user) external virtual override view returns (uint40) {
return _usersData[user].lastUpdateTimestamp;
}
/**
* @dev returns the stable rate of the user
* @param _user the address of the user
* @return the stable rate of _user
* @param user the address of the user
* @return the stable rate of user
**/
function getUserStableRate(address _user) external virtual override view returns (uint256) {
return usersData[_user].currentRate;
function getUserStableRate(address user) external virtual override view returns (uint256) {
return _usersData[user].currentRate;
}
/**
@ -112,17 +112,18 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
* @return the accumulated debt of the user
**/
function balanceOf(address account) public virtual override view returns (uint256) {
if (balances[account] == 0) {
uint256 accountsBalance = _balances[account];
if (accountsBalance == 0) {
return 0;
}
UserData storage userData = usersData[account];
UserData storage userData = _usersData[account];
uint256 cumulatedInterest = MathUtils.calculateCompoundedInterest(
userData.currentRate,
userData.lastUpdateTimestamp
);
return balances[account].wadToRay().rayMul(cumulatedInterest).rayToWad();
return accountsBalance.wadToRay().rayMul(cumulatedInterest).rayToWad();
}
struct MintLocalVars {
@ -135,14 +136,14 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
/**
* @dev mints debt token to the target user. The resulting rate is the weighted average
* between the rate of the new debt and the rate of the previous debt
* @param _user the address of the user
* @param _amount the amount of debt tokens to mint
* @param _rate the rate of the debt being minted.
* @param user the address of the user
* @param amount the amount of debt tokens to mint
* @param rate the rate of the debt being minted.
**/
function mint(
address _user,
uint256 _amount,
uint256 _rate
address user,
uint256 amount,
uint256 rate
) external override onlyLendingPool {
MintLocalVars memory vars;
@ -151,36 +152,36 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
uint256 previousBalance,
uint256 currentBalance,
uint256 balanceIncrease
) = _calculateBalanceIncrease(_user);
) = _calculateBalanceIncrease(user);
vars.supplyBeforeMint = totalSupply.add(balanceIncrease);
vars.supplyAfterMint = vars.supplyBeforeMint.add(_amount);
vars.supplyBeforeMint = _totalSupply.add(balanceIncrease);
vars.supplyAfterMint = vars.supplyBeforeMint.add(amount);
vars.amountInRay = _amount.wadToRay();
vars.amountInRay = amount.wadToRay();
//calculates the new stable rate for the user
vars.newStableRate = usersData[_user]
vars.newStableRate = _usersData[user]
.currentRate
.rayMul(currentBalance.wadToRay())
.add(vars.amountInRay.rayMul(_rate))
.rayDiv(currentBalance.add(_amount).wadToRay());
.add(vars.amountInRay.rayMul(rate))
.rayDiv(currentBalance.add(amount).wadToRay());
usersData[_user].currentRate = vars.newStableRate;
_usersData[user].currentRate = vars.newStableRate;
//solium-disable-next-line
usersData[_user].lastUpdateTimestamp = uint40(block.timestamp);
_usersData[user].lastUpdateTimestamp = uint40(block.timestamp);
//calculates the updated average stable rate
avgStableRate = avgStableRate
.rayMul(vars.supplyBeforeMint.wadToRay())
.add(_rate.rayMul(vars.amountInRay))
.add(rate.rayMul(vars.amountInRay))
.rayDiv(vars.supplyAfterMint.wadToRay());
_mint(_user, _amount.add(balanceIncrease));
_mint(user, amount.add(balanceIncrease));
emit MintDebt(
_user,
_amount,
user,
amount,
previousBalance,
currentBalance,
balanceIncrease,
@ -190,42 +191,42 @@ contract StableDebtToken is IStableDebtToken, DebtTokenBase {
/**
* @dev burns debt of the target user.
* @param _user the address of the user
* @param _amount the amount of debt tokens to mint
* @param user the address of the user
* @param amount the amount of debt tokens to mint
**/
function burn(address _user, uint256 _amount) external override onlyLendingPool {
function burn(address user, uint256 amount) external override onlyLendingPool {
(
uint256 previousBalance,
uint256 currentBalance,
uint256 balanceIncrease
) = _calculateBalanceIncrease(_user);
) = _calculateBalanceIncrease(user);
uint256 supplyBeforeBurn = totalSupply.add(balanceIncrease);
uint256 supplyAfterBurn = supplyBeforeBurn.sub(_amount);
uint256 supplyBeforeBurn = _totalSupply.add(balanceIncrease);
uint256 supplyAfterBurn = supplyBeforeBurn.sub(amount);
if (supplyAfterBurn == 0) {
avgStableRate = 0;
} else {
avgStableRate = avgStableRate
.rayMul(supplyBeforeBurn.wadToRay())
.sub(usersData[_user].currentRate.rayMul(_amount.wadToRay()))
.sub(_usersData[user].currentRate.rayMul(amount.wadToRay()))
.rayDiv(supplyAfterBurn.wadToRay());
}
if (_amount == currentBalance) {
usersData[_user].currentRate = 0;
usersData[_user].lastUpdateTimestamp = 0;
if (amount == currentBalance) {
_usersData[user].currentRate = 0;
_usersData[user].lastUpdateTimestamp = 0;
} else {
//solium-disable-next-line
usersData[_user].lastUpdateTimestamp = uint40(block.timestamp);
_usersData[user].lastUpdateTimestamp = uint40(block.timestamp);
}
if (balanceIncrease > _amount) {
_mint(_user, balanceIncrease.sub(_amount));
if (balanceIncrease > amount) {
_mint(user, balanceIncrease.sub(amount));
} else {
_burn(_user, _amount.sub(balanceIncrease));
_burn(user, amount.sub(balanceIncrease));
}
emit BurnDebt(_user, _amount, previousBalance, currentBalance, balanceIncrease);
emit BurnDebt(user, amount, previousBalance, currentBalance, balanceIncrease);
}
}

113
contracts/tokenization/VariableDebtToken.sol
View File

@ -20,50 +20,50 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
uint256 public constant DEBT_TOKEN_REVISION = 0x1;
mapping(address => uint256) private userIndexes;
mapping(address => uint256) private _userIndexes;
/**
* @dev emitted when new variable debt is minted
* @param _user the user receiving the debt
* @param _amount the amount of debt being minted
* @param _previousBalance the previous balance of the user
* @param _currentBalance the current balance of the user
* @param _balanceIncrease the debt accumulated since the last action
* @param _index the index of the user
* @param user the user receiving the debt
* @param amount the amount of debt being minted
* @param previousBalance the previous balance of the user
* @param currentBalance the current balance of the user
* @param balanceIncrease the debt accumulated since the last action
* @param index the index of the user
**/
event MintDebt(
address _user,
uint256 _amount,
uint256 _previousBalance,
uint256 _currentBalance,
uint256 _balanceIncrease,
uint256 _index
address user,
uint256 amount,
uint256 previousBalance,
uint256 currentBalance,
uint256 balanceIncrease,
uint256 index
);
/**
* @dev emitted when variable debt is burnt
* @param _user the user which debt has been burned
* @param _amount the amount of debt being burned
* @param _previousBalance the previous balance of the user
* @param _currentBalance the current balance of the user
* @param _balanceIncrease the debt accumulated since the last action
* @param _index the index of the user
* @param user the user which debt has been burned
* @param amount the amount of debt being burned
* @param previousBalance the previous balance of the user
* @param currentBalance the current balance of the user
* @param balanceIncrease the debt accumulated since the last action
* @param index the index of the user
**/
event BurnDebt(
address _user,
uint256 _amount,
uint256 _previousBalance,
uint256 _currentBalance,
uint256 _balanceIncrease,
uint256 _index
address user,
uint256 amount,
uint256 previousBalance,
uint256 currentBalance,
uint256 balanceIncrease,
uint256 index
);
constructor(
address _pool,
address _underlyingAsset,
string memory _name,
string memory _symbol
) public DebtTokenBase(_pool, _underlyingAsset, _name, _symbol) {}
address pool,
address underlyingAsset,
string memory name,
string memory symbol
) public DebtTokenBase(pool, underlyingAsset, name, symbol) {}
/**
* @dev gets the revision of the stable debt token implementation
@ -77,16 +77,17 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
* @dev calculates the accumulated debt balance of the user
* @return the debt balance of the user
**/
function balanceOf(address _user) public virtual override view returns (uint256) {
if (balances[_user] == 0) {
function balanceOf(address user) public virtual override view returns (uint256) {
uint256 userBalance = _balances[user];
if (userBalance == 0) {
return 0;
}
return
balances[_user]
userBalance
.wadToRay()
.rayMul(pool.getReserveNormalizedVariableDebt(underlyingAssetAddress))
.rayDiv(userIndexes[_user])
.rayMul(_pool.getReserveNormalizedVariableDebt(_underlyingAssetAddress))
.rayDiv(_userIndexes[user])
.rayToWad();
}
@ -95,55 +96,55 @@ contract VariableDebtToken is DebtTokenBase, IVariableDebtToken {
* @return the user index
**/
function getUserIndex(address _user) external virtual override view returns (uint256) {
return userIndexes[_user];
function getUserIndex(address user) external virtual override view returns (uint256) {
return _userIndexes[user];
}
/**
* @dev mints new variable debt
* @param _user the user receiving the debt
* @param _amount the amount of debt being minted
* @param user the user receiving the debt
* @param amount the amount of debt being minted
**/
function mint(address _user, uint256 _amount) external override onlyLendingPool {
function mint(address user, uint256 amount) external override onlyLendingPool {
(
uint256 previousBalance,
uint256 currentBalance,
uint256 balanceIncrease
) = _calculateBalanceIncrease(_user);
) = _calculateBalanceIncrease(user);
_mint(_user, _amount.add(balanceIncrease));
_mint(user, amount.add(balanceIncrease));
uint256 newUserIndex = pool.getReserveNormalizedVariableDebt(underlyingAssetAddress);
userIndexes[_user] = newUserIndex;
uint256 newUserIndex = _pool.getReserveNormalizedVariableDebt(_underlyingAssetAddress);
_userIndexes[user] = newUserIndex;
emit MintDebt(_user, _amount, previousBalance, currentBalance, balanceIncrease, newUserIndex);
emit MintDebt(user, amount, previousBalance, currentBalance, balanceIncrease, newUserIndex);
}
/**
* @dev burns user variable debt
* @param _user the user which debt is burnt
* @param _amount the amount of debt being burned
* @param user the user which debt is burnt
* @param amount the amount of debt being burned
**/
function burn(address _user, uint256 _amount) external override onlyLendingPool {
function burn(address user, uint256 amount) external override onlyLendingPool {
(
uint256 previousBalance,
uint256 currentBalance,
uint256 balanceIncrease
) = _calculateBalanceIncrease(_user);
) = _calculateBalanceIncrease(user);
if (balanceIncrease > _amount) {
_mint(_user, balanceIncrease.sub(_amount));
if (balanceIncrease > amount) {
_mint(user, balanceIncrease.sub(amount));
} else {
_burn(_user, _amount.sub(balanceIncrease));
_burn(user, amount.sub(balanceIncrease));
}
uint256 newUserIndex = 0;
//if user not repaid everything
if (currentBalance != _amount) {
newUserIndex = pool.getReserveNormalizedVariableDebt(underlyingAssetAddress);
if (currentBalance != amount) {
newUserIndex = _pool.getReserveNormalizedVariableDebt(_underlyingAssetAddress);
}
userIndexes[_user] = newUserIndex;
_userIndexes[user] = newUserIndex;
emit BurnDebt(_user, _amount, previousBalance, currentBalance, balanceIncrease, newUserIndex);
emit BurnDebt(user, amount, previousBalance, currentBalance, balanceIncrease, newUserIndex);
}
}

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

@ -2,13 +2,13 @@
pragma solidity ^0.6.8;
import {Context} from '@openzeppelin/contracts/GSN/Context.sol';
import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import {SafeMath} from '@openzeppelin/contracts/math/SafeMath.sol';
import {ILendingPoolAddressesProvider} from '../../interfaces/ILendingPoolAddressesProvider.sol';
import {ILendingPool} from '../../interfaces/ILendingPool.sol';
import {
VersionedInitializable
} from '../../libraries/openzeppelin-upgradeability/VersionedInitializable.sol';
import {IERC20Detailed} from '../../interfaces/IERC20Detailed.sol';
/**
* @title contract DebtTokenBase
@ -16,67 +16,87 @@ import {
* @notice base contract for StableDebtToken and VariableDebtToken
*/
abstract contract DebtTokenBase is IERC20, VersionedInitializable {
abstract contract DebtTokenBase is IERC20Detailed, VersionedInitializable {
using SafeMath for uint256;
uint256 public override totalSupply;
uint256 internal _totalSupply;
string public name;
string public symbol;
uint8 public decimals;
address public immutable underlyingAssetAddress;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
address internal immutable _underlyingAssetAddress;
ILendingPool internal immutable pool;
mapping(address => uint256) internal balances;
ILendingPool internal immutable _pool;
mapping(address => uint256) internal _balances;
/**
* @dev only lending pool can call functions marked by this modifier
**/
modifier onlyLendingPool {
require(msg.sender == address(pool), 'The caller of this function must be a lending pool');
require(msg.sender == address(_pool), 'The caller of this function must be a lending pool');
_;
}
constructor(
address _pool,
address _underlyingAssetAddress,
string memory _name,
string memory _symbol
address pool,
address underlyingAssetAddress,
string memory name,
string memory symbol
) public {
pool = ILendingPool(_pool);
underlyingAssetAddress = _underlyingAssetAddress;
name = _name;
symbol = _symbol;
_pool = ILendingPool(pool);
_underlyingAssetAddress = underlyingAssetAddress;
_name = name;
_symbol = symbol;
}
/**
* @dev initializes the debt token.
* @param _name the name of the token
* @param _symbol the symbol of the token
* @param _decimals the decimals of the token
* @param name the name of the token
* @param symbol the symbol of the token
* @param decimals the decimals of the token
*/
function initialize(
uint8 _decimals,
string memory _name,
string memory _symbol
uint8 decimals,
string memory name,
string memory symbol
) public initializer {
name = _name;
symbol = _symbol;
decimals = _decimals;
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public override view returns (string memory) {
return _name;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function underlyingAssetAddress() public view returns (address) {
return _underlyingAssetAddress;
}
/**
* @dev calculates the accumulated debt balance of the user
* @return the debt balance of the user
**/
function balanceOf(address _user) public virtual override view returns (uint256);
function balanceOf(address user) public virtual override view returns (uint256);
/**
* @dev returns the principal debt balance of the user from
* @return the debt balance of the user since the last burn/mint action
**/
function principalBalanceOf(address _user) public view returns (uint256) {
return balances[_user];
function principalBalanceOf(address user) public view returns (uint256) {
return _balances[user];
}
/**
@ -84,9 +104,9 @@ abstract contract DebtTokenBase is IERC20, VersionedInitializable {
* @dev _user the target user of the minting action
* @dev _amount the amount to mint
**/
function _mint(address _user, uint256 _amount) internal {
totalSupply = totalSupply.add(_amount);
balances[_user] = balances[_user].add(_amount);
function _mint(address user, uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
_balances[user] = _balances[user].add(amount);
}
/**
@ -94,16 +114,16 @@ abstract contract DebtTokenBase is IERC20, VersionedInitializable {
* @dev _user the target user of the burning action
* @dev _amount the amount to burn
**/
function _burn(address _user, uint256 _amount) internal {
totalSupply = totalSupply.sub(_amount);
balances[_user] = balances[_user].sub(_amount);
function _burn(address user, uint256 amount) internal {
_totalSupply = _totalSupply.sub(amount);
_balances[user] = _balances[user].sub(amount);
}
/**
* @dev being non transferrable, the debt token does not implement any of the
* standard ERC20 functions for transfer and allowance.
**/
function transfer(address recipient, uint256 _amount) external virtual override returns (bool) {
function transfer(address recipient, uint256 amount) external virtual override returns (bool) {
revert('TRANSFER_NOT_SUPPORTED');
}
@ -117,14 +137,14 @@ abstract contract DebtTokenBase is IERC20, VersionedInitializable {
revert('ALLOWANCE_NOT_SUPPORTED');
}
function approve(address spender, uint256 _amount) external virtual override returns (bool) {
function approve(address spender, uint256 amount) external virtual override returns (bool) {
revert('APPROVAL_NOT_SUPPORTED');
}
function transferFrom(
address sender,
address recipient,
uint256 _amount
uint256 amount
) external virtual override returns (bool) {
revert('TRANSFER_NOT_SUPPORTED');
}
@ -143,11 +163,11 @@ abstract contract DebtTokenBase is IERC20, VersionedInitializable {
/**
* @dev calculates the increase in balance since the last user interaction
* @param _user the address of the user for which the interest is being accumulated
* @param user the address of the user for which the interest is being accumulated
* @return the previous principal balance, the new principal balance, the balance increase
* and the new user index
**/
function _calculateBalanceIncrease(address _user)
function _calculateBalanceIncrease(address user)
internal
view
returns (
@ -156,14 +176,14 @@ abstract contract DebtTokenBase is IERC20, VersionedInitializable {
uint256
)
{
uint256 previousPrincipalBalance = balances[_user];
uint256 previousPrincipalBalance = _balances[user];
if (previousPrincipalBalance == 0) {
return (0, 0, 0);
}
//calculate the accrued interest since the last accumulation
uint256 balanceIncrease = balanceOf(_user).sub(previousPrincipalBalance);
uint256 balanceIncrease = balanceOf(user).sub(previousPrincipalBalance);
return (
previousPrincipalBalance,

0
contracts/interfaces/IAToken.sol → contracts/tokenization/interfaces/IAToken.sol
View File

22
contracts/tokenization/interfaces/IStableDebtToken.sol
View File

@ -16,22 +16,22 @@ interface IStableDebtToken {
/**
* @dev mints debt token to the target user. The resulting rate is the weighted average
* between the rate of the new debt and the rate of the previous debt
* @param _user the address of the user
* @param _amount the amount of debt tokens to mint
* @param _rate the rate of the debt being minted.
* @param user the address of the user
* @param amount the amount of debt tokens to mint
* @param rate the rate of the debt being minted.
**/
function mint(
address _user,
uint256 _amount,
uint256 _rate
address user,
uint256 amount,
uint256 rate
) external;
/**
* @dev burns debt of the target user.
* @param _user the address of the user
* @param _amount the amount of debt tokens to mint
* @param user the address of the user
* @param amount the amount of debt tokens to mint
**/
function burn(address _user, uint256 _amount) external;
function burn(address user, uint256 amount) external;
/**
* @dev returns the average rate of all the stable rate loans.
@ -43,11 +43,11 @@ interface IStableDebtToken {
* @dev returns the stable rate of the user debt
* @return the stable rate of the user
**/
function getUserStableRate(address _user) external view returns (uint256);
function getUserStableRate(address user) external view returns (uint256);
/**
* @dev returns the timestamp of the last update of the user
* @return the timestamp
**/
function getUserLastUpdated(address _user) external view returns (uint40);
function getUserLastUpdated(address user) external view returns (uint40);
}

14
contracts/tokenization/interfaces/IVariableDebtToken.sol
View File

@ -10,21 +10,21 @@ pragma solidity ^0.6.8;
interface IVariableDebtToken {
/**
* @dev mints new variable debt
* @param _user the user receiving the debt
* @param _amount the amount of debt being minted
* @param user the user receiving the debt
* @param amount the amount of debt being minted
**/
function mint(address _user, uint256 _amount) external;
function mint(address user, uint256 amount) external;
/**
* @dev burns user variable debt
* @param _user the user which debt is burnt
* @param _amount the amount of debt being burned
* @param user the user which debt is burnt
* @param amount the amount of debt being burned
**/
function burn(address _user, uint256 _amount) external;
function burn(address user, uint256 amount) external;
/**
* @dev returns the last index of the user
* @return the index of the user
**/
function getUserIndex(address _user) external view returns (uint256);
function getUserIndex(address user) external view returns (uint256);
}

28
test/helpers/actions.ts
View File

@ -1,39 +1,38 @@
import BigNumber from 'bignumber.js';
import {
calcExpectedReserveDataAfterDeposit,
calcExpectedReserveDataAfterWithdraw,
calcExpectedUserDataAfterDeposit,
calcExpectedUserDataAfterWithdraw,
calcExpectedReserveDataAfterBorrow,
calcExpectedUserDataAfterBorrow,
calcExpectedReserveDataAfterDeposit,
calcExpectedReserveDataAfterRepay,
calcExpectedReserveDataAfterStableRateRebalance,
calcExpectedReserveDataAfterSwapRateMode,
calcExpectedReserveDataAfterWithdraw,
calcExpectedUserDataAfterBorrow,
calcExpectedUserDataAfterDeposit,
calcExpectedUserDataAfterRepay,
calcExpectedUserDataAfterSetUseAsCollateral,
calcExpectedUserDataAfterSwapRateMode,
calcExpectedReserveDataAfterSwapRateMode,
calcExpectedReserveDataAfterStableRateRebalance,
calcExpectedUserDataAfterStableRateRebalance,
calcExpectedUserDataAfterSwapRateMode,
calcExpectedUserDataAfterWithdraw,
calcExpectedUsersDataAfterRedirectInterest,
} from './utils/calculations';
import {getReserveAddressFromSymbol, getReserveData, getUserData} from './utils/helpers';
import {
getMintableErc20,
convertToCurrencyDecimals,
getAToken,
getMintableErc20,
} from '../../helpers/contracts-helpers';
import {ONE_YEAR, MAX_UINT_AMOUNT} from '../../helpers/constants';
import {TestEnv, SignerWithAddress} from './make-suite';
import {MAX_UINT_AMOUNT, ONE_YEAR} from '../../helpers/constants';
import {SignerWithAddress, TestEnv} from './make-suite';
import {BRE, increaseTime, timeLatest} from '../../helpers/misc-utils';
import chai from 'chai';
import {ReserveData, UserReserveData} from './utils/interfaces';
import {waitForTx} from '../__setup.spec';
import {ContractReceipt} from 'ethers';
import {ethers} from 'ethers';
import {AToken} from '../../types/AToken';
import {tEthereumAddress, RateMode} from '../../helpers/types';
import {RateMode, tEthereumAddress} from '../../helpers/types';
const {expect} = chai;
@ -155,8 +154,7 @@ export const deposit = async (
);
if (sendValue) {
const valueToSend = await convertToCurrencyDecimals(reserve, sendValue);
txOptions.value = valueToSend;
txOptions.value = await convertToCurrencyDecimals(reserve, sendValue);
}
if (expectedResult === 'success') {
const txResult = await waitForTx(

31
test/helpers/almost-equal.ts Normal file
View File

@ -0,0 +1,31 @@
import BigNumber from 'bignumber.js';
function almostEqualAssertion(this: any, expected: any, actual: any, message: string): any {
this.assert(
expected.plus(new BigNumber(1)).eq(actual) ||
expected.plus(new BigNumber(2)).eq(actual) ||
actual.plus(new BigNumber(1)).eq(expected) ||
actual.plus(new BigNumber(2)).eq(expected) ||
expected.eq(actual),
`${message} expected #{act} to be almost equal #{exp}`,
`${message} expected #{act} to be different from #{exp}`,
expected.toString(),
actual.toString()
);
}
export function almostEqual() {
return function (chai: any, utils: any) {
chai.Assertion.overwriteMethod('almostEqual', function (original: any) {
return function (this: any, value: any, message: string) {
if (utils.flag(this, 'bignumber')) {
var expected = new BigNumber(value);
var actual = new BigNumber(this._obj);
almostEqualAssertion.apply(this, [expected, actual, message]);
} else {
original.apply(this, arguments);
}
};
});
};
}

5
test/helpers/make-suite.ts
View File

@ -20,9 +20,11 @@ import {LendingPoolConfigurator} from '../../types/LendingPoolConfigurator';
import chai from 'chai';
// @ts-ignore
import bignumberChai from 'chai-bignumber';
import {almostEqual} from './almost-equal';
import {PriceOracle} from '../../types/PriceOracle';
import {LendingPoolAddressesProvider} from '../../types/LendingPoolAddressesProvider';
chai.use(bignumberChai());
chai.use(almostEqual());
export interface SignerWithAddress {
signer: Signer;
@ -95,7 +97,6 @@ export async function initializeMakeSuite() {
const aDaiAddress = (await testEnv.helpersContract.getAllATokens()).find(
(aToken) => aToken.symbol === 'aDAI'
)?.tokenAddress;
const aEthAddress = (await testEnv.helpersContract.getAllATokens()).find(
(aToken) => aToken.symbol === 'aETH'
@ -112,7 +113,7 @@ export async function initializeMakeSuite() {
console.log(`atoken-modifiers.spec: aTokens not correctly initialized`);
process.exit(1);
}
if (!daiAddress || !usdcAddress || !lendAddress || ! wethAddress) {
if (!daiAddress || !usdcAddress || !lendAddress || !wethAddress) {
console.log(`atoken-modifiers.spec: USDC or DAI not correctly initialized`);
process.exit(1);
}

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

@ -9,7 +9,6 @@ import {calcExpectedVariableDebtTokenBalance} from './helpers/utils/calculations
import {getUserData, getReserveData} from './helpers/utils/helpers';
const chai = require('chai');
chai.use(require('chai-bignumber')());
const {expect} = chai;
makeSuite('LendingPool liquidation - liquidator receiving aToken', (testEnv) => {

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

@ -9,38 +9,9 @@ import {calcExpectedStableDebtTokenBalance} from './helpers/utils/calculations';
import {getUserData} from './helpers/utils/helpers';
const chai = require('chai');
chai.use(require('chai-bignumber')());
const {expect} = chai;
const almostEqual: any = function (this: any, expected: any, actual: any, message: string): any {
this.assert(
expected.plus(new BigNumber(1)).eq(actual) ||
expected.plus(new BigNumber(2)).eq(actual) ||
actual.plus(new BigNumber(1)).eq(expected) ||
actual.plus(new BigNumber(2)).eq(expected) ||
expected.eq(actual),
`${message} expected #{act} to be almost equal #{exp}`,
`${message} expected #{act} to be different from #{exp}`,
expected.toString(),
actual.toString()
);
};
chai.use(function (chai: any, utils: any) {
chai.Assertion.overwriteMethod('almostEqual', function (original: any) {
return function (this: any, value: any, message: string) {
if (utils.flag(this, 'bignumber')) {
var expected = new BigNumber(value);
var actual = new BigNumber(this._obj);
almostEqual.apply(this, [expected, actual, message]);
} else {
original.apply(this, arguments);
}
};
});
});
makeSuite('LendingPool liquidation - liquidator receiving the underlying asset', (testEnv) => {
const {
HF_IS_NOT_BELLOW_THRESHOLD,