@pendle/core-v2 6.3.0 → 6.3.1

package/contracts/oracles/PtYtLpOracle/PendleLpOracleLib.sol

@@ -10,8 +10,8 @@ library PendleLpOracleLib {
     using MarketMathCore for MarketState;
 
     /**
-      * This function returns the approximated twap rate LP/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 function returns the approximated twap rate LP/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
      * @param market market to get rate from
      * @param duration twap duration
      */
@@ -26,8 +26,8 @@ library PendleLpOracleLib {
     }
 
     /**
-      * This function returns the approximated twap rate LP/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 function returns the approximated twap rate LP/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
      * @param market market to get rate from
      * @param duration twap duration
      */
@@ -41,11 +41,11 @@ library PendleLpOracleLib {
         }
     }
 
-    function _getLpToAssetRateRaw(
-        IPMarket market,
-        uint32 duration,
-        uint256 pyIndex
-    ) private view returns (uint256 lpToAssetRateRaw) {
+    function _getLpToAssetRateRaw(IPMarket market, uint32 duration, uint256 pyIndex)
+        private
+        view
+        returns (uint256 lpToAssetRateRaw)
+    {
         _checkMarketReentrancy(market);
         MarketState memory state = market.readState(address(0));
 
@@ -59,24 +59,21 @@ library PendleLpOracleLib {
             (int256 rateOracle, int256 rateHypTrade) = _getPtRatesRaw(market, state, duration);
             int256 cParam = LogExpMath.exp(comp.rateScalar.mulDown((rateOracle - comp.rateAnchor)));
 
-            int256 tradeSize = (cParam.mulDown(comp.totalAsset) - state.totalPt).divDown(
-                PMath.IONE + cParam.divDown(rateHypTrade)
-            );
+            int256 tradeSize =
+                (cParam.mulDown(comp.totalAsset) - state.totalPt).divDown(PMath.IONE + cParam.divDown(rateHypTrade));
 
             totalHypotheticalAsset =
-                comp.totalAsset -
-                tradeSize.divDown(rateHypTrade) +
-                (state.totalPt + tradeSize).divDown(rateOracle);
+                comp.totalAsset - tradeSize.divDown(rateHypTrade) + (state.totalPt + tradeSize).divDown(rateOracle);
         }
 
         lpToAssetRateRaw = totalHypotheticalAsset.divDown(state.totalLp).Uint();
     }
 
-    function _getPtRatesRaw(
-        IPMarket market,
-        MarketState memory state,
-        uint32 duration
-    ) private view returns (int256 rateOracle, int256 rateHypTrade) {
+    function _getPtRatesRaw(IPMarket market, MarketState memory state, uint32 duration)
+        private
+        view
+        returns (int256 rateOracle, int256 rateHypTrade)
+    {
         uint256 lnImpliedRate = market.getMarketLnImpliedRate(duration);
         uint256 timeToExpiry = state.expiry - block.timestamp;
         rateOracle = MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry);

package/contracts/oracles/PtYtLpOracle/PendlePYLpOracle.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "./PendlePYOracleLib.sol";
-import "./PendleLpOracleLib.sol";
-import "../../interfaces/IPPYLpOracle.sol";
 import "../../core/libraries/BoringOwnableUpgradeableV2.sol";
+import "../../interfaces/IPPYLpOracle.sol";
+import "./PendleLpOracleLib.sol";
+import "./PendlePYOracleLib.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,38 +78,34 @@ 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,18 +1,19 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../../interfaces/IPMarket.sol";
 import "../../core/libraries/math/PMath.sol";
+import "../../interfaces/IPMarket.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
      */
@@ -27,7 +28,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
      */
@@ -80,7 +81,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();
@@ -94,7 +95,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,9 +68,12 @@ 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();
     }
 
@@ -120,14 +123,15 @@ 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 "./PendleChainlinkOracle.sol";
-import "./PendleChainlinkOracleWithQuote.sol";
 import "../../../interfaces/IPChainlinkOracleFactory.sol";
 import "../../../interfaces/IPPYLpOracle.sol";
+import "./PendleChainlinkOracle.sol";
+import "./PendleChainlinkOracleWithQuote.sol";
 
 contract PendleChainlinkOracleFactory is IPChainlinkOracleFactory {
     error OracleAlreadyExists();
@@ -28,11 +28,10 @@ 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();
 
@@ -66,11 +65,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)];
     }
 
@@ -83,11 +82,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));
     }
 
@@ -105,12 +104,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,12 +13,9 @@ 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());
     }
@@ -39,7 +36,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,12 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../../interfaces/IPPYLpOracle.sol";
-import "../../../interfaces/IPMarket.sol";
 import "../../../core/libraries/math/PMath.sol";
+import "../../../interfaces/IPMarket.sol";
+import "../../../interfaces/IPPYLpOracle.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
@@ -37,7 +39,8 @@ 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();
@@ -82,15 +85,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,12 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../../interfaces/IPPYLpOracle.sol";
-import "../../../interfaces/IPMarket.sol";
 import "../../../core/libraries/math/PMath.sol";
+import "../../../interfaces/IPMarket.sol";
+import "../../../interfaces/IPPYLpOracle.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
@@ -37,7 +39,8 @@ 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();
@@ -82,15 +85,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,11 +22,12 @@ 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 {PendleLinearDiscountOracleWrapper} from "./PendleLinearDiscountOracleWrapper.sol";
 import {PendleSparkLinearDiscountOracleFactory} from "../internal/PendleSparkLinearDiscountOracleFactory.sol";
+import {PendleLinearDiscountOracleWrapper} from "./PendleLinearDiscountOracleWrapper.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 {PendleSparkLinearDiscountOracle} from "./PendleSparkLinearDiscountOracle.sol";
-import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPMarket.sol";
+import "../../interfaces/IPPrincipalToken.sol";
+import {PendleSparkLinearDiscountOracle} from "./PendleSparkLinearDiscountOracle.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;