Merge pull request #8 from Gearbox-protocol/pricefeed-optimisation

feat: pricefeed optimisation

Author: 0xmikko

contracts/interfaces/ILPPriceFeed.sol

@@ -1,30 +1,25 @@
 // SPDX-License-Identifier: MIT
 // Gearbox Protocol. Generalized leverage for DeFi protocols
 // (c) Gearbox Foundation, 2023.
-pragma solidity ^0.8.10;
+pragma solidity ^0.8.17;
 
-import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
-import {IPriceFeedType} from "./IPriceFeedType.sol";
+import {IPriceFeed} from "./IPriceFeed.sol";
 
 interface ILPPriceFeedEvents {
-    /// @dev Emits on updating the virtual price bounds
-    event NewLimiterParams(uint256 lowerBound, uint256 upperBound);
+    /// @notice Emitted when new LP token exchange rate bounds are set
+    event SetBounds(uint256 lowerBound, uint256 upperBound);
 }
 
-/// @title Interface for LP PriceFeeds with limiter
-interface ILPPriceFeed is AggregatorV3Interface, IPriceFeedType, ILPPriceFeedEvents {
-    /// @dev Sets the lower and upper bounds for virtual price.
-    /// @param _lowerBound The new lower bound
-    /// @notice The upper bound is computed automatically
-    function setLimiter(uint256 _lowerBound) external;
-
-    /// @dev Returns the lower bound
+/// @title LP price feed interface
+interface ILPPriceFeed is IPriceFeed, ILPPriceFeedEvents {
+    function lpToken() external view returns (address);
     function lowerBound() external view returns (uint256);
-
-    /// @dev Returns the upper bound
     function upperBound() external view returns (uint256);
-
-    /// @dev Returns the pre-defined window between the lower and upper bounds
-    /// @notice In bp format
     function delta() external view returns (uint256);
+
+    // ------------- //
+    // CONFIGURATION //
+    // ------------- //
+
+    function setLimiter(uint256 newLowerBound) external;
 }

contracts/interfaces/IPriceFeedType.sol contracts/interfaces/IPriceFeed.solcontracts/interfaces/IPriceFeedType.sol renamed to contracts/interfaces/IPriceFeed.sol

@@ -1,14 +1,13 @@
 // SPDX-License-Identifier: MIT
 // Gearbox Protocol. Generalized leverage for DeFi protocols
 // (c) Gearbox Foundation, 2023.
-pragma solidity ^0.8.0;
+pragma solidity ^0.8.17;
 
 import {PriceFeedType} from "@gearbox-protocol/sdk/contracts/PriceFeedType.sol";
+import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
 
-interface IPriceFeedType {
-    /// @dev Returns the price feed type
+/// @title Price feed interface
+interface IPriceFeed is AggregatorV3Interface {
     function priceFeedType() external view returns (PriceFeedType);
-
-    /// @dev Returns whether sanity checks on price feed result should be skipped
     function skipPriceCheck() external view returns (bool);
 }

contracts/interfaces/IPriceOracleV2.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: BUSL-1.1
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2023.
+pragma solidity ^0.8.17;
+
+import {IPriceFeed} from "../interfaces/IPriceFeed.sol";
+import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
+import {PriceFeedValidationTrait} from "@gearbox-protocol/core-v3/contracts/traits/PriceFeedValidationTrait.sol";
+import {NotImplementedException} from "@gearbox-protocol/core-v3/contracts/interfaces/IExceptions.sol";
+
+struct PriceFeedParams {
+    address priceFeed;
+    uint32 stalenessPeriod;
+}
+
+/// @title Abstract price feed
+/// @notice Base contract for all price feeds
+abstract contract AbstractPriceFeed is IPriceFeed, PriceFeedValidationTrait {
+    /// @notice Answer precision (always 8 decimals for USD price feeds)
+    uint8 public constant override decimals = 8;
+
+    /// @notice Indicates that price oracle can skip checks for this price feed's answers
+    bool public constant override skipPriceCheck = true;
+
+    /// @dev Returns answer from a price feed with optional sanity and staleness checks
+    /// @dev When computing LP token price, this MUST be used to get prices of underlying tokens
+    function _getValidatedPrice(address priceFeed, uint32 stalenessPeriod, bool skipCheck)
+        internal
+        view
+        returns (int256 answer, uint256 updatedAt)
+    {
+        (, answer,, updatedAt,) = AggregatorV3Interface(priceFeed).latestRoundData();
+        if (!skipCheck) _checkAnswer(answer, updatedAt, stalenessPeriod);
+    }
+
+    /// @dev Not implemented since Gearbox price feeds don't provide historical data
+    function getRoundData(uint80) external pure override returns (uint80, int256, uint256, uint256, uint80) {
+        revert NotImplementedException();
+    }
+}

contracts/oracles/AbstractPriceFeed.sol

@@ -1,98 +1,71 @@
 // SPDX-License-Identifier: BUSL-1.1
 // Gearbox Protocol. Generalized leverage for DeFi protocols
 // (c) Gearbox Foundation, 2023.
-pragma solidity ^0.8.10;
+pragma solidity ^0.8.17;
 
+import {AbstractPriceFeed} from "./AbstractPriceFeed.sol";
+import {PriceFeedType} from "../interfaces/IPriceFeed.sol";
 import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
 import {AggregatorV2V3Interface} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
-import {PERCENTAGE_FACTOR} from "@gearbox-protocol/core-v2/contracts/libraries/Constants.sol";
-import {PriceFeedType, IPriceFeedType} from "../interfaces/IPriceFeedType.sol";
-
-// EXCEPTIONS
-import {NotImplementedException} from "@gearbox-protocol/core-v3/contracts/interfaces/IExceptions.sol";
 
 interface ChainlinkReadableAggregator {
     function aggregator() external view returns (address);
-
     function phaseAggregators(uint16 idx) external view returns (AggregatorV2V3Interface);
-
     function phaseId() external view returns (uint16);
 }
 
-/// @title Price feed with an upper bound on price
-/// @notice Used to limit prices on assets that should not rise above
-///         a certain level, such as stablecoins and other pegged assets
-contract BoundedPriceFeed is ChainlinkReadableAggregator, AggregatorV3Interface, IPriceFeedType {
-    /// @dev Chainlink price feed for the Vault's underlying
-    AggregatorV3Interface public immutable priceFeed;
-
-    /// @dev The upper bound on Chainlink price for the asset
-    int256 public immutable upperBound;
-
-    /// @dev Decimals of the returned result.
-    uint8 public immutable override decimals;
-
-    /// @dev Price feed description
-    string public override description;
-
-    uint256 public constant override version = 1;
-
+/// @title Bounded price feed
+/// @notice Can be used to provide upper-bounded answers for assets that are
+///         expected to have the price in a certain range, e.g. stablecoins
+contract BoundedPriceFeed is AbstractPriceFeed, ChainlinkReadableAggregator {
+    /// @notice Contract version
+    uint256 public constant override version = 3_00;
     PriceFeedType public constant override priceFeedType = PriceFeedType.BOUNDED_ORACLE;
 
-    bool public constant override skipPriceCheck = false;
+    /// @notice Underlying price feed
+    address public immutable priceFeed;
+    uint32 public immutable stalenessPeriod;
+    bool public immutable skipCheck;
 
-    /// @dev Constructor
-    /// @param _priceFeed Chainlink price feed to receive results from
-    /// @param _upperBound Initial upper bound for the Chainlink price
-    constructor(address _priceFeed, int256 _upperBound) {
-        priceFeed = AggregatorV3Interface(_priceFeed);
-        description = string(abi.encodePacked(priceFeed.description(), " Bounded"));
-        decimals = priceFeed.decimals();
-        upperBound = _upperBound;
-    }
+    /// @notice Upper bound for underlying price feed answers
+    int256 public immutable upperBound;
 
-    /// @dev Implemented for compatibility, but reverts since Gearbox's price feeds
-    ///      do not store historical data.
-    function getRoundData(uint80)
-        external
-        pure
-        virtual
-        override
-        returns (
-            uint80, // roundId,
-            int256, // answer,
-            uint256, // startedAt,
-            uint256, // updatedAt,
-            uint80 // answeredInRound
-        )
-    {
-        revert NotImplementedException(); // F:[LPF-2]
+    /// @notice Constructor
+    /// @param _priceFeed Underlying price feed
+    /// @param _stalenessPeriod Underlying price feed staleness period, must be non-zero unless it performs own checks
+    /// @param _upperBound Upper bound for underlying price feed answers
+    constructor(address _priceFeed, uint32 _stalenessPeriod, int256 _upperBound) {
+        priceFeed = _priceFeed;
+        stalenessPeriod = _stalenessPeriod;
+        skipCheck = _validatePriceFeed(priceFeed, stalenessPeriod);
+        upperBound = _upperBound;
     }
 
-    /// @dev Returns the value if it is below the upper bound, otherwise returns the upper bound
-    /// @param value Value to be checked and bounded
-    function _upperBoundValue(int256 value) internal view returns (int256) {
-        return (value > upperBound) ? upperBound : value;
+    /// @notice Price feed description
+    function description() external view override returns (string memory) {
+        return string(abi.encodePacked("Bounded ", AggregatorV3Interface(priceFeed).description(), " price feed"));
     }
 
-    /// @dev Returns the upper-bounded USD price of the token
+    /// @notice Returns the upper-bounded USD price of the token
     function latestRoundData()
         external
         view
         override
-        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
+        returns (uint80, int256 answer, uint256, uint256 updatedAt, uint80)
     {
-        (roundId, answer, startedAt, updatedAt, answeredInRound) = priceFeed.latestRoundData(); // F:[OYPF-4]
+        (answer, updatedAt) = _getValidatedPrice(priceFeed, stalenessPeriod, skipCheck);
+        return (0, _upperBoundValue(answer), 0, updatedAt, 0);
+    }
 
-        answer = _upperBoundValue(answer);
+    /// @dev Upper-bounds given value
+    function _upperBoundValue(int256 value) internal view returns (int256) {
+        return (value > upperBound) ? upperBound : value;
     }
 
-    /// @dev Returns the current phase's aggregator address
     function aggregator() external view returns (address) {
         return ChainlinkReadableAggregator(address(priceFeed)).aggregator();
     }
 
-    /// @dev Returns a phase aggregator by index
     function phaseAggregators(uint16 idx) external view returns (AggregatorV2V3Interface) {
         return ChainlinkReadableAggregator(address(priceFeed)).phaseAggregators(idx);
     }