总的来说,Aave通过贴现的方式,将不同时间点的存款数量转化成初始时间点的存款数量,因此每份数量的底层资产对应的本息和,就可以直接用amount * index算出来,大大方便了计算和理解。
Aave是一个借贷平台,AToken属于存款凭证,当用户存入资产时,Aave会给用户mint一定数量的AToken,下面是AToken的代码概览
contract AToken is VersionedInitializable, ScaledBalanceTokenBase, EIP712Base, IAToken
AToken继承了VersionedInitializable、ScaledBalanceTokenBase、EIP712Base和IAToken,下面我们分别来看下他们的实现
// SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.10;
/**
* @title VersionedInitializable
* @author Aave, inspired by the OpenZeppelin Initializable contract
* @notice Helper contract to implement initializer functions. To use it, replace
* the constructor with a function that has the `initializer` modifier.
* @dev WARNING: Unlike constructors, initializer functions must be manually
* invoked. This applies both to deploying an Initializable contract, as well
* as extending an Initializable contract via inheritance.
* WARNING: When used with inheritance, manual care must be taken to not invoke
* a parent initializer twice, or ensure that all initializers are idempotent,
* because this is not dealt with automatically as with constructors.
*/
abstract contract VersionedInitializable {
/**
* @dev Indicates that the contract has been initialized.
*/
uint256 private lastInitializedRevision = 0;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private initializing;
/**
* @dev Modifier to use in the initializer function of a contract.
*/
modifier initializer() {
uint256 revision = getRevision();
require(
initializing || isConstructor() || revision > lastInitializedRevision,
'Contract instance has already been initialized'
);
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
lastInitializedRevision = revision;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
/**
* @notice Returns the revision number of the contract
* @dev Needs to be defined in the inherited class as a constant.
* @return The revision number
*/
function getRevision() internal pure virtual returns (uint256);
/**
* @notice Returns true if and only if the function is running in the constructor
* @return True if the function is running in the constructor
*/
function isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
uint256 cs;
//solium-disable-next-line
assembly {
cs := extcodesize(address())
}
return cs == 0;
}
// Reserved storage space to allow for layout changes in the future.
uint256[50] private ______gap;
}
这个合约是用来辅助初始化的,修改自OpenZeppelin里的Initializable合约,引入了revision版本号,当版本号变大时,可以再次初始化。
abstract contract ScaledBalanceTokenBase is MintableIncentivizedERC20, IScaledBalanceToken
我们可以看到ScaledBalanceTokenBase继承了MintableIncentivizedERC20:
abstract contract MintableIncentivizedERC20 is IncentivizedERC20
MintableIncentivizedERC20又继承了IncentivizedERC20,因此我们先来看下IncentivizedERC20的实现
abstract contract IncentivizedERC20 is Context, IERC20Detailed {
using WadRayMath for uint256;
using SafeCast for uint256;
/**
* @dev Only pool admin can call functions marked by this modifier.
*/
modifier onlyPoolAdmin() {
IACLManager aclManager = IACLManager(_addressesProvider.getACLManager());
require(aclManager.isPoolAdmin(msg.sender), Errors.CALLER_NOT_POOL_ADMIN);
_;
}
/**
* @dev Only pool can call functions marked by this modifier.
*/
modifier onlyPool() {
require(_msgSender() == address(POOL), Errors.CALLER_MUST_BE_POOL);
_;
}
/**
* @dev UserState - additionalData is a flexible field.
* ATokens and VariableDebtTokens use this field store the index of the
* user's last supply/withdrawal/borrow/repayment. StableDebtTokens use
* this field to store the user's stable rate.
*/
struct UserState {
uint128 balance;
uint128 additionalData;
}
// Map of users address and their state data (userAddress => userStateData)
mapping(address => UserState) internal _userState;
// Map of allowances (delegator => delegatee => allowanceAmount)
mapping(address => mapping(address => uint256)) private _allowances;
uint256 internal _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
IAaveIncentivesController internal _incentivesController;
IPoolAddressesProvider internal immutable _addressesProvider;
IPool public immutable POOL;
/**
* @dev Constructor.
* @param pool The reference to the main Pool contract
* @param name The name of the token
* @param symbol The symbol of the token
* @param decimals The number of decimals of the token
*/
constructor(
IPool pool,
string memory name,
string memory symbol,
uint8 decimals
) {
_addressesProvider = pool.ADDRESSES_PROVIDER();
_name = name;
_symbol = symbol;
_decimals = decimals;
POOL = pool;
}
/// @inheritdoc IERC20Detailed
function name() public view override returns (string memory) {
return _name;
}
/// @inheritdoc IERC20Detailed
function symbol() external view override returns (string memory) {
return _symbol;
}
/// @inheritdoc IERC20Detailed
function decimals() external view override returns (uint8) {
return _decimals;
}
/// @inheritdoc IERC20
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/// @inheritdoc IERC20
function balanceOf(address account) public view virtual override returns (uint256) {
return _userState[account].balance;
}
/**
* @notice Returns the address of the Incentives Controller contract
* @return The address of the Incentives Controller
*/
function getIncentivesController() external view virtual returns (IAaveIncentivesController) {
return _incentivesController;
}
/**
* @notice Sets a new Incentives Controller
* @param controller the new Incentives controller
*/
function setIncentivesController(IAaveIncentivesController controller) external onlyPoolAdmin {
_incentivesController = controller;
}
/// @inheritdoc IERC20
function transfer(address recipient, uint256 amount) external virtual override returns (bool) {
uint128 castAmount = amount.toUint128();
_transfer(_msgSender(), recipient, castAmount);
return true;
}
/// @inheritdoc IERC20
function allowance(address owner, address spender)
external
view
virtual
override
returns (uint256)
{
return _allowances[owner][spender];
}
/// @inheritdoc IERC20
function approve(address spender, uint256 amount) external virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/// @inheritdoc IERC20
function transferFrom(
address sender,
address recipient,
uint256 amount
) external virtual override returns (bool) {
uint128 castAmount = amount.toUint128();
_approve(sender, _msgSender(), _allowances[sender][_msgSender()] - castAmount);
_transfer(sender, recipient, castAmount);
return true;
}
/**
* @notice Increases the allowance of spender to spend _msgSender() tokens
* @param spender The user allowed to spend on behalf of _msgSender()
* @param addedValue The amount being added to the allowance
* @return `true`
*/
function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
/**
* @notice Decreases the allowance of spender to spend _msgSender() tokens
* @param spender The user allowed to spend on behalf of _msgSender()
* @param subtractedValue The amount being subtracted to the allowance
* @return `true`
*/
function decreaseAllowance(address spender, uint256 subtractedValue)
external
virtual
returns (bool)
{
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
/**
* @notice Transfers tokens between two users and apply incentives if defined.
* @param sender The source address
* @param recipient The destination address
* @param amount The amount getting transferred
*/
function _transfer(
address sender,
address recipient,
uint128 amount
) internal virtual {
uint128 oldSenderBalance = _userState[sender].balance;
_userState[sender].balance = oldSenderBalance - amount;
uint128 oldRecipientBalance = _userState[recipient].balance;
_userState[recipient].balance = oldRecipientBalance + amount;
IAaveIncentivesController incentivesControllerLocal = _incentivesController;
if (address(incentivesControllerLocal) != address(0)) {
uint256 currentTotalSupply = _totalSupply;
incentivesControllerLocal.handleAction(sender, currentTotalSupply, oldSenderBalance);
if (sender != recipient) {
incentivesControllerLocal.handleAction(recipient, currentTotalSupply, oldRecipientBalance);
}
}
}
/**
* @notice Approve `spender` to use `amount` of `owner`s balance
* @param owner The address owning the tokens
* @param spender The address approved for spending
* @param amount The amount of tokens to approve spending of
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @notice Update the name of the token
* @param newName The new name for the token
*/
function _setName(string memory newName) internal {
_name = newName;
}
/**
* @notice Update the symbol for the token
* @param newSymbol The new symbol for the token
*/
function _setSymbol(string memory newSymbol) internal {
_symbol = newSymbol;
}
/**
* @notice Update the number of decimals for the token
* @param newDecimals The new number of decimals for the token
*/
function _setDecimals(uint8 newDecimals) internal {
_decimals = newDecimals;
}
}
IncentivizedERC20和标准ERC20很类似,不同之处在于两个,一个是balance使用UserState进行包装:
/**
* @dev UserState - additionalData is a flexible field.
* ATokens and VariableDebtTokens use this field store the index of the
* user's last supply/withdrawal/borrow/repayment. StableDebtTokens use
* this field to store the user's stable rate.
*/
struct UserState {
uint128 balance;
uint128 additionalData;
}
// Map of users address and their state data (userAddress => userStateData)
mapping(address => UserState) internal _userState;
UserState里保存的balance就是实际的balance,而additionalData其实是当前的利率的累加指数,如果是AToken,这个就是存款利率的累加指数,如果是DebtToken,就是贷款利率的累加指数。 第二个不同是_transfer会调用IAaveIncentivesController相关方法:
function _transfer(
address sender,
address recipient,
uint128 amount
) internal virtual {
uint128 oldSenderBalance = _userState[sender].balance;
_userState[sender].balance = oldSenderBalance - amount;
uint128 oldRecipientBalance = _userState[recipient].balance;
_userState[recipient].balance = oldRecipientBalance + amount;
IAaveIncentivesController incentivesControllerLocal = _incentivesController;
if (address(incentivesControllerLocal) != address(0)) {
uint256 currentTotalSupply = _totalSupply;
incentivesControllerLocal.handleAction(sender, currentTotalSupply, oldSenderBalance);
if (sender != recipient) {
incentivesControllerLocal.handleAction(recipient, currentTotalSupply, oldRecipientBalance);
}
}
}
这里的IAaveIncentivesController其实是Aave里的RewardController(https://docs.aave.com/developers/periphery-contracts/rewardscontroller) 这里回调了handleAction方法,实际是更新用户的持仓数量。
abstract contract MintableIncentivizedERC20 is IncentivizedERC20 {
/**
* @dev Constructor.
* @param pool The reference to the main Pool contract
* @param name The name of the token
* @param symbol The symbol of the token
* @param decimals The number of decimals of the token
*/
constructor(
IPool pool,
string memory name,
string memory symbol,
uint8 decimals
) IncentivizedERC20(pool, name, symbol, decimals) {
// Intentionally left blank
}
/**
* @notice Mints tokens to an account and apply incentives if defined
* @param account The address receiving tokens
* @param amount The amount of tokens to mint
*/
function _mint(address account, uint128 amount) internal virtual {
uint256 oldTotalSupply = _totalSupply;
_totalSupply = oldTotalSupply + amount;
uint128 oldAccountBalance = _userState[account].balance;
_userState[account].balance = oldAccountBalance + amount;
IAaveIncentivesController incentivesControllerLocal = _incentivesController;
if (address(incentivesControllerLocal) != address(0)) {
incentivesControllerLocal.handleAction(account, oldTotalSupply, oldAccountBalance);
}
}
/**
* @notice Burns tokens from an account and apply incentives if defined
* @param account The account whose tokens are burnt
* @param amount The amount of tokens to burn
*/
function _burn(address account, uint128 amount) internal virtual {
uint256 oldTotalSupply = _totalSupply;
_totalSupply = oldTotalSupply - amount;
uint128 oldAccountBalance = _userState[account].balance;
_userState[account].balance = oldAccountBalance - amount;
IAaveIncentivesController incentivesControllerLocal = _incentivesController;
if (address(incentivesControllerLocal) != address(0)) {
incentivesControllerLocal.handleAction(account, oldTotalSupply, oldAccountBalance);
}
}
}
Footer
我们可以看到MintableIncentivizedERC20继承了IncentivizedERC20,然后实现了mint和burn的功能,这两个方法会去更新_totalSupply和UserState里的balance,然后会调用IAaveIncentivesController去更新实际持仓量。
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.10;
import {SafeCast} from '../../../dependencies/openzeppelin/contracts/SafeCast.sol';
import {Errors} from '../../libraries/helpers/Errors.sol';
import {WadRayMath} from '../../libraries/math/WadRayMath.sol';
import {IPool} from '../../../interfaces/IPool.sol';
import {IScaledBalanceToken} from '../../../interfaces/IScaledBalanceToken.sol';
import {MintableIncentivizedERC20} from './MintableIncentivizedERC20.sol';
/**
* @title ScaledBalanceTokenBase
* @author Aave
* @notice Basic ERC20 implementation of scaled balance token
*/
abstract contract ScaledBalanceTokenBase is MintableIncentivizedERC20, IScaledBalanceToken {
using WadRayMath for uint256;
using SafeCast for uint256;
/**
* @dev Constructor.
* @param pool The reference to the main Pool contract
* @param name The name of the token
* @param symbol The symbol of the token
* @param decimals The number of decimals of the token
*/
constructor(
IPool pool,
string memory name,
string memory symbol,
uint8 decimals
) MintableIncentivizedERC20(pool, name, symbol, decimals) {
// Intentionally left blank
}
/// @inheritdoc IScaledBalanceToken
function scaledBalanceOf(address user) external view override returns (uint256) {
return super.balanceOf(user);
}
/// @inheritdoc IScaledBalanceToken
function getScaledUserBalanceAndSupply(address user)
external
view
override
returns (uint256, uint256)
{
return (super.balanceOf(user), super.totalSupply());
}
/// @inheritdoc IScaledBalanceToken
function scaledTotalSupply() public view virtual override returns (uint256) {
return super.totalSupply();
}
/// @inheritdoc IScaledBalanceToken
function getPreviousIndex(address user) external view virtual override returns (uint256) {
return _userState[user].additionalData;
}
/**
* @notice Implements the basic logic to mint a scaled balance token.
* @param caller The address performing the mint
* @param onBehalfOf The address of the user that will receive the scaled tokens
* @param amount The amount of tokens getting minted
* @param index The next liquidity index of the reserve
* @return `true` if the the previous balance of the user was 0
*/
function _mintScaled(
address caller,
address onBehalfOf,
uint256 amount,
uint256 index
) internal returns (bool) {
uint256 amountScaled = amount.rayDiv(index);
require(amountScaled != 0, Errors.INVALID_MINT_AMOUNT);
uint256 scaledBalance = super.balanceOf(onBehalfOf);
uint256 balanceIncrease = scaledBalance.rayMul(index) -
scaledBalance.rayMul(_userState[onBehalfOf].additionalData);
_userState[onBehalfOf].additionalData = index.toUint128();
_mint(onBehalfOf, amountScaled.toUint128());
uint256 amountToMint = amount + balanceIncrease;
emit Transfer(address(0), onBehalfOf, amountToMint);
emit Mint(caller, onBehalfOf, amountToMint, balanceIncrease, index);
return (scaledBalance == 0);
}
/**
* @notice Implements the basic logic to burn a scaled balance token.
* @dev In some instances, a burn transaction will emit a mint event
* if the amount to burn is less than the interest that the user accrued
* @param user The user which debt is burnt
* @param target The address that will receive the underlying, if any
* @param amount The amount getting burned
* @param index The variable debt index of the reserve
*/
function _burnScaled(
address user,
address target,
uint256 amount,
uint256 index
) internal {
uint256 amountScaled = amount.rayDiv(index);
require(amountScaled != 0, Errors.INVALID_BURN_AMOUNT);
uint256 scaledBalance = super.balanceOf(user);
uint256 balanceIncrease = scaledBalance.rayMul(index) -
scaledBalance.rayMul(_userState[user].additionalData);
_userState[user].additionalData = index.toUint128();
_burn(user, amountScaled.toUint128());
if (balanceIncrease > amount) {
uint256 amountToMint = balanceIncrease - amount;
emit Transfer(address(0), user, amountToMint);
emit Mint(user, user, amountToMint, balanceIncrease, index);
} else {
uint256 amountToBurn = amount - balanceIncrease;
emit Transfer(user, address(0), amountToBurn);
emit Burn(user, target, amountToBurn, balanceIncrease, index);
}
}
/**
* @notice Implements the basic logic to transfer scaled balance tokens between two users
* @dev It emits a mint event with the interest accrued per user
* @param sender The source address
* @param recipient The destination address
* @param amount The amount getting transferred
* @param index The next liquidity index of the reserve
*/
function _transfer(
address sender,
address recipient,
uint256 amount,
uint256 index
) internal {
uint256 senderScaledBalance = super.balanceOf(sender);
uint256 senderBalanceIncrease = senderScaledBalance.rayMul(index) -
senderScaledBalance.rayMul(_userState[sender].additionalData);
uint256 recipientScaledBalance = super.balanceOf(recipient);
uint256 recipientBalanceIncrease = recipientScaledBalance.rayMul(index) -
recipientScaledBalance.rayMul(_userState[recipient].additionalData);
_userState[sender].additionalData = index.toUint128();
_userState[recipient].additionalData = index.toUint128();
super._transfer(sender, recipient, amount.rayDiv(index).toUint128());
if (senderBalanceIncrease > 0) {
emit Transfer(address(0), sender, senderBalanceIncrease);
emit Mint(_msgSender(), sender, senderBalanceIncrease, senderBalanceIncrease, index);
}
if (sender != recipient && recipientBalanceIncrease > 0) {
emit Transfer(address(0), recipient, recipientBalanceIncrease);
emit Mint(_msgSender(), recipient, recipientBalanceIncrease, recipientBalanceIncrease, index);
}
emit Transfer(sender, recipient, amount);
}
}
ScaledBalanceTokenBase继承了MintableIncentivizedERC20,并且实现了三个新方法:_mintScaled、_burnScaled和 _transfer a)_mintScaled
function _mintScaled(
address caller,
address onBehalfOf,
uint256 amount,
uint256 index
) internal returns (bool)
第一个传参caller是调用者,第二个传参onBehalfOf是实际受影响的用户地址,第三个传参amount是存入的底层资产的数量,第四个传参是index,也就是当前的存款利率累加指数。
接下来我们可以看到,实际需要被mint的数量amountScaled
,其实是用amount去除以累加指数index:
uint256 amountScaled = amount.rayDiv(index);
require(amountScaled != 0, Errors.INVALID_MINT_AMOUNT);
如果有点金融知识的就能理解,这其实是将该资产按照index进行贴现处理。举个例子,当第一个用户存款100,这时候index是1,此时amountScaled = 100 / 1 = 100。过一段时间后,index变成了1.03,如果用户又存入了100,此时amountScaled = 100/1.03 = 97,此时用户总的balance = 100 + 97 = 197。之所以这么处理,是因为用户实际的本息和是用balance去乘以当前的index。当第二次存款的时候,用户正确的本息和应该是 100 1.03 + 100 = 203,如果不做贴现处理,第二次用户存入100后的本息和就变成了(100+100) 1.03 = 206,是错误的,如果进行了贴现,本息和就变成了(100 + 100 / 1.03) * 1.03 = 103 + 100 = 203,这是正确的。
算出amountScaled
后直接调用_mint:
_mint(onBehalfOf, amountScaled.toUint128());
其他代码都是为了处理事件,可以不看。
b)_burnScaled _burnScaled和_mintScaled逻辑差不多,也是先进行贴现处理,然后burn掉。
c) _transfer _transfer的核心代码就一行:
super._transfer(sender, recipient, amount.rayDiv(index).toUint128());
其他都是为了处理事件而进行的计算
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.10;
/**
* @title EIP712Base
* @author Aave
* @notice Base contract implementation of EIP712.
*/
abstract contract EIP712Base {
bytes public constant EIP712_REVISION = bytes('1');
bytes32 internal constant EIP712_DOMAIN =
keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)');
// Map of address nonces (address => nonce)
mapping(address => uint256) internal _nonces;
bytes32 internal _domainSeparator;
uint256 internal immutable _chainId;
/**
* @dev Constructor.
*/
constructor() {
_chainId = block.chainid;
}
/**
* @notice Get the domain separator for the token
* @dev Return cached value if chainId matches cache, otherwise recomputes separator
* @return The domain separator of the token at current chain
*/
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
if (block.chainid == _chainId) {
return _domainSeparator;
}
return _calculateDomainSeparator();
}
/**
* @notice Returns the nonce value for address specified as parameter
* @param owner The address for which the nonce is being returned
* @return The nonce value for the input address`
*/
function nonces(address owner) public view virtual returns (uint256) {
return _nonces[owner];
}
/**
* @notice Compute the current domain separator
* @return The domain separator for the token
*/
function _calculateDomainSeparator() internal view returns (bytes32) {
return
keccak256(
abi.encode(
EIP712_DOMAIN,
keccak256(bytes(_EIP712BaseId())),
keccak256(EIP712_REVISION),
block.chainid,
address(this)
)
);
}
/**
* @notice Returns the user readable name of signing domain (e.g. token name)
* @return The name of the signing domain
*/
function _EIP712BaseId() internal view virtual returns (string memory);
}
其实就是实现了EIP712,如果不理解EIP712,可以看这篇文章:https://learnblockchain.cn/2019/04/24/token-EIP712
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.10;
import {IERC20} from '../../dependencies/openzeppelin/contracts/IERC20.sol';
import {GPv2SafeERC20} from '../../dependencies/gnosis/contracts/GPv2SafeERC20.sol';
import {SafeCast} from '../../dependencies/openzeppelin/contracts/SafeCast.sol';
import {VersionedInitializable} from '../libraries/aave-upgradeability/VersionedInitializable.sol';
import {Errors} from '../libraries/helpers/Errors.sol';
import {WadRayMath} from '../libraries/math/WadRayMath.sol';
import {IPool} from '../../interfaces/IPool.sol';
import {IAToken} from '../../interfaces/IAToken.sol';
import {IAaveIncentivesController} from '../../interfaces/IAaveIncentivesController.sol';
import {IInitializableAToken} from '../../interfaces/IInitializableAToken.sol';
import {ScaledBalanceTokenBase} from './base/ScaledBalanceTokenBase.sol';
import {IncentivizedERC20} from './base/IncentivizedERC20.sol';
import {EIP712Base} from './base/EIP712Base.sol';
/**
* @title Aave ERC20 AToken
* @author Aave
* @notice Implementation of the interest bearing token for the Aave protocol
*/
contract AToken is VersionedInitializable, ScaledBalanceTokenBase, EIP712Base, IAToken {
using WadRayMath for uint256;
using SafeCast for uint256;
using GPv2SafeERC20 for IERC20;
bytes32 public constant PERMIT_TYPEHASH =
keccak256('Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)');
uint256 public constant ATOKEN_REVISION = 0x1;
address internal _treasury;
address internal _underlyingAsset;
/// @inheritdoc VersionedInitializable
function getRevision() internal pure virtual override returns (uint256) {
return ATOKEN_REVISION;
}
/**
* @dev Constructor.
* @param pool The address of the Pool contract
*/
constructor(IPool pool)
ScaledBalanceTokenBase(pool, 'ATOKEN_IMPL', 'ATOKEN_IMPL', 0)
EIP712Base()
{
// Intentionally left blank
}
/// @inheritdoc IInitializableAToken
function initialize(
IPool initializingPool,
address treasury,
address underlyingAsset,
IAaveIncentivesController incentivesController,
uint8 aTokenDecimals,
string calldata aTokenName,
string calldata aTokenSymbol,
bytes calldata params
) public virtual override initializer {
require(initializingPool == POOL, Errors.POOL_ADDRESSES_DO_NOT_MATCH);
_setName(aTokenName);
_setSymbol(aTokenSymbol);
_setDecimals(aTokenDecimals);
_treasury = treasury;
_underlyingAsset = underlyingAsset;
_incentivesController = incentivesController;
_domainSeparator = _calculateDomainSeparator();
emit Initialized(
underlyingAsset,
address(POOL),
treasury,
address(incentivesController),
aTokenDecimals,
aTokenName,
aTokenSymbol,
params
);
}
/// @inheritdoc IAToken
function mint(
address caller,
address onBehalfOf,
uint256 amount,
uint256 index
) external virtual override onlyPool returns (bool) {
return _mintScaled(caller, onBehalfOf, amount, index);
}
/// @inheritdoc IAToken
function burn(
address from,
address receiverOfUnderlying,
uint256 amount,
uint256 index
) external virtual override onlyPool {
_burnScaled(from, receiverOfUnderlying, amount, index);
if (receiverOfUnderlying != address(this)) {
IERC20(_underlyingAsset).safeTransfer(receiverOfUnderlying, amount);
}
}
/// @inheritdoc IAToken
function mintToTreasury(uint256 amount, uint256 index) external virtual override onlyPool {
if (amount == 0) {
return;
}
_mintScaled(address(POOL), _treasury, amount, index);
}
/// @inheritdoc IAToken
function transferOnLiquidation(
address from,
address to,
uint256 value
) external virtual override onlyPool {
// Being a normal transfer, the Transfer() and BalanceTransfer() are emitted
// so no need to emit a specific event here
_transfer(from, to, value, false);
}
/// @inheritdoc IERC20
function balanceOf(address user)
public
view
virtual
override(IncentivizedERC20, IERC20)
returns (uint256)
{
return super.balanceOf(user).rayMul(POOL.getReserveNormalizedIncome(_underlyingAsset));
}
/// @inheritdoc IERC20
function totalSupply() public view virtual override(IncentivizedERC20, IERC20) returns (uint256) {
uint256 currentSupplyScaled = super.totalSupply();
if (currentSupplyScaled == 0) {
return 0;
}
return currentSupplyScaled.rayMul(POOL.getReserveNormalizedIncome(_underlyingAsset));
}
/// @inheritdoc IAToken
function RESERVE_TREASURY_ADDRESS() external view override returns (address) {
return _treasury;
}
/// @inheritdoc IAToken
function UNDERLYING_ASSET_ADDRESS() external view override returns (address) {
return _underlyingAsset;
}
/// @inheritdoc IAToken
function transferUnderlyingTo(address target, uint256 amount) external virtual override onlyPool {
IERC20(_underlyingAsset).safeTransfer(target, amount);
}
/// @inheritdoc IAToken
function handleRepayment(
address user,
address onBehalfOf,
uint256 amount
) external virtual override onlyPool {
// Intentionally left blank
}
/// @inheritdoc IAToken
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external override {
require(owner != address(0), Errors.ZERO_ADDRESS_NOT_VALID);
//solium-disable-next-line
require(block.timestamp <= deadline, Errors.INVALID_EXPIRATION);
uint256 currentValidNonce = _nonces[owner];
bytes32 digest = keccak256(
abi.encodePacked(
'\x19\x01',
DOMAIN_SEPARATOR(),
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, currentValidNonce, deadline))
)
);
require(owner == ecrecover(digest, v, r, s), Errors.INVALID_SIGNATURE);
_nonces[owner] = currentValidNonce + 1;
_approve(owner, spender, value);
}
/**
* @notice Transfers the aTokens between two users. Validates the transfer
* (ie checks for valid HF after the transfer) if required
* @param from The source address
* @param to The destination address
* @param amount The amount getting transferred
* @param validate True if the transfer needs to be validated, false otherwise
*/
function _transfer(
address from,
address to,
uint256 amount,
bool validate
) internal virtual {
address underlyingAsset = _underlyingAsset;
uint256 index = POOL.getReserveNormalizedIncome(underlyingAsset);
uint256 fromBalanceBefore = super.balanceOf(from).rayMul(index);
uint256 toBalanceBefore = super.balanceOf(to).rayMul(index);
super._transfer(from, to, amount, index);
if (validate) {
POOL.finalizeTransfer(underlyingAsset, from, to, amount, fromBalanceBefore, toBalanceBefore);
}
emit BalanceTransfer(from, to, amount.rayDiv(index), index);
}
/**
* @notice Overrides the parent _transfer to force validated transfer() and transferFrom()
* @param from The source address
* @param to The destination address
* @param amount The amount getting transferred
*/
function _transfer(
address from,
address to,
uint128 amount
) internal virtual override {
_transfer(from, to, amount, true);
}
/**
* @dev Overrides the base function to fully implement IAToken
* @dev see `EIP712Base.DOMAIN_SEPARATOR()` for more detailed documentation
*/
function DOMAIN_SEPARATOR() public view override(IAToken, EIP712Base) returns (bytes32) {
return super.DOMAIN_SEPARATOR();
}
/**
* @dev Overrides the base function to fully implement IAToken
* @dev see `EIP712Base.nonces()` for more detailed documentation
*/
function nonces(address owner) public view override(IAToken, EIP712Base) returns (uint256) {
return super.nonces(owner);
}
/// @inheritdoc EIP712Base
function _EIP712BaseId() internal view override returns (string memory) {
return name();
}
/// @inheritdoc IAToken
function rescueTokens(
address token,
address to,
uint256 amount
) external override onlyPoolAdmin {
require(token != _underlyingAsset, Errors.UNDERLYING_CANNOT_BE_RESCUED);
IERC20(token).safeTransfer(to, amount);
}
}
AToken继承了ScaledBalanceTokenBase并且重写了balanceOf方法:
function balanceOf(address user)
public
view
virtual
override(IncentivizedERC20, IERC20)
returns (uint256)
{
return super.balanceOf(user).rayMul(POOL.getReserveNormalizedIncome(_underlyingAsset));
}
super.balanceOf(user)返回的是实际的balance,这些balance都是进行贴现处理过的,POOL.getReserveNormalizedIncome(_underlyingAsset)返回的是当前的存款利率累加指数。两个相乘就是用户的本息和。随着时间的推移,由于贷款利息在不断增加,因此存款利率累加指数也会慢慢变大,因此用户AToken的balanceOf返回的值也会慢慢变大。这其实是违背了ERC20的标准的,因此很多其他协议在使用AToken的时候,又会进行一层封装,比如Balancer在使用AToken的时候,会将它转成一个static token,具体可以看他们的文档。
重写了totalSupply方法:
function totalSupply() public view virtual override(IncentivizedERC20, IERC20) returns (uint256) {
uint256 currentSupplyScaled = super.totalSupply();
if (currentSupplyScaled == 0) {
return 0;
}
return currentSupplyScaled.rayMul(POOL.getReserveNormalizedIncome(_underlyingAsset));
}
原理和balanceOf一样。
重写了mint和burn:
function mint(
address caller,
address onBehalfOf,
uint256 amount,
uint256 index
) external virtual override onlyPool returns (bool) {
return _mintScaled(caller, onBehalfOf, amount, index);
}
/// @inheritdoc IAToken
function burn(
address from,
address receiverOfUnderlying,
uint256 amount,
uint256 index
) external virtual override onlyPool {
_burnScaled(from, receiverOfUnderlying, amount, index);
if (receiverOfUnderlying != address(this)) {
IERC20(_underlyingAsset).safeTransfer(receiverOfUnderlying, amount);
}
}
底层调用_mintScaled和_burnScaled。
重写了_transfer方法:
function _transfer(
address from,
address to,
uint256 amount,
bool validate
) internal virtual {
address underlyingAsset = _underlyingAsset;
uint256 index = POOL.getReserveNormalizedIncome(underlyingAsset);
uint256 fromBalanceBefore = super.balanceOf(from).rayMul(index);
uint256 toBalanceBefore = super.balanceOf(to).rayMul(index);
super._transfer(from, to, amount, index);
if (validate) {
POOL.finalizeTransfer(underlyingAsset, from, to, amount, fromBalanceBefore, toBalanceBefore);
}
emit BalanceTransfer(from, to, amount.rayDiv(index), index);
}
使用的是ScaledBalanceTokenBase的_transfer方法,如果validate是true,还需要调用POOL.finalizeTransfer校验下用户是否可以转移,如果用户本身存在债务,就可能无法转移,否则会被清算。
总的来说,Aave通过贴现的方式,将不同时间点的存款数量转化成初始时间点的存款数量,因此每份数量的底层资产对应的本息和,就可以直接用amount * index算出来,大大方便了计算和理解。
如果觉得我的文章对您有用,请随意打赏。你的支持将鼓励我继续创作!