AAVE V2

1contract LendingPool is VersionedInitializable, ILendingPool, LendingPoolStorage {
2  using SafeMath for uint256;
3  using WadRayMath for uint256;
4  using PercentageMath for uint256;
5  using SafeERC20 for IERC20;
6​
7  uint256 public constant LENDINGPOOL_REVISION = 0x2;
8​
9  modifier whenNotPaused() {
10    _whenNotPaused();
11    _;
12  }
13​
14  modifier onlyLendingPoolConfigurator() {
15    _onlyLendingPoolConfigurator();
16    _;
17  }
18​
19  function _whenNotPaused() internal view {
20    require(!_paused, Errors.LP_IS_PAUSED);
21  }
22​
23  function _onlyLendingPoolConfigurator() internal view {
24    require(
25      _addressesProvider.getLendingPoolConfigurator() == msg.sender,
26      Errors.LP_CALLER_NOT_LENDING_POOL_CONFIGURATOR
27    );
28  }
29​
30  function getRevision() internal pure override returns (uint256) {
31    return LENDINGPOOL_REVISION;
32  }
33​
34  /**
35   * @dev Function is invoked by the proxy contract when the LendingPool contract is added to the
36   * LendingPoolAddressesProvider of the market.
37   * - Caching the address of the LendingPoolAddressesProvider in order to reduce gas consumption
38   *   on subsequent operations
39   * @param provider The address of the LendingPoolAddressesProvider
40   **/
41  function initialize(ILendingPoolAddressesProvider provider) public initializer {
42    _addressesProvider = provider;
43    _maxStableRateBorrowSizePercent = 2500;
44    _flashLoanPremiumTotal = 9;
45    _maxNumberOfReserves = 128;
46  }
47​
48  /**
49   * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
50   * - E.g. User deposits 100 USDC and gets in return 100 aUSDC
51   * @param asset The address of the underlying asset to deposit
52   * @param amount The amount to be deposited
53   * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
54   *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
55   *   is a different wallet
56   * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
57   *   0 if the action is executed directly by the user, without any middle-man
58   **/
59  function deposit(
60    address asset,
61    uint256 amount,
62    address onBehalfOf,
63    uint16 referralCode
64  ) external override whenNotPaused {
65    DataTypes.ReserveData storage reserve = _reserves[asset];
66​
67    ValidationLogic.validateDeposit(reserve, amount);
68​
69    address aToken = reserve.aTokenAddress;
70​
71    reserve.updateState();
72    reserve.updateInterestRates(asset, aToken, amount, 0);
73​
74    IERC20(asset).safeTransferFrom(msg.sender, aToken, amount);
75​
76    bool isFirstDeposit = IAToken(aToken).mint(onBehalfOf, amount, reserve.liquidityIndex);
77​
78    if (isFirstDeposit) {
79      _usersConfig[onBehalfOf].setUsingAsCollateral(reserve.id, true);
80      emit ReserveUsedAsCollateralEnabled(asset, onBehalfOf);
81    }
82​
83    emit Deposit(asset, msg.sender, onBehalfOf, amount, referralCode);
84  }
85​
86  /**
87   * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
88   * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
89   * @param asset The address of the underlying asset to withdraw
90   * @param amount The underlying amount to be withdrawn
91   *   - Send the value type(uint256).max in order to withdraw the whole aToken balance
92   * @param to Address that will receive the underlying, same as msg.sender if the user
93   *   wants to receive it on his own wallet, or a different address if the beneficiary is a
94   *   different wallet
95   * @return The final amount withdrawn
96   **/
97  function withdraw(
98    address asset,
99    uint256 amount,
100    address to
101  ) external override whenNotPaused returns (uint256) {
102    DataTypes.ReserveData storage reserve = _reserves[asset];
103​
104    address aToken = reserve.aTokenAddress;
105​
106    uint256 userBalance = IAToken(aToken).balanceOf(msg.sender);
107​
108    uint256 amountToWithdraw = amount;
109​
110    if (amount == type(uint256).max) {
111      amountToWithdraw = userBalance;
112    }
113​
114    ValidationLogic.validateWithdraw(
115      asset,
116      amountToWithdraw,
117      userBalance,
118      _reserves,
119      _usersConfig[msg.sender],
120      _reservesList,
121      _reservesCount,
122      _addressesProvider.getPriceOracle()
123    );
124​
125    reserve.updateState();
126​
127    reserve.updateInterestRates(asset, aToken, 0, amountToWithdraw);
128​
129    if (amountToWithdraw == userBalance) {
130      _usersConfig[msg.sender].setUsingAsCollateral(reserve.id, false);
131      emit ReserveUsedAsCollateralDisabled(asset, msg.sender);
132    }
133​
134    IAToken(aToken).burn(msg.sender, to, amountToWithdraw, reserve.liquidityIndex);
135​
136    emit Withdraw(asset, msg.sender, to, amountToWithdraw);
137​
138    return amountToWithdraw;
139  }
140​
141  /*
142   * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
143   * already deposited enough collateral, or he was given enough allowance by a credit delegator on the
144   * corresponding debt token (StableDebtToken or VariableDebtToken)
145   * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
146   *   and 100 stable/variable debt tokens, depending on the `interestRateMode`
147   * @param asset The address of the underlying asset to borrow
148   * @param amount The amount to be borrowed
149   * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
150   * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
151   *   0 if the action is executed directly by the user, without any middle-man
152   * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself
153   * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
154   * if he has been given credit delegation allowance
155   */
156  function borrow(
157    address asset,
158    uint256 amount,
159    uint256 interestRateMode,
160    uint16 referralCode,
161    address onBehalfOf
162  ) external override whenNotPaused {
163    DataTypes.ReserveData storage reserve = _reserves[asset];
164​
165    _executeBorrow(
166      ExecuteBorrowParams(
167        asset,
168        msg.sender,
169        onBehalfOf,
170        amount,
171        interestRateMode,
172        reserve.aTokenAddress,
173        referralCode,
174        true

Solidity Contracts

JavaScript Tests