feat(middleware): wsteth oracle with data streams (#898)

* feat: wsteth oracle with data streams

* docs: wstETH

* docs: ETH

Author: fireboss777

src/OracleMiddleware/WstEthOracleMiddleware.sol

@@ -10,7 +10,7 @@ import { OracleMiddlewareWithPyth } from "./OracleMiddlewareWithPyth.sol";
 
 /**
  * @title Middleware Implementation For WstETH Price
- * @notice This contract is used to get the price of wstETH from the eth price oracle.
+ * @notice This contract is used to get the price of wstETH from the ETH price oracle.
  */
 contract WstEthOracleMiddleware is OracleMiddlewareWithPyth {
     /// @notice The wstETH contract.
@@ -35,7 +35,7 @@ contract WstEthOracleMiddleware is OracleMiddlewareWithPyth {
 
     /**
      * @inheritdoc IBaseOracleMiddleware
-     * @notice Parses and validates `data`, returns the corresponding price data by applying eth/wstETH ratio.
+     * @notice Parses and validates `data`, returns the corresponding price data by applying ETH/wstETH ratio.
      * @dev The data format is specific to the middleware and is simply forwarded from the user transaction's calldata.
      * Wsteth price is calculated as follows: `ethPrice x stEthPerToken / 1 ether`.
      * A fee amounting to exactly {validationCost} (with the same `data` and `action`) must be sent or the transaction

src/OracleMiddleware/WstEthOracleMiddlewareWithDataStreams.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.26;
+
+import { IWstETH } from "../interfaces/IWstETH.sol";
+import { IBaseOracleMiddleware } from "../interfaces/OracleMiddleware/IBaseOracleMiddleware.sol";
+import { PriceInfo } from "../interfaces/OracleMiddleware/IOracleMiddlewareTypes.sol";
+import { IUsdnProtocolTypes as Types } from "../interfaces/UsdnProtocol/IUsdnProtocolTypes.sol";
+import { CommonOracleMiddleware } from "./CommonOracleMiddleware.sol";
+import { OracleMiddlewareWithDataStreams } from "./OracleMiddlewareWithDataStreams.sol";
+
+/**
+ * @title Middleware Implementation For WstETH Price With Chainlink Data Streams
+ * @notice This contract is used to get the price of wstETH from the ETH price or the wstETH price directly.
+ */
+contract WstEthOracleMiddlewareWithDataStreams is OracleMiddlewareWithDataStreams {
+    /// @notice The wstETH contract.
+    IWstETH internal immutable _wstETH;
+
+    /**
+     * @param pythContract The address of the Pyth contract.
+     * @param pythFeedId The ETH/USD Pyth price feed ID for the asset.
+     * @param chainlinkPriceFeed The address of the Chainlink ETH/USD price feed.
+     * @param wstETH The address of the wstETH contract.
+     * @param chainlinkTimeElapsedLimit The duration after which a Chainlink price is considered stale.
+     * @param chainlinkProxyVerifierAddress The address of the Chainlink proxy verifier contract.
+     * @param chainlinkStreamId The supported Chainlink wstETH/USD data stream ID.
+     */
+    constructor(
+        address pythContract,
+        bytes32 pythFeedId,
+        address chainlinkPriceFeed,
+        address wstETH,
+        uint256 chainlinkTimeElapsedLimit,
+        address chainlinkProxyVerifierAddress,
+        bytes32 chainlinkStreamId
+    )
+        OracleMiddlewareWithDataStreams(
+            pythContract,
+            pythFeedId,
+            chainlinkPriceFeed,
+            chainlinkTimeElapsedLimit,
+            chainlinkProxyVerifierAddress,
+            chainlinkStreamId
+        )
+    {
+        _wstETH = IWstETH(wstETH);
+    }
+
+    /**
+     * @inheritdoc IBaseOracleMiddleware
+     * @notice Parses and validates `data`, returns the corresponding price data,
+     * applying ETH/wstETH ratio if the price is in ETH.
+     * @dev The data format is specific to the middleware and is simply forwarded from the user transaction's calldata.
+     * If needed, the wstETH price is calculated as follows: `ethPrice x stEthPerToken / 1 ether`.
+     * A fee amounting to exactly {validationCost} (with the same `data` and `action`) must be sent or the transaction
+     * will revert.
+     * @param actionId A unique identifier for the current action. This identifier can be used to link an `Initiate`
+     * call with the corresponding `Validate` call.
+     * @param targetTimestamp The target timestamp for validating the price data. For validation actions, this is the
+     * timestamp of the initiation.
+     * @param action Type of action for which the price is requested. The middleware may use this to alter the
+     * validation of the price or the returned price.
+     * @param data The data to be used to communicate with oracles, the format varies from middleware to middleware and
+     * can be different depending on the action.
+     * @return result_ The price and timestamp as {IOracleMiddlewareTypes.PriceInfo}.
+     */
+    function parseAndValidatePrice(
+        bytes32 actionId,
+        uint128 targetTimestamp,
+        Types.ProtocolAction action,
+        bytes calldata data
+    ) public payable virtual override(IBaseOracleMiddleware, CommonOracleMiddleware) returns (PriceInfo memory) {
+        PriceInfo memory oraclePrice = super.parseAndValidatePrice(actionId, targetTimestamp, action, data);
+
+        if (data.length > 32 && !_isPythData(data)) {
+            // the price is already in wstETH/USD from the Chainlink data stream
+            return oraclePrice;
+        }
+
+        uint256 stEthPerToken = _wstETH.stEthPerToken();
+
+        return PriceInfo({
+            price: oraclePrice.price * stEthPerToken / 1 ether,
+            neutralPrice: oraclePrice.neutralPrice * stEthPerToken / 1 ether,
+            timestamp: oraclePrice.timestamp
+        });
+    }
+}

src/OracleMiddleware/mock/MockWstEthOracleMiddleware.sol

@@ -9,15 +9,15 @@ import { WstEthOracleMiddleware } from "../WstEthOracleMiddleware.sol";
 
 /**
  * @title Contract to apply and return a mocked wstETH price
- * @notice This contract is used to get the price of wsteth by setting up a price or forwarding it to wstethMiddleware
+ * @notice This contract is used to get the price of wstETH by setting up a price or forwarding it to wstethMiddleware
  * @dev This aims at simulating price action. Do not use in production
  */
 contract MockWstEthOracleMiddleware is WstEthOracleMiddleware {
     /// @notice Confidence interval percentage numerator
     uint16 internal _wstethMockedConfBps = 20; // default 0.2% conf
 
     /**
-     * @notice Wsteth mocked price
+     * @notice wstETH mocked price
      * @dev This price will be used if greater than zero
      */
     uint256 internal _wstethMockedPrice;
@@ -42,7 +42,7 @@ contract MockWstEthOracleMiddleware is WstEthOracleMiddleware {
         Types.ProtocolAction action,
         bytes calldata data
     ) public payable override returns (PriceInfo memory price_) {
-        // parse and validate from parent wsteth middleware
+        // parse and validate from parent WstEth middleware
         // this aims to verify pyth price hermes signature in any case
         if (_verifySignature || _wstethMockedPrice == 0) {
             price_ = super.parseAndValidatePrice(actionId, targetTimestamp, action, data);
@@ -75,8 +75,8 @@ contract MockWstEthOracleMiddleware is WstEthOracleMiddleware {
     }
 
     /**
-     * @notice Set Wsteth mocked price
-     * @dev If the new mocked wsteth is greater than zero this will validate this mocked price else this will validate
+     * @notice Set WstEth mocked price
+     * @dev If the new mocked WstEth is greater than zero this will validate this mocked price else this will validate
      * the parent middleware price
      * @param newWstethMockedPrice The mock price to set
      */
@@ -94,12 +94,12 @@ contract MockWstEthOracleMiddleware is WstEthOracleMiddleware {
         _wstethMockedConfBps = newWstethMockedConfPct;
     }
 
-    /// @notice Get current wsteth mocked price
+    /// @notice Get current WstEth mocked price
     function getWstethMockedPrice() external view returns (uint256) {
         return _wstethMockedPrice;
     }
 
-    /// @notice Get current wsteth mocked confidence interval
+    /// @notice Get current WstEth mocked confidence interval
     function getWstethMockedConfBps() external view returns (uint64) {
         return _wstethMockedConfBps;
     }

src/interfaces/IWstETH.sol

@@ -12,7 +12,7 @@ interface IWstETH is IERC20Metadata, IERC20Permit {
      *  - `_stETHAmount` must be non-zero
      *  - msg.sender must approve at least `_stETHAmount` stETH to this contract
      *  - msg.sender must have at least `_stETHAmount` of stETH
-     * User should first approve `_stETHAmount` to the WstETH contract
+     * User should first approve `_stETHAmount` to the wstETH contract
      * @return Amount of wstETH user receives after wrap
      */
     function wrap(uint256 _stETHAmount) external returns (uint256);

test/integration/Middlewares/Oracle/ParseAndValidatePrice.t.sol

@@ -94,7 +94,7 @@ contract TestOracleMiddlewareParseAndValidatePriceRealData is OracleMiddlewareBa
 
     /**
      * @custom:scenario Parse and validate price with chainlink on-chain
-     * @custom:given The price feed is eth/usd for chainlink
+     * @custom:given The price feed is ETH/USD for chainlink
      * @custom:when The protocol action is any targeted action
      * @custom:then The price retrieved by the oracle middleware is the same as the one from chainlink on-chain data
      */
@@ -257,7 +257,7 @@ contract TestOracleMiddlewareParseAndValidatePriceRealData is OracleMiddlewareBa
 
     /**
      * @custom:scenario Parse and validate price with chainlink on-chain
-     * @custom:given The price feed is eth/usd for chainlink
+     * @custom:given The price feed is ETH/USD for chainlink
      * @custom:when Protocol action is an `initiateDeposit`
      * @custom:then The price signature is well-decoded
      * @custom:and The price retrieved by the oracle middleware is the same as the one from the chainlink on-chain data

test/integration/Middlewares/WstethOracle/ParseAndValidatePrice.t.sol

@@ -281,7 +281,7 @@ contract TestWstethMiddlewareParseAndValidatePriceRealData is WstethIntegrationF
                 assertApproxEqAbs(middlewarePrice.timestamp, pythWstethTimestamp, 5, "Wrong similar timestamp");
 
                 // should obtain a short different price between the pyth wsteth price feed
-                // and the pyth eth price feed adjusted with ratio.
+                // and the pyth ETH price feed adjusted with ratio.
                 // We are ok with a delta below the pyth wsteth confidence.
                 assertApproxEqAbs(
                     middlewarePrice.price,

test/integration/UsdnProtocol/RebalancerInitiateClosePosition.t.sol

@@ -245,7 +245,7 @@ contract TestRebalancerInitiateClosePosition is
         protocol.setExpoImbalanceLimits(0, 0, 0, 0, 0, 0);
 
         skip(1 hours);
-        // put the eth price a bit higher to avoid liquidating existing position
+        // put the ETH price a bit higher to avoid liquidating existing position
         wstEthPrice = _setOraclePrices(wstEthPrice * 15 / 10);
 
         vm.startPrank(user);

test/unit/LiquidationRewardsManager/GetLiquidationRewardsWusdn.t.sol

@@ -18,7 +18,7 @@ contract TestLiquidationRewardsManagerWusdnGetLiquidationRewards is BaseFixture
     LiquidationRewardsManagerWusdn internal liquidationRewardsManager;
     ILiquidationRewardsManagerErrorsEventsTypes.RewardsParameters rewardsParameters;
 
-    uint256 internal constant CURRENT_PRICE = 1 ether / 1000; // 0.001 eth/wUsdn
+    uint256 internal constant CURRENT_PRICE = 1 ether / 1000; // 0.001 ETH/WUSDN
 
     Types.LiqTickInfo[] internal _singleLiquidatedTick;
     Types.LiqTickInfo[] internal _liquidatedTicksEmpty;
@@ -41,8 +41,8 @@ contract TestLiquidationRewardsManagerWusdnGetLiquidationRewards is BaseFixture
                 totalPositions: 1,
                 totalExpo: 10_000 ether,
                 remainingCollateral: -200 ether,
-                tickPrice: 1.02 ether / 1000, // 0.00102 eth/wUsdn
-                priceWithoutPenalty: 1 ether / 1000 // 0.001 eth/wUsdn
+                tickPrice: 1.02 ether / 1000, // 0.00102 ETH/wUsdn
+                priceWithoutPenalty: 1 ether / 1000 // 0.001 ETH/wUsdn
              })
         );
     }

test/unit/Middlewares/WstethOracle/WstethOracleWithDataStreams/ParseAndValidate.t.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity 0.8.26;
+
+import { FixedPointMathLib } from "solady/src/utils/FixedPointMathLib.sol";
+
+import { MOCK_PYTH_DATA } from "../../utils/Constants.sol";
+import { WstethOracleWithDataStreamsBaseFixture } from "../../utils/Fixtures.sol";
+
+import { PriceInfo } from "../../../../../src/interfaces/OracleMiddleware/IOracleMiddlewareTypes.sol";
+import { IUsdnProtocolTypes as Types } from "../../../../../src/interfaces/UsdnProtocol/IUsdnProtocolTypes.sol";
+
+/**
+ * @custom:feature The `parseAndValidatePrice` function of the `WstethOracleWithDataStreams`
+ * @custom:background A deployed `WstethOracleWithDataStreams` contract.
+ */
+contract TestWstethOracleParseAndValidatePrice is WstethOracleWithDataStreamsBaseFixture {
+    uint256 internal oracleFee;
+
+    function setUp() public override {
+        super.setUp();
+    }
+
+    /**
+     * @custom:scenario Tests the `parseAndValidatePrice` with a payload from a Chainlink data stream.
+     * @custom:when The function is called.
+     * @custom:then The returned price data must be equal to the data from the Chainlink data stream report.
+     */
+    function test_parseAndValidatePriceWithDataStreams() public {
+        oracleFee = oracleMiddleware.validationCost(payload, Types.ProtocolAction.InitiateOpenPosition);
+
+        PriceInfo memory price = oracleMiddleware.parseAndValidatePrice{ value: oracleFee }(
+            "", 0, Types.ProtocolAction.InitiateOpenPosition, payload
+        );
+
+        assertEq(price.price, uint192(report.price), "The returned price must be equal to the report price");
+        assertEq(
+            price.neutralPrice, uint192(report.price), "The returned neutral price must be equal to the report price"
+        );
+        assertEq(
+            price.timestamp,
+            uint128(report.observationsTimestamp),
+            "The returned timestamp must be equal to the report observationsTimestamp"
+        );
+    }
+
+    /**
+     * @custom:scenario Tests the `parseAndValidatePrice` with a price data from a Pyth price feed.
+     * @custom:when The function is called.
+     * @custom:then The returned price data must be equal to the adjusted data from the Pyth price feed.
+     */
+    function test_parseAndValidatePriceWithPyth() public {
+        oracleFee = oracleMiddleware.validationCost(MOCK_PYTH_DATA, Types.ProtocolAction.Liquidation);
+
+        PriceInfo memory price = oracleMiddleware.parseAndValidatePrice{ value: oracleFee }(
+            "", 0, Types.ProtocolAction.Liquidation, MOCK_PYTH_DATA
+        );
+        uint256 adjustedWstethPythPrice = uint256(uint64(mockPyth.price()))
+            * 10 ** (oracleMiddleware.getDecimals() - FixedPointMathLib.abs(mockPyth.expo())) * wsteth.stEthPerToken()
+            / 1 ether;
+
+        assertEq(price.price, adjustedWstethPythPrice, "The returned price must be equal to the adjusted Pyth price");
+        assertEq(
+            price.neutralPrice,
+            adjustedWstethPythPrice,
+            "The returned neutral price must be equal to the adjusted Pyth price"
+        );
+        assertEq(
+            price.timestamp, mockPyth.lastPublishTime(), "The returned timestamp must be equal to the Pyth timestamp"
+        );
+    }
+
+    /**
+     * @custom:scenario Tests the `parseAndValidatePrice` without data.
+     * @custom:when The function is called.
+     * @custom:then The returned price data must be equal to the adjusted data from the latest roundId of the Chainlink
+     * data feeds.
+     */
+    function test_parseAndValidatePriceWithDataFeedsEmptyData() public {
+        oracleFee = oracleMiddleware.validationCost("", Types.ProtocolAction.InitiateOpenPosition);
+
+        (, int256 answer,, uint256 updatedAt,) = mockChainlinkOnChain.latestRoundData();
+        PriceInfo memory price = oracleMiddleware.parseAndValidatePrice{ value: oracleFee }(
+            "", 0, Types.ProtocolAction.InitiateOpenPosition, ""
+        );
+        uint256 adjustedWstethDataFeedsPrice = uint256(answer)
+            * 10 ** (oracleMiddleware.getDecimals() - mockChainlinkOnChain.decimals()) * wsteth.stEthPerToken() / 1 ether;
+        assertEq(
+            price.price,
+            adjustedWstethDataFeedsPrice,
+            "The returned price must be equal to the adjusted latest roundId adjusted price"
+        );
+        assertEq(
+            price.neutralPrice,
+            adjustedWstethDataFeedsPrice,
+            "The returned neutral price must be equal to the adjusted latest roundId adjusted price"
+        );
+        assertEq(price.timestamp, updatedAt, "The returned timestamp must be equal to the latest roundId timestamp");
+    }
+
+    /**
+     * @custom:scenario Tests the `parseAndValidatePrice` with a specified roundId data from a Chainlink data feed.
+     * @custom:when The function is called.
+     * @custom:then The returned price data must be equal to the adjusted data from the specified
+     * roundId of the Chainlink data feeds.
+     */
+    function test_parseAndValidatePriceWithDataFeedsRoundIdData() public {
+        uint256 lowLatencyDelay = oracleMiddleware.getLowLatencyDelay();
+        skip(lowLatencyDelay + 1);
+
+        uint80 roundId = 1;
+        (,,, uint256 previousRoundIdTimestamp,) = mockChainlinkOnChain.getRoundData(roundId - 1);
+
+        mockChainlinkOnChain.setRoundTimestamp(
+            roundId, previousRoundIdTimestamp + oracleMiddleware.getLowLatencyDelay() + 1
+        );
+        oracleFee = oracleMiddleware.validationCost(abi.encode(roundId), Types.ProtocolAction.ValidateOpenPosition);
+
+        (, int256 answer,, uint256 updatedAt,) = mockChainlinkOnChain.getRoundData(roundId);
+        PriceInfo memory price = oracleMiddleware.parseAndValidatePrice{ value: oracleFee }(
+            "", uint128(previousRoundIdTimestamp), Types.ProtocolAction.ValidateOpenPosition, abi.encode(roundId)
+        );
+        uint256 adjustedWstethDataFeedsPrice = uint256(answer)
+            * 10 ** (oracleMiddleware.getDecimals() - mockChainlinkOnChain.decimals()) * wsteth.stEthPerToken() / 1 ether;
+
+        assertEq(
+            price.price,
+            adjustedWstethDataFeedsPrice,
+            "The returned price must be equal to the specified roundId adjusted price"
+        );
+        assertEq(
+            price.neutralPrice,
+            adjustedWstethDataFeedsPrice,
+            "The returned neutral price must be equal to the specified roundId adjusted price"
+        );
+        assertEq(price.timestamp, updatedAt, "The returned timestamp must be equal to specified roundId timestamp");
+    }
+}

test/unit/Middlewares/utils/Constants.sol

@@ -18,6 +18,6 @@ uint48 constant REDSTONE_ETH_TIMESTAMP = 1_717_684_100;
 bytes constant REDSTONE_ETH_DATA =
     hex"00000000000000004554480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000595cd5e4d5018fedf35ba00000002000000196c710f6ee933d08f86e99def2c6c64684808705691289aef63503f54bf8b9202d21cde463aeef0830cea7795a03cbebd92d51a7eb13134129fc82e3cac26e2e1b4554480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000595cd4a962018fedf35ba0000000200000015bd816c1b59f67af5990b834c572b1e403a6a7ffcbc78e13510a0b7de750e02a4d0c641de3797cc2225fd6064f7445d0d77808ec620bd96f84e298bea049ac2f1c4554480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000595cd5e4d5018fedf35ba000000020000001ab05ff923cef4ea56a1b77af4ea5f2700cab64628b44aaf460b7d9950dff4c1e74da926233820b52b78644fce28a97dc7b88c25bbe1dbd173ff69e8e3c1dcef01b0003000000000002ed57011e0000";
 
-uint256 constant STREAM_ETH_PRICE = 2000 ether;
+uint256 constant STREAM_WSTETH_PRICE = 2300 ether;
 bytes32 constant EMPTY_STREAM_V3 = 0x0003000000000000000000000000000000000000000000000000000000000000;
 bytes32 constant EMPTY_STREAM_V4 = 0x0004000000000000000000000000000000000000000000000000000000000000;