Branch data     Line data    Source code

       1                 :             : // SPDX-License-Identifier: BUSL-1.1
       2                 :             : pragma solidity ^0.8.10;
       3                 :             : 
       4                 :             : import {Errors} from '../protocol/libraries/helpers/Errors.sol';
       5                 :             : import {IPoolAddressesProvider} from '../interfaces/IPoolAddressesProvider.sol';
       6                 :             : import {IPriceOracleSentinel} from '../interfaces/IPriceOracleSentinel.sol';
       7                 :             : import {ISequencerOracle} from '../interfaces/ISequencerOracle.sol';
       8                 :             : import {IACLManager} from '../interfaces/IACLManager.sol';
       9                 :             : 
      10                 :             : /**
      11                 :             :  * @title PriceOracleSentinel
      12                 :             :  * @author Aave
      13                 :             :  * @notice It validates if operations are allowed depending on the PriceOracle health.
      14                 :             :  * @dev Once the PriceOracle gets up after an outage/downtime, users can make their positions healthy during a grace
      15                 :             :  *  period. So the PriceOracle is considered completely up once its up and the grace period passed.
      16                 :             :  */
      17                 :             : contract PriceOracleSentinel is IPriceOracleSentinel {
      18                 :             :   /**
      19                 :             :    * @dev Only pool admin can call functions marked by this modifier.
      20                 :             :    */
      21                 :             :   modifier onlyPoolAdmin() {
      22                 :           2 :     IACLManager aclManager = IACLManager(ADDRESSES_PROVIDER.getACLManager());
      23                 :           2 :     require(aclManager.isPoolAdmin(msg.sender), Errors.CALLER_NOT_POOL_ADMIN);
      24                 :             :     _;
      25                 :             :   }
      26                 :             : 
      27                 :             :   /**
      28                 :             :    * @dev Only risk or pool admin can call functions marked by this modifier.
      29                 :             :    */
      30                 :             :   modifier onlyRiskOrPoolAdmins() {
      31                 :           2 :     IACLManager aclManager = IACLManager(ADDRESSES_PROVIDER.getACLManager());
      32                 :           2 :     require(
      33                 :             :       aclManager.isRiskAdmin(msg.sender) || aclManager.isPoolAdmin(msg.sender),
      34                 :             :       Errors.CALLER_NOT_RISK_OR_POOL_ADMIN
      35                 :             :     );
      36                 :             :     _;
      37                 :             :   }
      38                 :             : 
      39                 :             :   IPoolAddressesProvider public immutable override ADDRESSES_PROVIDER;
      40                 :             : 
      41                 :             :   ISequencerOracle internal _sequencerOracle;
      42                 :             : 
      43                 :             :   uint256 internal _gracePeriod;
      44                 :             : 
      45                 :             :   /**
      46                 :             :    * @dev Constructor
      47                 :             :    * @param provider The address of the PoolAddressesProvider
      48                 :             :    * @param oracle The address of the SequencerOracle
      49                 :             :    * @param gracePeriod The duration of the grace period in seconds
      50                 :             :    */
      51                 :             :   constructor(IPoolAddressesProvider provider, ISequencerOracle oracle, uint256 gracePeriod) {
      52                 :          31 :     ADDRESSES_PROVIDER = provider;
      53                 :          28 :     _sequencerOracle = oracle;
      54                 :          20 :     _gracePeriod = gracePeriod;
      55                 :             :   }
      56                 :             : 
      57                 :             :   /// @inheritdoc IPriceOracleSentinel
      58                 :             :   function isBorrowAllowed() external view override returns (bool) {
      59                 :           5 :     return _isUpAndGracePeriodPassed();
      60                 :             :   }
      61                 :             : 
      62                 :             :   /// @inheritdoc IPriceOracleSentinel
      63                 :             :   function isLiquidationAllowed() external view override returns (bool) {
      64                 :           5 :     return _isUpAndGracePeriodPassed();
      65                 :             :   }
      66                 :             : 
      67                 :             :   /**
      68                 :             :    * @notice Checks the sequencer oracle is healthy: is up and grace period passed.
      69                 :             :    * @return True if the SequencerOracle is up and the grace period passed, false otherwise
      70                 :             :    */
      71                 :             :   function _isUpAndGracePeriodPassed() internal view returns (bool) {
      72                 :          10 :     (, int256 answer, uint256 startedAt, , ) = _sequencerOracle.latestRoundData();
      73                 :          10 :     return answer == 0 && block.timestamp - startedAt > _gracePeriod;
      74                 :             :   }
      75                 :             : 
      76                 :             :   /// @inheritdoc IPriceOracleSentinel
      77                 :             :   function setSequencerOracle(address newSequencerOracle) external onlyPoolAdmin {
      78                 :           1 :     _sequencerOracle = ISequencerOracle(newSequencerOracle);
      79                 :           1 :     emit SequencerOracleUpdated(newSequencerOracle);
      80                 :             :   }
      81                 :             : 
      82                 :             :   /// @inheritdoc IPriceOracleSentinel
      83                 :             :   function setGracePeriod(uint256 newGracePeriod) external onlyRiskOrPoolAdmins {
      84                 :           1 :     _gracePeriod = newGracePeriod;
      85                 :           1 :     emit GracePeriodUpdated(newGracePeriod);
      86                 :             :   }
      87                 :             : 
      88                 :             :   /// @inheritdoc IPriceOracleSentinel
      89                 :             :   function getSequencerOracle() external view returns (address) {
      90                 :           1 :     return address(_sequencerOracle);
      91                 :             :   }
      92                 :             : 
      93                 :             :   /// @inheritdoc IPriceOracleSentinel
      94                 :             :   function getGracePeriod() external view returns (uint256) {
      95                 :           1 :     return _gracePeriod;
      96                 :             :   }
      97                 :             : }