Aave V3

1import {VersionedInitializable} from '../libraries/aave-upgradeability/VersionedInitializable.sol';
2import {Errors} from '../libraries/helpers/Errors.sol';
3import {ReserveConfiguration} from '../libraries/configuration/ReserveConfiguration.sol';
4import {PoolLogic} from '../libraries/logic/PoolLogic.sol';
5import {ReserveLogic} from '../libraries/logic/ReserveLogic.sol';
6import {EModeLogic} from '../libraries/logic/EModeLogic.sol';
7import {SupplyLogic} from '../libraries/logic/SupplyLogic.sol';
8import {FlashLoanLogic} from '../libraries/logic/FlashLoanLogic.sol';
9import {BorrowLogic} from '../libraries/logic/BorrowLogic.sol';
10import {LiquidationLogic} from '../libraries/logic/LiquidationLogic.sol';
11import {DataTypes} from '../libraries/types/DataTypes.sol';
12import {BridgeLogic} from '../libraries/logic/BridgeLogic.sol';
13import {IERC20WithPermit} from '../../interfaces/IERC20WithPermit.sol';
14import {IPoolAddressesProvider} from '../../interfaces/IPoolAddressesProvider.sol';
15import {IPool} from '../../interfaces/IPool.sol';
16import {IACLManager} from '../../interfaces/IACLManager.sol';
17import {PoolStorage} from './PoolStorage.sol';
18
19/**
20 * @title Pool contract
21 * @author Aave
22 * @notice Main point of interaction with an Aave protocol's market
23 * - Users can:
24 *   # Supply
25 *   # Withdraw
26 *   # Borrow
27 *   # Repay
28 *   # Swap their loans between variable and stable rate
29 *   # Enable/disable their supplied assets as collateral rebalance stable rate borrow positions
30 *   # Liquidate positions
31 *   # Execute Flash Loans
32 * @dev To be covered by a proxy contract, owned by the PoolAddressesProvider of the specific market
33 * @dev All admin functions are callable by the PoolConfigurator contract defined also in the
34 *   PoolAddressesProvider
35 **/
36contract Pool is VersionedInitializable, IPool, PoolStorage {
37  using ReserveLogic for DataTypes.ReserveData;
38
39  uint256 public constant POOL_REVISION = 0x1;
40  IPoolAddressesProvider public immutable ADDRESSES_PROVIDER;
41
42  /**
43   * @dev Only pool configurator can call functions marked by this modifier.
44   **/
45  modifier onlyPoolConfigurator() {
46    _onlyPoolConfigurator();
47    _;
48  }
49
50  /**
51   * @dev Only pool admin can call functions marked by this modifier.
52   **/
53  modifier onlyPoolAdmin() {
54    _onlyPoolAdmin();
55    _;
56  }
57
58  /**
59   * @dev Only bridge can call functions marked by this modifier.
60   **/
61  modifier onlyBridge() {
62    _onlyBridge();
63    _;
64  }
65
66  function _onlyPoolConfigurator() internal view virtual {
67    require(
68      ADDRESSES_PROVIDER.getPoolConfigurator() == msg.sender,
69      Errors.CALLER_NOT_POOL_CONFIGURATOR
70    );
71  }
72
73  function _onlyPoolAdmin() internal view virtual {
74    require(
75      IACLManager(ADDRESSES_PROVIDER.getACLManager()).isPoolAdmin(msg.sender),
76      Errors.CALLER_NOT_POOL_ADMIN
77    );
78  }
79
80  function _onlyBridge() internal view virtual {
81    require(
82      IACLManager(ADDRESSES_PROVIDER.getACLManager()).isBridge(msg.sender),
83      Errors.CALLER_NOT_BRIDGE
84    );
85  }
86
87  function getRevision() internal pure virtual override returns (uint256) {
88    return POOL_REVISION;
89  }
90
91  /**
92   * @dev Constructor.
93   * @param provider The address of the PoolAddressesProvider contract
94   */
95  constructor(IPoolAddressesProvider provider) {
96    ADDRESSES_PROVIDER = provider;
97  }
98
99  /**
100   * @notice Initializes the Pool.
101   * @dev Function is invoked by the proxy contract when the Pool contract is added to the
102   * PoolAddressesProvider of the market.
103   * @dev Caching the address of the PoolAddressesProvider in order to reduce gas consumption on subsequent operations
104   * @param provider The address of the PoolAddressesProvider
105   **/
106  function initialize(IPoolAddressesProvider provider) external virtual initializer {
107    require(provider == ADDRESSES_PROVIDER, Errors.INVALID_ADDRESSES_PROVIDER);
108    _maxStableRateBorrowSizePercent = 0.25e4;
109    _flashLoanPremiumTotal = 0.0009e4;
110    _flashLoanPremiumToProtocol = 0;
111  }
112
113  /// @inheritdoc IPool
114  function mintUnbacked(
115    address asset,
116    uint256 amount,
117    address onBehalfOf,
118    uint16 referralCode
119  ) external virtual override onlyBridge {
120    BridgeLogic.executeMintUnbacked(
121      _reserves,
122      _reservesList,
123      _usersConfig[onBehalfOf],
124      asset,
125      amount,
126      onBehalfOf,
127      referralCode
128    );
129  }
130
131  /// @inheritdoc IPool
132  function backUnbacked(
133    address asset,
134    uint256 amount,
135    uint256 fee
136  ) external virtual override onlyBridge {
137    BridgeLogic.executeBackUnbacked(_reserves[asset], asset, amount, fee, _bridgeProtocolFee);
138  }
139
140  /// @inheritdoc IPool
141  function supply(
142    address asset,
143    uint256 amount,
144    address onBehalfOf,
145    uint16 referralCode
146  ) external virtual override {
147    SupplyLogic.executeSupply(
148      _reserves,
149      _reservesList,
150      _usersConfig[onBehalfOf],
151      DataTypes.ExecuteSupplyParams({
152        asset: asset,
153        amount: amount,
154        onBehalfOf: onBehalfOf,
155        referralCode: referralCode
156      })
157    );
158  }
159
160  /// @inheritdoc IPool
161  function supplyWithPermit(
162    address asset,
163    uint256 amount,
164    address onBehalfOf,
165    uint16 referralCode,
166    uint256 deadline,
167    uint8 permitV,
168    bytes32 permitR,
169    bytes32 permitS
170  ) external virtual override {
171    IERC20WithPermit(asset).permit(
172      msg.sender,
173      address(this),
174      amount,
175      deadline,
176      permitV,
177      permitR,
178      permitS
179    );
180    SupplyLogic.executeSupply(
181      _reserves,
182      _reservesList,
183      _usersConfig[onBehalfOf],
184      DataTypes.ExecuteSupplyParams({
185        asset: asset,
186        amount: amount,
187        onBehalfOf: onBehalfOf,
188        referralCode: referralCode
189      })
190    );
191  }
192
193  /// @inheritdoc IPool
194  function withdraw(
195    address asset,
196    uint256 amount,
197    address to
198  ) external virtual override returns (uint256) {
199    return
200      SupplyLogic.executeWithdraw(
201        _reserves,
202        _reservesList,
203        _eModeCategories,
204        _usersConfig[msg.sender],
205        DataTypes.ExecuteWithdrawParams({
206          asset: asset,
207          amount: amount,
208          to: to,
209          reservesCount: _reservesCount,
210          oracle: ADDRESSES_PROVIDER.getPriceOracle(),
211          userEModeCategory: _usersEModeCategory[msg.sender]
212        })
213      );
214  }
215
216  /// @inheritdoc IPool
217  function borrow(
218    address asset,
219    uint256 amount,
220    uint256 interestRateMode,
221    uint16 referralCode,
222    address onBehalfOf
223  ) external virtual override {
224    BorrowLogic.executeBorrow(
225      _reserves,
226      _reservesList,
227      _eModeCategories,
228      _usersConfig[onBehalfOf],
229      DataTypes.ExecuteBorrowParams({
230        asset: asset,
231        user: msg.sender,
232        onBehalfOf: onBehalfOf,
233        amount: amount,
234        interestRateMode: DataTypes.InterestRateMode(interestRateMode),
235        referralCode: referralCode,
236        releaseUnderlying: true,
237        maxStableRateBorrowSizePercent: _maxStableRateBorrowSizePercent,
238        reservesCount: _reservesCount,
239        oracle: ADDRESSES_PROVIDER.getPriceOracle(),
240        userEModeCategory: _usersEModeCategory[onBehalfOf],
241        priceOracleSentinel: ADDRESSES_PROVIDER.getPriceOracleSentinel()
242      })
243    );
244  }
245
246  /// @inheritdoc IPool
247  function repay(
248    address asset,
249    uint256 amount,
250    uint256 interestRateMode,
251    address onBehalfOf
252  ) external virtual override returns (uint256) {
253    return
254      BorrowLogic.executeRepay(
255        _reserves,
256        _reservesList,
257        _usersConfig[onBehalfOf],
258        DataTypes.ExecuteRepayParams({
259          asset: asset,
260          amount: amount,
261          interestRateMode: DataTypes.InterestRateMode(interestRateMode),
262          onBehalfOf: onBehalfOf,
263          useATokens: false
264        })
265      );
266  }
267
268  /// @inheritdoc IPool
269  function repayWithPermit(
270    address asset,
271    uint256 amount,
272    uint256 interestRateMode,
273    address onBehalfOf,
274    uint256 deadline,
275    uint8 permitV,
276    bytes32 permitR,
277    bytes32 permitS
278  ) external virtual override returns (uint256) {
279    {
280      IERC20WithPermit(asset).permit(
281        msg.sender,
282        address(this),
283        amount,
284        deadline,
285        permitV,
286        permitR,
287        permitS
288      );
289    }