Branch data     Line data    Source code

       1                 :             : // SPDX-License-Identifier: BUSL-1.1
       2                 :             : pragma solidity ^0.8.10;
       3                 :             : 
       4                 :             : import {IERC20} from '../../dependencies/openzeppelin/contracts/IERC20.sol';
       5                 :             : import {SafeCast} from '../../dependencies/openzeppelin/contracts/SafeCast.sol';
       6                 :             : import {VersionedInitializable} from '../../misc/aave-upgradeability/VersionedInitializable.sol';
       7                 :             : import {WadRayMath} from '../libraries/math/WadRayMath.sol';
       8                 :             : import {Errors} from '../libraries/helpers/Errors.sol';
       9                 :             : import {IPool} from '../../interfaces/IPool.sol';
      10                 :             : import {IAaveIncentivesController} from '../../interfaces/IAaveIncentivesController.sol';
      11                 :             : import {IInitializableDebtToken} from '../../interfaces/IInitializableDebtToken.sol';
      12                 :             : import {IVariableDebtToken} from '../../interfaces/IVariableDebtToken.sol';
      13                 :             : import {EIP712Base} from './base/EIP712Base.sol';
      14                 :             : import {DebtTokenBase} from './base/DebtTokenBase.sol';
      15                 :             : import {ScaledBalanceTokenBase} from './base/ScaledBalanceTokenBase.sol';
      16                 :             : 
      17                 :             : /**
      18                 :             :  * @title VariableDebtToken
      19                 :             :  * @author Aave
      20                 :             :  * @notice Implements a variable debt token to track the borrowing positions of users
      21                 :             :  * at variable rate mode
      22                 :             :  * @dev Transfer and approve functionalities are disabled since its a non-transferable token
      23                 :             :  */
      24                 :             : abstract contract VariableDebtToken is DebtTokenBase, ScaledBalanceTokenBase, IVariableDebtToken {
      25                 :             :   using WadRayMath for uint256;
      26                 :             :   using SafeCast for uint256;
      27                 :             : 
      28                 :             :   /**
      29                 :             :    * @dev Constructor.
      30                 :             :    * @param pool The address of the Pool contract
      31                 :             :    */
      32                 :             :   constructor(
      33                 :             :     IPool pool
      34                 :             :   )
      35                 :             :     DebtTokenBase()
      36                 :             :     ScaledBalanceTokenBase(pool, 'VARIABLE_DEBT_TOKEN_IMPL', 'VARIABLE_DEBT_TOKEN_IMPL', 0)
      37                 :             :   {
      38                 :             :     // Intentionally left blank
      39                 :             :   }
      40                 :             : 
      41                 :             :   /// @inheritdoc IInitializableDebtToken
      42                 :             :   function initialize(
      43                 :             :     IPool initializingPool,
      44                 :             :     address underlyingAsset,
      45                 :             :     IAaveIncentivesController incentivesController,
      46                 :             :     uint8 debtTokenDecimals,
      47                 :             :     string memory debtTokenName,
      48                 :             :     string memory debtTokenSymbol,
      49                 :             :     bytes calldata params
      50                 :             :   ) external virtual;
      51                 :             : 
      52                 :             :   /// @inheritdoc IERC20
      53                 :             :   function balanceOf(address user) public view virtual override returns (uint256) {
      54                 :       30602 :     uint256 scaledBalance = super.balanceOf(user);
      55                 :             : 
      56                 :       30602 :     if (scaledBalance == 0) {
      57                 :        1040 :       return 0;
      58                 :             :     }
      59                 :             : 
      60                 :       29562 :     return scaledBalance.rayMul(POOL.getReserveNormalizedVariableDebt(_underlyingAsset));
      61                 :             :   }
      62                 :             : 
      63                 :             :   /// @inheritdoc IVariableDebtToken
      64                 :             :   function mint(
      65                 :             :     address user,
      66                 :             :     address onBehalfOf,
      67                 :             :     uint256 amount,
      68                 :             :     uint256 index
      69                 :             :   ) external virtual override onlyPool returns (bool, uint256) {
      70                 :       19091 :     if (user != onBehalfOf) {
      71                 :        1001 :       _decreaseBorrowAllowance(onBehalfOf, user, amount);
      72                 :             :     }
      73                 :       19091 :     return (_mintScaled(user, onBehalfOf, amount, index), scaledTotalSupply());
      74                 :             :   }
      75                 :             : 
      76                 :             :   /// @inheritdoc IVariableDebtToken
      77                 :             :   function burn(
      78                 :             :     address from,
      79                 :             :     uint256 amount,
      80                 :             :     uint256 index
      81                 :             :   ) external virtual override onlyPool returns (uint256) {
      82                 :       15035 :     _burnScaled(from, address(0), amount, index);
      83                 :       15035 :     return scaledTotalSupply();
      84                 :             :   }
      85                 :             : 
      86                 :             :   /// @inheritdoc IERC20
      87                 :             :   function totalSupply() public view virtual override returns (uint256) {
      88                 :          15 :     return super.totalSupply().rayMul(POOL.getReserveNormalizedVariableDebt(_underlyingAsset));
      89                 :             :   }
      90                 :             : 
      91                 :             :   /// @inheritdoc EIP712Base
      92                 :             :   function _EIP712BaseId() internal view override returns (string memory) {
      93                 :      172697 :     return name();
      94                 :             :   }
      95                 :             : 
      96                 :             :   /**
      97                 :             :    * @dev Being non transferrable, the debt token does not implement any of the
      98                 :             :    * standard ERC20 functions for transfer and allowance.
      99                 :             :    */
     100                 :             :   function transfer(address, uint256) external virtual override returns (bool) {
     101                 :           1 :     revert(Errors.OPERATION_NOT_SUPPORTED);
     102                 :             :   }
     103                 :             : 
     104                 :             :   function allowance(address, address) external view virtual override returns (uint256) {
     105                 :           1 :     revert(Errors.OPERATION_NOT_SUPPORTED);
     106                 :             :   }
     107                 :             : 
     108                 :             :   function approve(address, uint256) external virtual override returns (bool) {
     109                 :           1 :     revert(Errors.OPERATION_NOT_SUPPORTED);
     110                 :             :   }
     111                 :             : 
     112                 :             :   function transferFrom(address, address, uint256) external virtual override returns (bool) {
     113                 :           1 :     revert(Errors.OPERATION_NOT_SUPPORTED);
     114                 :             :   }
     115                 :             : 
     116                 :             :   function increaseAllowance(address, uint256) external virtual override returns (bool) {
     117                 :           1 :     revert(Errors.OPERATION_NOT_SUPPORTED);
     118                 :             :   }
     119                 :             : 
     120                 :             :   function decreaseAllowance(address, uint256) external virtual override returns (bool) {
     121                 :           1 :     revert(Errors.OPERATION_NOT_SUPPORTED);
     122                 :             :   }
     123                 :             : 
     124                 :             :   /// @inheritdoc IVariableDebtToken
     125                 :             :   function UNDERLYING_ASSET_ADDRESS() external view override returns (address) {
     126                 :       51072 :     return _underlyingAsset;
     127                 :             :   }
     128                 :             : }