Branch data Line data Source code
1 : : // SPDX-License-Identifier: BUSL-1.1
2 : : pragma solidity ^0.8.10;
3 : :
4 : : import {VersionedInitializable} from '../../misc/aave-upgradeability/VersionedInitializable.sol';
5 : : import {ReserveConfiguration} from '../libraries/configuration/ReserveConfiguration.sol';
6 : : import {EModeConfiguration} from '../libraries/configuration/EModeConfiguration.sol';
7 : : import {IPoolAddressesProvider} from '../../interfaces/IPoolAddressesProvider.sol';
8 : : import {IDefaultInterestRateStrategyV2} from '../../interfaces/IDefaultInterestRateStrategyV2.sol';
9 : : import {Errors} from '../libraries/helpers/Errors.sol';
10 : : import {PercentageMath} from '../libraries/math/PercentageMath.sol';
11 : : import {DataTypes} from '../libraries/types/DataTypes.sol';
12 : : import {ConfiguratorLogic} from '../libraries/logic/ConfiguratorLogic.sol';
13 : : import {ConfiguratorInputTypes} from '../libraries/types/ConfiguratorInputTypes.sol';
14 : : import {IPoolConfigurator} from '../../interfaces/IPoolConfigurator.sol';
15 : : import {IPool} from '../../interfaces/IPool.sol';
16 : : import {IACLManager} from '../../interfaces/IACLManager.sol';
17 : : import {IPoolDataProvider} from '../../interfaces/IPoolDataProvider.sol';
18 : : import {IERC20} from '../../dependencies/openzeppelin/contracts/IERC20.sol';
19 : : import {IERC20Detailed} from '../../dependencies/openzeppelin/contracts/IERC20Detailed.sol';
20 : :
21 : : /**
22 : : * @title PoolConfigurator
23 : : * @author Aave
24 : : * @dev Implements the configuration methods for the Aave protocol
25 : : */
26 : : abstract contract PoolConfigurator is VersionedInitializable, IPoolConfigurator {
27 : : using PercentageMath for uint256;
28 : : using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
29 : :
30 : : IPoolAddressesProvider internal _addressesProvider;
31 : : IPool internal _pool;
32 : :
33 : : mapping(address => uint256) internal _pendingLtv;
34 : :
35 : : uint40 public constant MAX_GRACE_PERIOD = 4 hours;
36 : :
37 : : /**
38 : : * @dev Only pool admin can call functions marked by this modifier.
39 : : */
40 : : modifier onlyPoolAdmin() {
41 : 1682 : _onlyPoolAdmin();
42 : : _;
43 : : }
44 : :
45 : : /**
46 : : * @dev Only emergency or pool admin can call functions marked by this modifier.
47 : : */
48 : : modifier onlyEmergencyOrPoolAdmin() {
49 : 2003 : _onlyPoolOrEmergencyAdmin();
50 : : _;
51 : : }
52 : :
53 : : /**
54 : : * @dev Only asset listing or pool admin can call functions marked by this modifier.
55 : : */
56 : : modifier onlyAssetListingOrPoolAdmins() {
57 : 8651 : _onlyAssetListingOrPoolAdmins();
58 : : _;
59 : : }
60 : :
61 : : /**
62 : : * @dev Only risk or pool admin can call functions marked by this modifier.
63 : : */
64 : : modifier onlyRiskOrPoolAdmins() {
65 : 7010 : _onlyRiskOrPoolAdmins();
66 : : _;
67 : : }
68 : :
69 : : /**
70 : : * @dev Only risk, pool or emergency admin can call functions marked by this modifier.
71 : : */
72 : : modifier onlyRiskOrPoolOrEmergencyAdmins() {
73 : 3014 : _onlyRiskOrPoolOrEmergencyAdmins();
74 : : _;
75 : : }
76 : :
77 : : function initialize(IPoolAddressesProvider provider) public virtual;
78 : :
79 : : /// @inheritdoc IPoolConfigurator
80 : : function initReserves(
81 : : ConfiguratorInputTypes.InitReserveInput[] calldata input
82 : : ) external override onlyAssetListingOrPoolAdmins {
83 : 7651 : IPool cachedPool = _pool;
84 : :
85 : 7651 : for (uint256 i = 0; i < input.length; i++) {
86 : 167016 : ConfiguratorLogic.executeInitReserve(cachedPool, input[i]);
87 : 165016 : emit ReserveInterestRateDataChanged(
88 : : input[i].underlyingAsset,
89 : : input[i].interestRateStrategyAddress,
90 : : input[i].interestRateData
91 : : );
92 : : }
93 : : }
94 : :
95 : : /// @inheritdoc IPoolConfigurator
96 : : function dropReserve(address asset) external override onlyPoolAdmin {
97 : 5 : _pool.dropReserve(asset);
98 : 1 : emit ReserveDropped(asset);
99 : : }
100 : :
101 : : /// @inheritdoc IPoolConfigurator
102 : : function updateAToken(
103 : : ConfiguratorInputTypes.UpdateATokenInput calldata input
104 : : ) external override onlyPoolAdmin {
105 : 1 : ConfiguratorLogic.executeUpdateAToken(_pool, input);
106 : : }
107 : :
108 : : /// @inheritdoc IPoolConfigurator
109 : : function updateVariableDebtToken(
110 : : ConfiguratorInputTypes.UpdateDebtTokenInput calldata input
111 : : ) external override onlyPoolAdmin {
112 : 1 : ConfiguratorLogic.executeUpdateVariableDebtToken(_pool, input);
113 : : }
114 : :
115 : : /// @inheritdoc IPoolConfigurator
116 : : function setReserveBorrowing(address asset, bool enabled) external override onlyRiskOrPoolAdmins {
117 : 4947 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
118 : 4947 : currentConfig.setBorrowingEnabled(enabled);
119 : 4947 : _pool.setConfiguration(asset, currentConfig);
120 : 4947 : emit ReserveBorrowing(asset, enabled);
121 : : }
122 : :
123 : : /// @inheritdoc IPoolConfigurator
124 : : function configureReserveAsCollateral(
125 : : address asset,
126 : : uint256 ltv,
127 : : uint256 liquidationThreshold,
128 : : uint256 liquidationBonus
129 : : ) external override onlyRiskOrPoolAdmins {
130 : : //validation of the parameters: the LTV can
131 : : //only be lower or equal than the liquidation threshold
132 : : //(otherwise a loan against the asset would cause instantaneous liquidation)
133 : 9952 : require(ltv <= liquidationThreshold, Errors.INVALID_RESERVE_PARAMS);
134 : :
135 : 7952 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
136 : :
137 : 7952 : if (liquidationThreshold != 0) {
138 : : //liquidation bonus must be bigger than 100.00%, otherwise the liquidator would receive less
139 : : //collateral than needed to cover the debt
140 : 6951 : require(liquidationBonus > PercentageMath.PERCENTAGE_FACTOR, Errors.INVALID_RESERVE_PARAMS);
141 : :
142 : : //if threshold * bonus is less than PERCENTAGE_FACTOR, it's guaranteed that at the moment
143 : : //a loan is taken there is enough collateral available to cover the liquidation bonus
144 : 5951 : require(
145 : : liquidationThreshold.percentMul(liquidationBonus) <= PercentageMath.PERCENTAGE_FACTOR,
146 : : Errors.INVALID_RESERVE_PARAMS
147 : : );
148 : : } else {
149 : 1001 : require(liquidationBonus == 0, Errors.INVALID_RESERVE_PARAMS);
150 : : //if the liquidation threshold is being set to 0,
151 : : // the reserve is being disabled as collateral. To do so,
152 : : //we need to ensure no liquidity is supplied
153 : 1001 : _checkNoSuppliers(asset);
154 : : }
155 : :
156 : 4952 : uint256 newLtv = ltv;
157 : :
158 : 4952 : if (currentConfig.getFrozen()) {
159 : 1000 : _pendingLtv[asset] = ltv;
160 : 1000 : newLtv = 0;
161 : :
162 : 1000 : emit PendingLtvChanged(asset, ltv);
163 : : } else {
164 : 3952 : currentConfig.setLtv(ltv);
165 : : }
166 : :
167 : 4952 : currentConfig.setLiquidationThreshold(liquidationThreshold);
168 : 4952 : currentConfig.setLiquidationBonus(liquidationBonus);
169 : :
170 : 4952 : _pool.setConfiguration(asset, currentConfig);
171 : :
172 : 4952 : emit CollateralConfigurationChanged(asset, newLtv, liquidationThreshold, liquidationBonus);
173 : : }
174 : :
175 : : /// @inheritdoc IPoolConfigurator
176 : : function setReserveFlashLoaning(
177 : : address asset,
178 : : bool enabled
179 : : ) external override onlyRiskOrPoolAdmins {
180 : 3948 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
181 : :
182 : 3948 : currentConfig.setFlashLoanEnabled(enabled);
183 : 3948 : _pool.setConfiguration(asset, currentConfig);
184 : 3948 : emit ReserveFlashLoaning(asset, enabled);
185 : : }
186 : :
187 : : /// @inheritdoc IPoolConfigurator
188 : : function setReserveActive(address asset, bool active) external override onlyPoolAdmin {
189 : 11 : if (!active) _checkNoSuppliers(asset);
190 : 10 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
191 : 10 : currentConfig.setActive(active);
192 : 10 : _pool.setConfiguration(asset, currentConfig);
193 : 10 : emit ReserveActive(asset, active);
194 : : }
195 : :
196 : : /// @inheritdoc IPoolConfigurator
197 : : function setReserveFreeze(
198 : : address asset,
199 : : bool freeze
200 : : ) external override onlyRiskOrPoolOrEmergencyAdmins {
201 : 2014 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
202 : :
203 : 2014 : require(freeze != currentConfig.getFrozen(), Errors.INVALID_FREEZE_STATE);
204 : :
205 : 2012 : currentConfig.setFrozen(freeze);
206 : :
207 : 2012 : uint256 ltvSet;
208 : 2012 : uint256 pendingLtvSet;
209 : :
210 : 2012 : if (freeze) {
211 : 1010 : pendingLtvSet = currentConfig.getLtv();
212 : 1010 : _pendingLtv[asset] = pendingLtvSet;
213 : 1010 : currentConfig.setLtv(0);
214 : : } else {
215 : 1002 : ltvSet = _pendingLtv[asset];
216 : 1002 : currentConfig.setLtv(ltvSet);
217 : 1002 : delete _pendingLtv[asset];
218 : : }
219 : :
220 : 2012 : emit PendingLtvChanged(asset, pendingLtvSet);
221 : 2012 : emit CollateralConfigurationChanged(
222 : : asset,
223 : : ltvSet,
224 : : currentConfig.getLiquidationThreshold(),
225 : : currentConfig.getLiquidationBonus()
226 : : );
227 : :
228 : 2012 : _pool.setConfiguration(asset, currentConfig);
229 : 2012 : emit ReserveFrozen(asset, freeze);
230 : : }
231 : :
232 : : /// @inheritdoc IPoolConfigurator
233 : : function setBorrowableInIsolation(
234 : : address asset,
235 : : bool borrowable
236 : : ) external override onlyRiskOrPoolAdmins {
237 : 1959 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
238 : 1959 : currentConfig.setBorrowableInIsolation(borrowable);
239 : 1959 : _pool.setConfiguration(asset, currentConfig);
240 : 1959 : emit BorrowableInIsolationChanged(asset, borrowable);
241 : : }
242 : :
243 : : /// @inheritdoc IPoolConfigurator
244 : : function setReservePause(
245 : : address asset,
246 : : bool paused,
247 : : uint40 gracePeriod
248 : : ) public override onlyEmergencyOrPoolAdmin {
249 : 14022 : if (!paused && gracePeriod != 0) {
250 : 10411 : require(gracePeriod <= MAX_GRACE_PERIOD, Errors.INVALID_GRACE_PERIOD);
251 : :
252 : 9411 : uint40 until = uint40(block.timestamp) + gracePeriod;
253 : 9411 : _pool.setLiquidationGracePeriod(asset, until);
254 : 9411 : emit LiquidationGracePeriodChanged(asset, until);
255 : : }
256 : :
257 : 13022 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
258 : 13022 : currentConfig.setPaused(paused);
259 : 13022 : _pool.setConfiguration(asset, currentConfig);
260 : 13022 : emit ReservePaused(asset, paused);
261 : : }
262 : :
263 : : /// @inheritdoc IPoolConfigurator
264 : : function setReservePause(address asset, bool paused) external override onlyEmergencyOrPoolAdmin {
265 : 1001 : setReservePause(asset, paused, 0);
266 : : }
267 : :
268 : : /// @inheritdoc IPoolConfigurator
269 : : function disableLiquidationGracePeriod(address asset) external override onlyEmergencyOrPoolAdmin {
270 : : // set the liquidation grace period in the past to disable liquidation grace period
271 : 1001 : _pool.setLiquidationGracePeriod(asset, 0);
272 : :
273 : 1001 : emit LiquidationGracePeriodDisabled(asset);
274 : : }
275 : :
276 : : /// @inheritdoc IPoolConfigurator
277 : : function setReserveFactor(
278 : : address asset,
279 : : uint256 newReserveFactor
280 : : ) external override onlyRiskOrPoolAdmins {
281 : 1949 : require(newReserveFactor <= PercentageMath.PERCENTAGE_FACTOR, Errors.INVALID_RESERVE_FACTOR);
282 : :
283 : 1948 : _pool.syncIndexesState(asset);
284 : :
285 : 1948 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
286 : 1948 : uint256 oldReserveFactor = currentConfig.getReserveFactor();
287 : 1948 : currentConfig.setReserveFactor(newReserveFactor);
288 : 1948 : _pool.setConfiguration(asset, currentConfig);
289 : 1948 : emit ReserveFactorChanged(asset, oldReserveFactor, newReserveFactor);
290 : :
291 : 1948 : _pool.syncRatesState(asset);
292 : : }
293 : :
294 : : /// @inheritdoc IPoolConfigurator
295 : : function setDebtCeiling(
296 : : address asset,
297 : : uint256 newDebtCeiling
298 : : ) external override onlyRiskOrPoolAdmins {
299 : 1964 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
300 : :
301 : 1964 : uint256 oldDebtCeiling = currentConfig.getDebtCeiling();
302 : 1964 : if (currentConfig.getLiquidationThreshold() != 0 && oldDebtCeiling == 0) {
303 : 1960 : _checkNoSuppliers(asset);
304 : : }
305 : 1963 : currentConfig.setDebtCeiling(newDebtCeiling);
306 : 1963 : _pool.setConfiguration(asset, currentConfig);
307 : :
308 : 1963 : if (newDebtCeiling == 0) {
309 : 1949 : _pool.resetIsolationModeTotalDebt(asset);
310 : : }
311 : :
312 : 1963 : emit DebtCeilingChanged(asset, oldDebtCeiling, newDebtCeiling);
313 : : }
314 : :
315 : : /// @inheritdoc IPoolConfigurator
316 : : function setSiloedBorrowing(
317 : : address asset,
318 : : bool newSiloed
319 : : ) external override onlyRiskOrPoolAdmins {
320 : 1949 : if (newSiloed) {
321 : 3 : _checkNoBorrowers(asset);
322 : : }
323 : 1948 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
324 : :
325 : 1948 : bool oldSiloed = currentConfig.getSiloedBorrowing();
326 : :
327 : 1948 : currentConfig.setSiloedBorrowing(newSiloed);
328 : :
329 : 1948 : _pool.setConfiguration(asset, currentConfig);
330 : :
331 : 1948 : emit SiloedBorrowingChanged(asset, oldSiloed, newSiloed);
332 : : }
333 : :
334 : : /// @inheritdoc IPoolConfigurator
335 : : function setBorrowCap(
336 : : address asset,
337 : : uint256 newBorrowCap
338 : : ) external override onlyRiskOrPoolAdmins {
339 : 1956 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
340 : 1956 : uint256 oldBorrowCap = currentConfig.getBorrowCap();
341 : 1956 : currentConfig.setBorrowCap(newBorrowCap);
342 : 1955 : _pool.setConfiguration(asset, currentConfig);
343 : 1955 : emit BorrowCapChanged(asset, oldBorrowCap, newBorrowCap);
344 : : }
345 : :
346 : : /// @inheritdoc IPoolConfigurator
347 : : function setSupplyCap(
348 : : address asset,
349 : : uint256 newSupplyCap
350 : : ) external override onlyRiskOrPoolAdmins {
351 : 2962 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
352 : 2962 : uint256 oldSupplyCap = currentConfig.getSupplyCap();
353 : 2962 : currentConfig.setSupplyCap(newSupplyCap);
354 : 2961 : _pool.setConfiguration(asset, currentConfig);
355 : 2961 : emit SupplyCapChanged(asset, oldSupplyCap, newSupplyCap);
356 : : }
357 : :
358 : : /// @inheritdoc IPoolConfigurator
359 : : function setLiquidationProtocolFee(
360 : : address asset,
361 : : uint256 newFee
362 : : ) external override onlyRiskOrPoolAdmins {
363 : 1953 : require(newFee <= PercentageMath.PERCENTAGE_FACTOR, Errors.INVALID_LIQUIDATION_PROTOCOL_FEE);
364 : 1951 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
365 : 1951 : uint256 oldFee = currentConfig.getLiquidationProtocolFee();
366 : 1951 : currentConfig.setLiquidationProtocolFee(newFee);
367 : 1951 : _pool.setConfiguration(asset, currentConfig);
368 : 1951 : emit LiquidationProtocolFeeChanged(asset, oldFee, newFee);
369 : : }
370 : :
371 : : /// @inheritdoc IPoolConfigurator
372 : : function setEModeCategory(
373 : : uint8 categoryId,
374 : : uint16 ltv,
375 : : uint16 liquidationThreshold,
376 : : uint16 liquidationBonus,
377 : : string calldata label
378 : : ) external override onlyRiskOrPoolAdmins {
379 : 10035 : require(ltv != 0, Errors.INVALID_EMODE_CATEGORY_PARAMS);
380 : 10034 : require(liquidationThreshold != 0, Errors.INVALID_EMODE_CATEGORY_PARAMS);
381 : :
382 : : // validation of the parameters: the LTV can
383 : : // only be lower or equal than the liquidation threshold
384 : : // (otherwise a loan against the asset would cause instantaneous liquidation)
385 : 10033 : require(ltv <= liquidationThreshold, Errors.INVALID_EMODE_CATEGORY_PARAMS);
386 : 10032 : require(
387 : : liquidationBonus > PercentageMath.PERCENTAGE_FACTOR,
388 : : Errors.INVALID_EMODE_CATEGORY_PARAMS
389 : : );
390 : :
391 : : // if threshold * bonus is less than PERCENTAGE_FACTOR, it's guaranteed that at the moment
392 : : // a loan is taken there is enough collateral available to cover the liquidation bonus
393 : 10030 : require(
394 : : uint256(liquidationThreshold).percentMul(liquidationBonus) <=
395 : : PercentageMath.PERCENTAGE_FACTOR,
396 : : Errors.INVALID_EMODE_CATEGORY_PARAMS
397 : : );
398 : :
399 : 10029 : DataTypes.EModeCategoryBaseConfiguration memory categoryData;
400 : 10029 : categoryData.ltv = ltv;
401 : 10029 : categoryData.liquidationThreshold = liquidationThreshold;
402 : 10029 : categoryData.liquidationBonus = liquidationBonus;
403 : 10029 : categoryData.label = label;
404 : :
405 : 10029 : _pool.configureEModeCategory(categoryId, categoryData);
406 : 10029 : emit EModeCategoryAdded(
407 : : categoryId,
408 : : ltv,
409 : : liquidationThreshold,
410 : : liquidationBonus,
411 : : address(0),
412 : : label
413 : : );
414 : : }
415 : :
416 : : /// @inheritdoc IPoolConfigurator
417 : : function setAssetCollateralInEMode(
418 : : address asset,
419 : : uint8 categoryId,
420 : : bool allowed
421 : : ) external override onlyRiskOrPoolAdmins {
422 : 10039 : uint128 collateralBitmap = _pool.getEModeCategoryCollateralBitmap(categoryId);
423 : 10039 : DataTypes.ReserveDataLegacy memory reserveData = _pool.getReserveData(asset);
424 : 10039 : require(reserveData.id != 0 || _pool.getReservesList()[0] == asset, Errors.ASSET_NOT_LISTED);
425 : 10039 : collateralBitmap = EModeConfiguration.setReserveBitmapBit(
426 : : collateralBitmap,
427 : : reserveData.id,
428 : : allowed
429 : : );
430 : 10039 : _pool.configureEModeCategoryCollateralBitmap(categoryId, collateralBitmap);
431 : 10039 : emit AssetCollateralInEModeChanged(asset, categoryId, allowed);
432 : : }
433 : :
434 : : /// @inheritdoc IPoolConfigurator
435 : : function setAssetBorrowableInEMode(
436 : : address asset,
437 : : uint8 categoryId,
438 : : bool borrowable
439 : : ) external override onlyRiskOrPoolAdmins {
440 : 7010 : uint128 borrowableBitmap = _pool.getEModeCategoryBorrowableBitmap(categoryId);
441 : 7010 : DataTypes.ReserveDataLegacy memory reserveData = _pool.getReserveData(asset);
442 : 7010 : require(reserveData.id != 0 || _pool.getReservesList()[0] == asset, Errors.ASSET_NOT_LISTED);
443 : 7010 : borrowableBitmap = EModeConfiguration.setReserveBitmapBit(
444 : : borrowableBitmap,
445 : : reserveData.id,
446 : : borrowable
447 : : );
448 : 7010 : _pool.configureEModeCategoryBorrowableBitmap(categoryId, borrowableBitmap);
449 : 7010 : emit AssetBorrowableInEModeChanged(asset, categoryId, borrowable);
450 : : }
451 : :
452 : : /// @inheritdoc IPoolConfigurator
453 : : function setUnbackedMintCap(
454 : : address asset,
455 : : uint256 newUnbackedMintCap
456 : : ) external override onlyRiskOrPoolAdmins {
457 : 7 : DataTypes.ReserveConfigurationMap memory currentConfig = _pool.getConfiguration(asset);
458 : 7 : uint256 oldUnbackedMintCap = currentConfig.getUnbackedMintCap();
459 : 7 : currentConfig.setUnbackedMintCap(newUnbackedMintCap);
460 : 7 : _pool.setConfiguration(asset, currentConfig);
461 : 7 : emit UnbackedMintCapChanged(asset, oldUnbackedMintCap, newUnbackedMintCap);
462 : : }
463 : :
464 : : /// @inheritdoc IPoolConfigurator
465 : : function setReserveInterestRateData(
466 : : address asset,
467 : : bytes calldata rateData
468 : : ) external onlyRiskOrPoolAdmins {
469 : 2 : DataTypes.ReserveDataLegacy memory reserve = _pool.getReserveData(asset);
470 : 2 : _updateInterestRateStrategy(asset, reserve, reserve.interestRateStrategyAddress, rateData);
471 : : }
472 : :
473 : : /// @inheritdoc IPoolConfigurator
474 : : function setReserveInterestRateStrategyAddress(
475 : : address asset,
476 : : address rateStrategyAddress,
477 : : bytes calldata rateData
478 : : ) external override onlyRiskOrPoolAdmins {
479 : 44 : DataTypes.ReserveDataLegacy memory reserve = _pool.getReserveData(asset);
480 : 44 : _updateInterestRateStrategy(asset, reserve, rateStrategyAddress, rateData);
481 : : }
482 : :
483 : : /// @inheritdoc IPoolConfigurator
484 : : function setPoolPause(bool paused, uint40 gracePeriod) public override onlyEmergencyOrPoolAdmin {
485 : 1003 : address[] memory reserves = _pool.getReservesList();
486 : :
487 : 1003 : for (uint256 i = 0; i < reserves.length; i++) {
488 : 3009 : if (reserves[i] != address(0)) {
489 : 3009 : setReservePause(reserves[i], paused, gracePeriod);
490 : : }
491 : : }
492 : : }
493 : :
494 : : /// @inheritdoc IPoolConfigurator
495 : : function setPoolPause(bool paused) external override onlyEmergencyOrPoolAdmin {
496 : 3 : setPoolPause(paused, 0);
497 : : }
498 : :
499 : : /// @inheritdoc IPoolConfigurator
500 : : function updateBridgeProtocolFee(uint256 newBridgeProtocolFee) external override onlyPoolAdmin {
501 : 14 : require(
502 : : newBridgeProtocolFee <= PercentageMath.PERCENTAGE_FACTOR,
503 : : Errors.BRIDGE_PROTOCOL_FEE_INVALID
504 : : );
505 : 13 : uint256 oldBridgeProtocolFee = _pool.BRIDGE_PROTOCOL_FEE();
506 : 13 : _pool.updateBridgeProtocolFee(newBridgeProtocolFee);
507 : 13 : emit BridgeProtocolFeeUpdated(oldBridgeProtocolFee, newBridgeProtocolFee);
508 : : }
509 : :
510 : : /// @inheritdoc IPoolConfigurator
511 : : function updateFlashloanPremiumTotal(
512 : : uint128 newFlashloanPremiumTotal
513 : : ) external override onlyPoolAdmin {
514 : 682 : require(
515 : : newFlashloanPremiumTotal <= PercentageMath.PERCENTAGE_FACTOR,
516 : : Errors.FLASHLOAN_PREMIUM_INVALID
517 : : );
518 : 681 : uint128 oldFlashloanPremiumTotal = _pool.FLASHLOAN_PREMIUM_TOTAL();
519 : 681 : _pool.updateFlashloanPremiums(newFlashloanPremiumTotal, _pool.FLASHLOAN_PREMIUM_TO_PROTOCOL());
520 : 681 : emit FlashloanPremiumTotalUpdated(oldFlashloanPremiumTotal, newFlashloanPremiumTotal);
521 : : }
522 : :
523 : : /// @inheritdoc IPoolConfigurator
524 : : function updateFlashloanPremiumToProtocol(
525 : : uint128 newFlashloanPremiumToProtocol
526 : : ) external override onlyPoolAdmin {
527 : 682 : require(
528 : : newFlashloanPremiumToProtocol <= PercentageMath.PERCENTAGE_FACTOR,
529 : : Errors.FLASHLOAN_PREMIUM_INVALID
530 : : );
531 : 681 : uint128 oldFlashloanPremiumToProtocol = _pool.FLASHLOAN_PREMIUM_TO_PROTOCOL();
532 : 681 : _pool.updateFlashloanPremiums(_pool.FLASHLOAN_PREMIUM_TOTAL(), newFlashloanPremiumToProtocol);
533 : 681 : emit FlashloanPremiumToProtocolUpdated(
534 : : oldFlashloanPremiumToProtocol,
535 : : newFlashloanPremiumToProtocol
536 : : );
537 : : }
538 : :
539 : : /// @inheritdoc IPoolConfigurator
540 : : function getPendingLtv(address asset) external view override returns (uint256) {
541 : 3003 : return _pendingLtv[asset];
542 : : }
543 : :
544 : : /// @inheritdoc IPoolConfigurator
545 : : function getConfiguratorLogic() external pure returns (address) {
546 : 1 : return address(ConfiguratorLogic);
547 : : }
548 : :
549 : : function _updateInterestRateStrategy(
550 : : address asset,
551 : : DataTypes.ReserveDataLegacy memory reserve,
552 : : address newRateStrategyAddress,
553 : : bytes calldata rateData
554 : : ) internal {
555 : 46 : address oldRateStrategyAddress = reserve.interestRateStrategyAddress;
556 : :
557 : 46 : _pool.syncIndexesState(asset);
558 : :
559 : 46 : IDefaultInterestRateStrategyV2(newRateStrategyAddress).setInterestRateParams(asset, rateData);
560 : 46 : emit ReserveInterestRateDataChanged(asset, newRateStrategyAddress, rateData);
561 : :
562 : 46 : if (oldRateStrategyAddress != newRateStrategyAddress) {
563 : 44 : _pool.setReserveInterestRateStrategyAddress(asset, newRateStrategyAddress);
564 : 44 : emit ReserveInterestRateStrategyChanged(
565 : : asset,
566 : : oldRateStrategyAddress,
567 : : newRateStrategyAddress
568 : : );
569 : : }
570 : :
571 : 46 : _pool.syncRatesState(asset);
572 : : }
573 : :
574 : : function _checkNoSuppliers(address asset) internal view {
575 : 2971 : DataTypes.ReserveDataLegacy memory reserveData = _pool.getReserveData(asset);
576 : 2971 : uint256 totalSupplied = IPoolDataProvider(_addressesProvider.getPoolDataProvider())
577 : : .getATokenTotalSupply(asset);
578 : :
579 : 2971 : require(
580 : : totalSupplied == 0 && reserveData.accruedToTreasury == 0,
581 : : Errors.RESERVE_LIQUIDITY_NOT_ZERO
582 : : );
583 : : }
584 : :
585 : : function _checkNoBorrowers(address asset) internal view {
586 : 3 : uint256 totalDebt = IPoolDataProvider(_addressesProvider.getPoolDataProvider()).getTotalDebt(
587 : : asset
588 : : );
589 : 3 : require(totalDebt == 0, Errors.RESERVE_DEBT_NOT_ZERO);
590 : : }
591 : :
592 : : function _onlyPoolAdmin() internal view {
593 : 7396 : IACLManager aclManager = IACLManager(_addressesProvider.getACLManager());
594 : 7396 : require(aclManager.isPoolAdmin(msg.sender), Errors.CALLER_NOT_POOL_ADMIN);
595 : : }
596 : :
597 : : function _onlyPoolOrEmergencyAdmin() internal view {
598 : 24030 : IACLManager aclManager = IACLManager(_addressesProvider.getACLManager());
599 : 24030 : require(
600 : : aclManager.isPoolAdmin(msg.sender) || aclManager.isEmergencyAdmin(msg.sender),
601 : : Errors.CALLER_NOT_POOL_OR_EMERGENCY_ADMIN
602 : : );
603 : : }
604 : :
605 : : function _onlyAssetListingOrPoolAdmins() internal view {
606 : 8651 : IACLManager aclManager = IACLManager(_addressesProvider.getACLManager());
607 : 8651 : require(
608 : : aclManager.isAssetListingAdmin(msg.sender) || aclManager.isPoolAdmin(msg.sender),
609 : : Errors.CALLER_NOT_ASSET_LISTING_OR_POOL_ADMIN
610 : : );
611 : : }
612 : :
613 : : function _onlyRiskOrPoolAdmins() internal view {
614 : 70679 : IACLManager aclManager = IACLManager(_addressesProvider.getACLManager());
615 : 70679 : require(
616 : : aclManager.isRiskAdmin(msg.sender) || aclManager.isPoolAdmin(msg.sender),
617 : : Errors.CALLER_NOT_RISK_OR_POOL_ADMIN
618 : : );
619 : : }
620 : :
621 : : function _onlyRiskOrPoolOrEmergencyAdmins() internal view {
622 : 3014 : IACLManager aclManager = IACLManager(_addressesProvider.getACLManager());
623 : 3014 : require(
624 : : aclManager.isRiskAdmin(msg.sender) ||
625 : : aclManager.isPoolAdmin(msg.sender) ||
626 : : aclManager.isEmergencyAdmin(msg.sender),
627 : : Errors.CALLER_NOT_RISK_OR_POOL_OR_EMERGENCY_ADMIN
628 : : );
629 : : }
630 : : }
|
