Merge pull request #37 from Gearbox-protocol/pyth-oracle

feat: pyth oracle

Author: 0xmikko

.gitignore

@@ -3,3 +3,4 @@
 .DS_Store
 cache
 .env
+*.log

contracts/oracles/LPPriceFeed.sol

@@ -10,9 +10,6 @@ import {ACLNonReentrantTrait} from "@gearbox-protocol/core-v3/contracts/traits/A
 import {PriceFeedValidationTrait} from "@gearbox-protocol/core-v3/contracts/traits/PriceFeedValidationTrait.sol";
 import {IPriceOracleV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IPriceOracleV3.sol";
 import {IUpdatablePriceFeed} from "@gearbox-protocol/core-v2/contracts/interfaces/IPriceFeed.sol";
-import {
-    IAddressProviderV3, AP_PRICE_ORACLE
-} from "@gearbox-protocol/core-v3/contracts/interfaces/IAddressProviderV3.sol";
 
 /// @dev Window size in bps, used to compute upper bound given lower bound
 uint256 constant WINDOW_SIZE = 200;
@@ -54,17 +51,19 @@ abstract contract LPPriceFeed is ILPPriceFeed, ACLNonReentrantTrait, PriceFeedVa
     uint40 public override lastBoundsUpdate;
 
     /// @notice Constructor
-    /// @param _addressProvider Address provider contract address
+    /// @param _acl Address of the ACL contract
+    /// @param _priceOracle Address of the price oracle
     /// @param _lpToken  LP token for which the prices are computed
     /// @param _lpContract LP contract (can be different from LP token)
     /// @dev Derived price feeds must call `_setLimiter` in their constructor after
     ///      initializing all state variables needed for exchange rate calculation
-    constructor(address _addressProvider, address _lpToken, address _lpContract)
-        ACLNonReentrantTrait(_addressProvider) // U:[LPPF-1]
+    constructor(address _acl, address _priceOracle, address _lpToken, address _lpContract)
+        ACLNonReentrantTrait(_acl) // U:[LPPF-1]
+        nonZeroAddress(_priceOracle) // U:[LPPF-1]
         nonZeroAddress(_lpToken) // U:[LPPF-1]
         nonZeroAddress(_lpContract) // U:[LPPF-1]
     {
-        priceOracle = IAddressProviderV3(_addressProvider).getAddressOrRevert(AP_PRICE_ORACLE, 3_00); // U:[LPPF-1]
+        priceOracle = _priceOracle; // U:[LPPF-1]
         lpToken = _lpToken; // U:[LPPF-1]
         lpContract = _lpContract; // U:[LPPF-1]
     }
@@ -149,13 +148,13 @@ abstract contract LPPriceFeed is ILPPriceFeed, ACLNonReentrantTrait, PriceFeedVa
         if (block.timestamp < lastBoundsUpdate + UPDATE_BOUNDS_COOLDOWN) revert UpdateBoundsBeforeCooldownException(); // U:[LPPF-7]
         lastBoundsUpdate = uint40(block.timestamp); // U:[LPPF-7]
 
-        address reserveFeed = IPriceOracleV3(priceOracle).priceFeedsRaw({token: lpToken, reserve: true}); // U:[LPPF-7]
+        address reserveFeed = IPriceOracleV3(priceOracle).reservePriceFeeds({token: lpToken}); // U:[LPPF-7]
         if (reserveFeed == address(this)) revert ReserveFeedMustNotBeSelfException(); // U:[LPPF-7]
         try IUpdatablePriceFeed(reserveFeed).updatable() returns (bool updatable) {
             if (updatable) IUpdatablePriceFeed(reserveFeed).updatePrice(updateData); // U:[LPPF-7]
         } catch {}
 
-        uint256 reserveAnswer = IPriceOracleV3(priceOracle).getPriceRaw({token: lpToken, reserve: true}); // U:[LPPF-7]
+        uint256 reserveAnswer = IPriceOracleV3(priceOracle).getReservePrice({token: lpToken}); // U:[LPPF-7]
         uint256 reserveExchangeRate = uint256(reserveAnswer * getScale() / uint256(getAggregatePrice())); // U:[LPPF-7]
 
         _ensureValueInBounds(reserveExchangeRate, lowerBound); // U:[LPPF-7]

contracts/oracles/SingleAssetLPPriceFeed.sol

@@ -15,13 +15,14 @@ abstract contract SingleAssetLPPriceFeed is LPPriceFeed {
     bool public immutable skipCheck;
 
     constructor(
-        address addressProvider,
+        address _acl,
+        address _priceOracle,
         address _lpToken,
         address _lpContract,
         address _priceFeed,
         uint32 _stalenessPeriod
     )
-        LPPriceFeed(addressProvider, _lpToken, _lpContract) // U:[SAPF-1]
+        LPPriceFeed(_acl, _priceOracle, _lpToken, _lpContract) // U:[SAPF-1]
         nonZeroAddress(_priceFeed) // U:[SAPF-1]
     {
         priceFeed = _priceFeed; // U:[SAPF-1]

contracts/oracles/aave/WrappedAaveV2PriceFeed.sol

@@ -14,13 +14,14 @@ contract WrappedAaveV2PriceFeed is SingleAssetLPPriceFeed {
     PriceFeedType public constant override priceFeedType = PriceFeedType.WRAPPED_AAVE_V2_ORACLE;
 
     constructor(
-        address addressProvider,
+        address _acl,
+        address _priceOracle,
         uint256 lowerBound,
         address _waToken,
         address _priceFeed,
         uint32 _stalenessPeriod
     )
-        SingleAssetLPPriceFeed(addressProvider, _waToken, _waToken, _priceFeed, _stalenessPeriod) // U:[AAVE-1]
+        SingleAssetLPPriceFeed(_acl, _priceOracle, _waToken, _waToken, _priceFeed, _stalenessPeriod) // U:[AAVE-1]
     {
         _setLimiter(lowerBound); // U:[AAVE-1]
     }

contracts/oracles/balancer/BPTStablePriceFeed.sol

@@ -38,12 +38,13 @@ contract BPTStablePriceFeed is LPPriceFeed {
     bool public immutable skipCheck4;
 
     constructor(
-        address addressProvider,
+        address _acl,
+        address _priceOracle,
         uint256 lowerBound,
         address _balancerPool,
         PriceFeedParams[5] memory priceFeeds
     )
-        LPPriceFeed(addressProvider, _balancerPool, _balancerPool) // U:[BAL-S-1]
+        LPPriceFeed(_acl, _priceOracle, _balancerPool, _balancerPool) // U:[BAL-S-1]
         nonZeroAddress(priceFeeds[0].priceFeed) // U:[BAL-S-2]
         nonZeroAddress(priceFeeds[1].priceFeed) // U:[BAL-S-2]
     {

contracts/oracles/balancer/BPTWeightedPriceFeed.sol

@@ -98,13 +98,14 @@ contract BPTWeightedPriceFeed is LPPriceFeed {
     uint256 immutable scale7;
 
     constructor(
-        address addressProvider,
+        address _acl,
+        address _priceOracle,
         uint256 lowerBound,
         address _vault,
         address _pool,
         PriceFeedParams[] memory priceFeeds
     )
-        LPPriceFeed(addressProvider, _pool, _pool) // U:[BAL-W-1]
+        LPPriceFeed(_acl, _priceOracle, _pool, _pool) // U:[BAL-W-1]
         nonZeroAddress(_vault) // U:[BAL-W-1]
         nonZeroAddress(priceFeeds[0].priceFeed) // U:[BAL-W-2]
         nonZeroAddress(priceFeeds[1].priceFeed) // U:[BAL-W-2]

contracts/oracles/compound/CompoundV2PriceFeed.sol

@@ -14,13 +14,14 @@ contract CompoundV2PriceFeed is SingleAssetLPPriceFeed {
     PriceFeedType public constant override priceFeedType = PriceFeedType.COMPOUND_V2_ORACLE;
 
     constructor(
-        address addressProvider,
+        address _acl,
+        address _priceOracle,
         uint256 lowerBound,
         address _cToken,
         address _priceFeed,
         uint32 _stalenessPeriod
     )
-        SingleAssetLPPriceFeed(addressProvider, _cToken, _cToken, _priceFeed, _stalenessPeriod) // U:[COMP-1]
+        SingleAssetLPPriceFeed(_acl, _priceOracle, _cToken, _cToken, _priceFeed, _stalenessPeriod) // U:[COMP-1]
     {
         _setLimiter(lowerBound); // U:[COMP-1]
     }

contracts/oracles/curve/CurveCryptoLPPriceFeed.sol

@@ -36,13 +36,14 @@ contract CurveCryptoLPPriceFeed is LPPriceFeed {
     bool public immutable skipCheck2;
 
     constructor(
-        address addressProvider,
+        address _acl,
+        address _priceOracle,
         uint256 lowerBound,
         address _token,
         address _pool,
         PriceFeedParams[3] memory priceFeeds
     )
-        LPPriceFeed(addressProvider, _token, _pool) // U:[CRV-C-1]
+        LPPriceFeed(_acl, _priceOracle, _token, _pool) // U:[CRV-C-1]
         nonZeroAddress(priceFeeds[0].priceFeed) // U:[CRV-C-2]
         nonZeroAddress(priceFeeds[1].priceFeed) // U:[CRV-C-2]
     {

contracts/oracles/curve/CurveStableLPPriceFeed.sol

@@ -35,13 +35,14 @@ contract CurveStableLPPriceFeed is LPPriceFeed {
     bool public immutable skipCheck3;
 
     constructor(
-        address addressProvider,
+        address _acl,
+        address _priceOracle,
         uint256 lowerBound,
         address _token,
         address _pool,
         PriceFeedParams[4] memory priceFeeds
     )
-        LPPriceFeed(addressProvider, _token, _pool) // U:[CRV-S-1]
+        LPPriceFeed(_acl, _priceOracle, _token, _pool) // U:[CRV-S-1]
         nonZeroAddress(priceFeeds[0].priceFeed) // U:[CRV-S-2]
         nonZeroAddress(priceFeeds[1].priceFeed) // U:[CRV-S-2]
     {

contracts/oracles/curve/CurveUSDPriceFeed.sol

@@ -17,14 +17,15 @@ contract CurveUSDPriceFeed is SingleAssetLPPriceFeed {
     PriceFeedType public constant override priceFeedType = PriceFeedType.CURVE_USD_ORACLE;
 
     constructor(
-        address addressProvider,
+        address _acl,
+        address _priceOracle,
         uint256 lowerBound,
         address _crvUSD,
         address _pool,
         address _priceFeed,
         uint32 _stalenessPeriod
     )
-        SingleAssetLPPriceFeed(addressProvider, _crvUSD, _pool, _priceFeed, _stalenessPeriod) // U:[CRV-D-1]
+        SingleAssetLPPriceFeed(_acl, _priceOracle, _crvUSD, _pool, _priceFeed, _stalenessPeriod) // U:[CRV-D-1]
     {
         _setLimiter(lowerBound); // U:[CRV-D-1]
     }