@pendle/core-v2 6.3.1 → 6.3.2-pendle-merkle-transfer

package/contracts/oracles/PtYtLpOracle/PendlePYLpOracle.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
-import "../../interfaces/IPPYLpOracle.sol";
-import "./PendleLpOracleLib.sol";
 import "./PendlePYOracleLib.sol";
+import "./PendleLpOracleLib.sol";
+import "../../interfaces/IPPYLpOracle.sol";
+import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
 
 // This is a pre-deployed version of PendlePtOracleLib & PendleLpOracleLib with additional utility functions.
-// Use of this contract rather than direct library integration resulting in a smaller bytecode size and simpler
-// structure but slightly higher gas usage (~ 4000 gas, 2 external calls & 1 cold code load)
+// Use of this contract rather than direct library integration resulting in a smaller bytecode size and simpler structure
+// but slightly higher gas usage (~ 4000 gas, 2 external calls & 1 cold code load)
 contract PendlePYLpOracle is BoringOwnableUpgradeableV2, IPPYLpOracle {
     using PendlePYOracleLib for IPMarket;
     using PendleLpOracleLib for IPMarket;
@@ -78,34 +78,38 @@ contract PendlePYLpOracle is BoringOwnableUpgradeableV2, IPPYLpOracle {
      * A check function for the cardinality status of the market
      * @param market PendleMarket address
      * @param duration twap duration
-     * @return increaseCardinalityRequired a boolean indicates whether the cardinality should be increased to serve the
-     * duration
+     * @return increaseCardinalityRequired a boolean indicates whether the cardinality should be increased to serve the duration
      * @return cardinalityRequired the amount of cardinality required for the twap duration
      */
-    function getOracleState(address market, uint32 duration)
+    function getOracleState(
+        address market,
+        uint32 duration
+    )
         external
         view
         returns (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied)
     {
-        (,,, uint16 observationIndex, uint16 observationCardinality, uint16 cardinalityReserved) =
-            IPMarket(market)._storage();
+        (, , , uint16 observationIndex, uint16 observationCardinality, uint16 cardinalityReserved) = IPMarket(market)
+            ._storage();
 
         // checkIncreaseCardinalityRequired
         cardinalityRequired = _calcCardinalityRequiredRequired(duration);
         increaseCardinalityRequired = cardinalityReserved < cardinalityRequired;
 
         // check oldestObservationSatisfied
-        (uint32 oldestTimestamp,, bool initialized) =
-            IPMarket(market).observations((observationIndex + 1) % observationCardinality);
+        (uint32 oldestTimestamp, , bool initialized) = IPMarket(market).observations(
+            (observationIndex + 1) % observationCardinality
+        );
         if (!initialized) {
-            (oldestTimestamp,,) = IPMarket(market).observations(0);
+            (oldestTimestamp, , ) = IPMarket(market).observations(0);
         }
         oldestObservationSatisfied = oldestTimestamp < block.timestamp - duration;
     }
 
     function _calcCardinalityRequiredRequired(uint32 duration) internal view returns (uint16) {
-        uint32 cardinalityRequired =
-            (duration * BLOCK_CYCLE_DENOMINATOR + blockCycleNumerator - 1) / blockCycleNumerator + 1;
+        uint32 cardinalityRequired = (duration * BLOCK_CYCLE_DENOMINATOR + blockCycleNumerator - 1) /
+            blockCycleNumerator +
+            1;
         if (cardinalityRequired > type(uint16).max) {
             revert TwapDurationTooLarge(duration, cardinalityRequired);
         }

package/contracts/oracles/PtYtLpOracle/PendlePYOracleLib.sol

@@ -1,19 +1,18 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../../core/libraries/math/PMath.sol";
 import "../../interfaces/IPMarket.sol";
+import "../../core/libraries/math/PMath.sol";
 
 // This library can & should be integrated directly for optimal gas usage.
-// If you prefer not to integrate it directly, the PendlePtOracle contract (a pre-deployed version of this contract) can
-// be used.
+// If you prefer not to integrate it directly, the PendlePtOracle contract (a pre-deployed version of this contract) can be used.
 library PendlePYOracleLib {
     using PMath for uint256;
     using PMath for int256;
 
     /**
      * This function returns the twap rate PT/Asset on market, but take into account the current rate of SY
-     *  This is to account for special cases where underlying asset becomes insolvent and has decreasing exchangeRate
+     This is to account for special cases where underlying asset becomes insolvent and has decreasing exchangeRate
      * @param market market to get rate from
      * @param duration twap duration
      */
@@ -28,7 +27,7 @@ library PendlePYOracleLib {
 
     /**
      * This function returns the twap rate YT/Asset on market, but take into account the current rate of SY
-     *  This is to account for special cases where underlying asset becomes insolvent and has decreasing exchangeRate
+     This is to account for special cases where underlying asset becomes insolvent and has decreasing exchangeRate
      * @param market market to get rate from
      * @param duration twap duration
      */
@@ -81,7 +80,7 @@ library PendlePYOracleLib {
     }
 
     function getSYandPYIndexCurrent(IPMarket market) internal view returns (uint256 syIndex, uint256 pyIndex) {
-        (IStandardizedYield SY,, IPYieldToken YT) = market.readTokens();
+        (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
 
         syIndex = SY.exchangeRate();
         uint256 pyIndexStored = YT.pyIndexStored();
@@ -95,7 +94,7 @@ library PendlePYOracleLib {
 
     function getMarketLnImpliedRate(IPMarket market, uint32 duration) internal view returns (uint256) {
         if (duration == 0) {
-            (,, uint96 lnImpliedRate,,,) = IPMarket(market)._storage();
+            (, , uint96 lnImpliedRate, , , ) = IPMarket(market)._storage();
             return uint256(lnImpliedRate);
         }
 

package/contracts/oracles/PtYtLpOracle/chainlink/PendleChainlinkOracle.sol

@@ -68,12 +68,9 @@ contract PendleChainlinkOracle is IPChainlinkOracle {
         answeredInRound = 0;
     }
 
-    function getRoundData(uint80 roundId)
-        external
-        view
-        roundIdIsZero(roundId)
-        returns (uint80, int256, uint256, uint256, uint80)
-    {
+    function getRoundData(
+        uint80 roundId
+    ) external view roundIdIsZero(roundId) returns (uint80, int256, uint256, uint256, uint80) {
         return latestRoundData();
     }
 
@@ -123,15 +120,14 @@ contract PendleChainlinkOracle is IPChainlinkOracle {
         }
     }
 
-    function _readDecimals(address _market, PendleOracleType _oracleType)
-        internal
-        view
-        returns (uint8 _fromDecimals, uint8 _toDecimals)
-    {
-        (IStandardizedYield SY,,) = IPMarket(_market).readTokens();
+    function _readDecimals(
+        address _market,
+        PendleOracleType _oracleType
+    ) internal view returns (uint8 _fromDecimals, uint8 _toDecimals) {
+        (IStandardizedYield SY, , ) = IPMarket(_market).readTokens();
 
         uint8 syDecimals = SY.decimals();
-        (,, uint8 assetDecimals) = SY.assetInfo();
+        (, , uint8 assetDecimals) = SY.assetInfo();
 
         if (_oracleType == PendleOracleType.PT_TO_ASSET) {
             return (assetDecimals, assetDecimals);

package/contracts/oracles/PtYtLpOracle/chainlink/PendleChainlinkOracleFactory.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../../interfaces/IPChainlinkOracleFactory.sol";
-import "../../../interfaces/IPPYLpOracle.sol";
 import "./PendleChainlinkOracle.sol";
 import "./PendleChainlinkOracleWithQuote.sol";
+import "../../../interfaces/IPChainlinkOracleFactory.sol";
+import "../../../interfaces/IPPYLpOracle.sol";
 
 contract PendleChainlinkOracleFactory is IPChainlinkOracleFactory {
     error OracleAlreadyExists();
@@ -28,10 +28,11 @@ contract PendleChainlinkOracleFactory is IPChainlinkOracleFactory {
     //                          CREATE ORACLE
     // =================================================================
 
-    function createOracle(address market, uint32 twapDuration, PendleOracleType baseOracleType)
-        external
-        returns (address oracle)
-    {
+    function createOracle(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType
+    ) external returns (address oracle) {
         bytes32 oracleId = getOracleId(market, twapDuration, baseOracleType);
         if (oracles[oracleId] != address(0)) revert OracleAlreadyExists();
 
@@ -65,11 +66,11 @@ contract PendleChainlinkOracleFactory is IPChainlinkOracleFactory {
     //                          GET ORACLE
     // =================================================================
 
-    function getOracle(address market, uint32 twapDuration, PendleOracleType baseOracleType)
-        public
-        view
-        returns (address)
-    {
+    function getOracle(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType
+    ) public view returns (address) {
         return oracles[getOracleId(market, twapDuration, baseOracleType)];
     }
 
@@ -82,11 +83,11 @@ contract PendleChainlinkOracleFactory is IPChainlinkOracleFactory {
         return oraclesWithQuote[getOracleWithQuoteId(market, twapDuration, baseOracleType, quoteOracle)];
     }
 
-    function getOracleId(address market, uint32 twapDuration, PendleOracleType baseOracleType)
-        public
-        pure
-        returns (bytes32)
-    {
+    function getOracleId(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType
+    ) public pure returns (bytes32) {
         return keccak256(abi.encode(market, twapDuration, baseOracleType));
     }
 
@@ -104,12 +105,12 @@ contract PendleChainlinkOracleFactory is IPChainlinkOracleFactory {
     // =================================================================
 
     function checkMarketOracleState(address market, uint32 twapDuration) public view {
-        (bool increaseCardinalityRequired, uint32 cardinalityRequired, bool oldestObservationSatisfied) =
-            IPPYLpOracle(pyLpOracle).getOracleState(market, twapDuration);
+        (bool increaseCardinalityRequired, uint32 cardinalityRequired, bool oldestObservationSatisfied) = IPPYLpOracle(
+            pyLpOracle
+        ).getOracleState(market, twapDuration);
 
         if (increaseCardinalityRequired) {
-            // call IPMarket(market).increaseObservationsCardinalityNext(cardinalityRequired) then wait for twapDuration
-            // seconds
+            // call IPMarket(market).increaseObservationsCardinalityNext(cardinalityRequired) then wait for twapDuration seconds
             revert OracleIncreaseCardinalityRequired(cardinalityRequired);
         }
         if (!oldestObservationSatisfied) {

package/contracts/oracles/PtYtLpOracle/chainlink/PendleChainlinkOracleWithQuote.sol

@@ -13,9 +13,12 @@ contract PendleChainlinkOracleWithQuote is PendleChainlinkOracle {
     address public immutable quoteOracle;
     int256 public immutable quoteScale;
 
-    constructor(address _market, uint32 _twapDuration, PendleOracleType _baseOracleType, address _quoteOracle)
-        PendleChainlinkOracle(_market, _twapDuration, _baseOracleType)
-    {
+    constructor(
+        address _market,
+        uint32 _twapDuration,
+        PendleOracleType _baseOracleType,
+        address _quoteOracle
+    ) PendleChainlinkOracle(_market, _twapDuration, _baseOracleType) {
         quoteOracle = _quoteOracle;
         quoteScale = PMath.Int(10 ** AggregatorV3Interface(_quoteOracle).decimals());
     }
@@ -36,7 +39,7 @@ contract PendleChainlinkOracleWithQuote is PendleChainlinkOracle {
         override
         returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
     {
-        (, int256 quoteAnswer,, uint256 quoteUpdatedAt,) = AggregatorV3Interface(quoteOracle).latestRoundData();
+        (, int256 quoteAnswer, , uint256 quoteUpdatedAt, ) = AggregatorV3Interface(quoteOracle).latestRoundData();
 
         roundId = 0;
         answer = (_getPendleTokenPrice() * quoteAnswer) / quoteScale;

package/contracts/oracles/PtYtLpOracle/samples/BoringLpSeller.sol

@@ -20,12 +20,12 @@ abstract contract BoringLpSeller {
         uint256 netSyToRedeem;
 
         if (PT.isExpired()) {
-            (uint256 netSyRemoved,) = IPMarket(market).burn(address(SY), address(YT), netLpIn);
+            (uint256 netSyRemoved, ) = IPMarket(market).burn(address(SY), address(YT), netLpIn);
             uint256 netSyFromPt = YT.redeemPY(address(SY));
             netSyToRedeem = netSyRemoved + netSyFromPt;
         } else {
             (uint256 netSyRemoved, uint256 netPtRemoved) = IPMarket(market).burn(address(SY), market, netLpIn);
-            (uint256 netSySwappedOut,) = IPMarket(market).swapExactPtForSy(address(SY), netPtRemoved, EMPTY_BYTES);
+            (uint256 netSySwappedOut, ) = IPMarket(market).swapExactPtForSy(address(SY), netPtRemoved, EMPTY_BYTES);
             netSyToRedeem = netSyRemoved + netSySwappedOut;
         }
 

package/contracts/oracles/PtYtLpOracle/samples/BoringPYUsdChainlinkAssetOracle.sol

@@ -1,14 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../../core/libraries/math/PMath.sol";
-import "../../../interfaces/IPMarket.sol";
 import "../../../interfaces/IPPYLpOracle.sol";
+import "../../../interfaces/IPMarket.sol";
+import "../../../core/libraries/math/PMath.sol";
 import "../PendleLpOracleLib.sol";
 
-import {
-    AggregatorV2V3Interface as IChainlinkAggregator
-} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
 
 /**
  * @notice The returned price from this contract is multiplied by the default USD price of the
@@ -39,8 +37,7 @@ contract BoringPYUsdChainlinkAssetOracle {
         pyLpOracle = _pyLpOracle;
 
         /**
-         * @notice All pricing functions in this contract should only be used after checkOracleState() is ran
-         * successfully without reverting.
+         * @notice All pricing functions in this contract should only be used after checkOracleState() is ran successfully without reverting.
          * This equals to calling checkOracleState() in your oracle constructor.
          */
         // checkOracleState();
@@ -85,15 +82,15 @@ contract BoringPYUsdChainlinkAssetOracle {
     error IncreaseCardinalityRequired(uint16 cardinalityRequired);
     error AdditionalWaitRequired(uint32 duration);
 
-    /// @notice Call only once for each (market, duration). Once successful, it's permanently valid (also for any
-    /// shorter duration).
+    /// @notice Call only once for each (market, duration). Once successful, it's permanently valid (also for any shorter duration).
     function checkOracleState() external view {
-        (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied) =
-            IPPYLpOracle(pyLpOracle).getOracleState(market, twapDuration);
+        (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied) = IPPYLpOracle(
+            pyLpOracle
+        ).getOracleState(market, twapDuration);
 
         if (increaseCardinalityRequired) {
-            // It's required to call IPMarket(market).increaseObservationsCardinalityNext(cardinalityRequired) and wait
-            // for at least the twapDuration, to allow data population.
+            // It's required to call IPMarket(market).increaseObservationsCardinalityNext(cardinalityRequired) and wait for
+            // at least the twapDuration, to allow data population.
             revert IncreaseCardinalityRequired(cardinalityRequired);
         }
 

package/contracts/oracles/PtYtLpOracle/samples/BoringPYUsdChainlinkSYOracle.sol

@@ -1,14 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../../core/libraries/math/PMath.sol";
-import "../../../interfaces/IPMarket.sol";
 import "../../../interfaces/IPPYLpOracle.sol";
+import "../../../interfaces/IPMarket.sol";
+import "../../../core/libraries/math/PMath.sol";
 import "../PendleLpOracleLib.sol";
 
-import {
-    AggregatorV2V3Interface as IChainlinkAggregator
-} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
 
 /**
  * @notice The returned price from this contract is multiplied by the default USD price of the
@@ -39,8 +37,7 @@ contract BoringPYUsdChainlinkSYOracle {
         pyLpOracle = _pyLpOracle;
 
         /**
-         * @notice All pricing functions in this contract should only be used after checkOracleState() is ran
-         * successfully without reverting.
+         * @notice All pricing functions in this contract should only be used after checkOracleState() is ran successfully without reverting.
          * This equals to calling checkOracleState() in your oracle constructor.
          */
         // checkOracleState();
@@ -85,15 +82,15 @@ contract BoringPYUsdChainlinkSYOracle {
     error IncreaseCardinalityRequired(uint16 cardinalityRequired);
     error AdditionalWaitRequired(uint32 duration);
 
-    /// @notice Call only once for each (market, duration). Once successful, it's permanently valid (also for any
-    /// shorter duration).
+    /// @notice Call only once for each (market, duration). Once successful, it's permanently valid (also for any shorter duration).
     function checkOracleState() external view {
-        (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied) =
-            IPPYLpOracle(pyLpOracle).getOracleState(market, twapDuration);
+        (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied) = IPPYLpOracle(
+            pyLpOracle
+        ).getOracleState(market, twapDuration);
 
         if (increaseCardinalityRequired) {
-            // It's required to call IPMarket(market).increaseObservationsCardinalityNext(cardinalityRequired) and wait
-            // for at least the twapDuration, to allow data population.
+            // It's required to call IPMarket(market).increaseObservationsCardinalityNext(cardinalityRequired) and wait for
+            // at least the twapDuration, to allow data population.
             revert IncreaseCardinalityRequired(cardinalityRequired);
         }
 

package/contracts/oracles/PtYtLpOracle/samples/BoringPtSeller.sol

@@ -22,12 +22,11 @@ abstract contract BoringPtSeller {
         } else {
             // safeTransfer not required
             PT.transfer(market, netPtIn);
-            (netSyOut,) = IPMarket(market)
-                .swapExactPtForSy(
-                    address(SY), // better gas optimization to transfer SY directly to itself and burn
-                    netPtIn,
-                    EMPTY_BYTES
-                );
+            (netSyOut, ) = IPMarket(market).swapExactPtForSy(
+                address(SY), // better gas optimization to transfer SY directly to itself and burn
+                netPtIn,
+                EMPTY_BYTES
+            );
         }
 
         netTokenOut = SY.redeem(address(this), netSyOut, tokenOut, 0, true);

package/contracts/oracles/StatelessWrapper/PendleSparkLinearDiscountOracleFactoryWrapper.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.19;
 
-import {PendleSparkLinearDiscountOracleFactory} from "../internal/PendleSparkLinearDiscountOracleFactory.sol";
 import {PendleLinearDiscountOracleWrapper} from "./PendleLinearDiscountOracleWrapper.sol";
+import {PendleSparkLinearDiscountOracleFactory} from "../internal/PendleSparkLinearDiscountOracleFactory.sol";
 
 contract PendleSparkLinearDiscountOracleFactoryWrapper {
     event WrapperOracleCreated(address indexed innerOracle, address indexed wrapper);

package/contracts/oracles/internal/PendleSparkLinearDiscountOracleFactory.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: SEE LICENSE IN LICENSE
 pragma solidity ^0.8.19;
 
-import "../../interfaces/IPMarket.sol";
-import "../../interfaces/IPPrincipalToken.sol";
 import {PendleSparkLinearDiscountOracle} from "./PendleSparkLinearDiscountOracle.sol";
+import "../../interfaces/IPPrincipalToken.sol";
+import "../../interfaces/IPMarket.sol";
 
 contract PendleSparkLinearDiscountOracleFactory {
     event OracleCreated(address indexed pt, uint256 baseDiscountPerYear, address oracle);
@@ -14,7 +14,7 @@ contract PendleSparkLinearDiscountOracleFactory {
     }
 
     function createWithMarket(address market, uint256 baseDiscountPerYear) external returns (address) {
-        (, IPPrincipalToken PT,) = IPMarket(market).readTokens();
+        (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
         address res = address(new PendleSparkLinearDiscountOracle(address(PT), baseDiscountPerYear));
         emit OracleCreated(address(PT), baseDiscountPerYear, res);
         return res;