@pendle/core-v2 3.0.0-beta-10 → 3.0.0-beta-12

package/contracts/offchain-helpers/LimitBackendHelper.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.17;
+
+import "../interfaces/IPLimitRouter.sol";
+import "../core/libraries/TokenHelper.sol";
+import "../interfaces/IStandardizedYield.sol";
+import "../interfaces/IWETH.sol";
+import "../core/libraries/Errors.sol";
+import "./BytesLib.sol";
+
+contract LimitBackendHelper is TokenHelper {
+    address private immutable WNATIVE;
+    address private immutable original;
+
+    constructor(address _WNATIVE) {
+        WNATIVE = _WNATIVE;
+        original = address(this);
+    }
+
+    /// @notice vanilla read
+    function readSingleToken(
+        address token,
+        address[] calldata owners,
+        address spender
+    ) public view returns (uint256[] memory balances, uint256[] memory allowances) {
+        balances = new uint256[](owners.length);
+        allowances = new uint256[](owners.length);
+        for (uint256 i = 0; i < owners.length; i++) {
+            balances[i] = IERC20(token).balanceOf(owners[i]);
+            allowances[i] = IERC20(token).allowance(owners[i], spender);
+        }
+    }
+
+    /// @notice auto return balances and allowances the input tokens of the orders, based on type
+    function readMultiTokens(
+        address[] calldata tokens,
+        address[] calldata owners,
+        address spender
+    ) public view returns (uint256[] memory balances, uint256[] memory allowances) {
+        require(tokens.length == owners.length, "Length mismatch");
+        balances = new uint256[](owners.length);
+        allowances = new uint256[](owners.length);
+        for (uint256 i = 0; i < owners.length; i++) {
+            balances[i] = IERC20(tokens[i]).balanceOf(owners[i]);
+            allowances[i] = IERC20(tokens[i]).allowance(owners[i], spender);
+        }
+    }
+
+    /// @notice to be delegatecall from LimitRouter
+    function mintSyFromTokens(
+        address YT,
+        address[] calldata makers,
+        address[] calldata tokens,
+        uint256[] calldata amounts
+    ) external returns (uint256[] memory minted) {
+        uint256 length = makers.length;
+
+        address SY = IPYieldToken(YT).SY();
+        minted = new uint256[](length);
+
+        for (uint256 i = 0; i < length; i++) {
+            (, bytes memory result) = original.delegatecall(
+                abi.encodeWithSignature(
+                    "mintSyFromTokenRevert(address,address,address,uint256)",
+                    makers[i],
+                    SY,
+                    tokens[i],
+                    amounts[i]
+                )
+            );
+            minted[i] = parseMinted(result);
+        }
+    }
+
+    function parseMinted(bytes memory result) internal pure returns (uint256 minted) {
+        if (result.length < 4) return type(uint256).max;
+
+        bytes4 top = bytes4(BytesLib.slice(result, 0, 4));
+        if (top == bytes4(0x1934afc8)) {
+            // selector of SimulationResults
+            (, bytes memory beta) = abi.decode(BytesLib.slice(result, 4, result.length - 4), (bool, bytes));
+            minted = abi.decode(beta, (uint256));
+        } else {
+            minted = type(uint256).max;
+        }
+    }
+
+    function mintSyFromTokenRevert(
+        address maker,
+        address SY,
+        address token,
+        uint256 makingAmount
+    ) public returns (uint256) {
+        _transferIn(token, maker, makingAmount);
+        if (token == WNATIVE && !IStandardizedYield(SY).isValidTokenIn(WNATIVE)) {
+            _wrap_unwrap_ETH(WNATIVE, NATIVE, makingAmount);
+            token = NATIVE;
+        }
+        _safeApproveInf(token, SY);
+        uint256 minted = IStandardizedYield(SY).deposit{value: token == NATIVE ? makingAmount : 0}(
+            address(this),
+            token,
+            makingAmount,
+            0
+        );
+        revert Errors.SimulationResults(true, abi.encode(minted));
+    }
+}

package/contracts/offchain-helpers/MarketExchangeRateLib.sol

@@ -11,21 +11,10 @@ library MarketExchangeRateLib {
 
     function getMarketExchangeRate(address market) internal view returns (uint256) {
         MarketState memory state = IPMarket(market).readState(address(0));
-        MarketPreCompute memory comp = state.getMarketPreCompute(
-            _getPYIndexCurrent(market),
-            block.timestamp
-        );
+        MarketPreCompute memory comp = state.getMarketPreCompute(_getPYIndexCurrent(market), block.timestamp);
 
         return
-            MarketMathCore
-                ._getExchangeRate(
-                    state.totalPt,
-                    comp.totalAsset,
-                    comp.rateScalar,
-                    comp.rateAnchor,
-                    0
-                )
-                .Uint();
+            MarketMathCore._getExchangeRate(state.totalPt, comp.totalAsset, comp.rateScalar, comp.rateAnchor, 0).Uint();
     }
 
     function _getPYIndexCurrent(address market) private view returns (PYIndex) {

package/contracts/offchain-helpers/Multicall2.sol

@@ -16,9 +16,7 @@ contract Multicall2 {
         bytes returnData;
     }
 
-    function aggregate(
-        Call[] memory calls
-    ) public returns (uint256 blockNumber, bytes[] memory returnData) {
+    function aggregate(Call[] memory calls) public returns (uint256 blockNumber, bytes[] memory returnData) {
         blockNumber = block.number;
         returnData = new bytes[](calls.length);
         for (uint256 i = 0; i < calls.length; i++) {
@@ -66,10 +64,7 @@ contract Multicall2 {
         blockHash = blockhash(block.number - 1);
     }
 
-    function tryAggregate(
-        bool requireSuccess,
-        Call[] memory calls
-    ) public returns (Result[] memory returnData) {
+    function tryAggregate(bool requireSuccess, Call[] memory calls) public returns (Result[] memory returnData) {
         returnData = new Result[](calls.length);
         for (uint256 i = 0; i < calls.length; i++) {
             (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);

package/contracts/offchain-helpers/PendleMulticallV1.sol

@@ -15,7 +15,7 @@ contract PendleMulticallV1 {
     function aggregate(Call[] calldata calls) public payable virtual {
         uint256 length = calls.length;
         Call calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call(call.callData);
@@ -31,15 +31,15 @@ contract PendleMulticallV1 {
         }
     }
 
-    function tryAggregate(bool requireSuccess, uint256 gasLimit, Call[] calldata calls)
-        public
-        payable
-        returns (Result[] memory returnData)
-    {
+    function tryAggregate(
+        bool requireSuccess,
+        uint256 gasLimit,
+        Call[] calldata calls
+    ) public payable returns (Result[] memory returnData) {
         uint256 length = calls.length;
         returnData = new Result[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call{gas: gasLimit}(calls[i].callData);

package/contracts/offchain-helpers/PendleMulticallV2.sol

@@ -17,7 +17,7 @@ contract PendleMulticallV2 {
     function aggregate(Call[] calldata calls) public payable virtual {
         uint256 length = calls.length;
         Call calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call(call.callData);
@@ -33,15 +33,15 @@ contract PendleMulticallV2 {
         }
     }
 
-    function tryAggregate(bool requireSuccess, uint256 gasLimit, Call[] calldata calls)
-        public
-        payable
-        returns (Result[] memory returnData)
-    {
+    function tryAggregate(
+        bool requireSuccess,
+        uint256 gasLimit,
+        Call[] calldata calls
+    ) public payable returns (Result[] memory returnData) {
         uint256 length = calls.length;
         returnData = new Result[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call{gas: gasLimit}(calls[i].callData);
@@ -59,15 +59,14 @@ contract PendleMulticallV2 {
         }
     }
 
-    function tryAggregateRevert(uint256 gasLimit, Call[] calldata calls)
-        public
-        payable
-        returns (bytes[] memory returnData)
-    {
+    function tryAggregateRevert(
+        uint256 gasLimit,
+        Call[] calldata calls
+    ) public payable returns (bytes[] memory returnData) {
         uint256 length = calls.length;
         returnData = new bytes[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length;) {
+        for (uint256 i = 0; i < length; ) {
             call = calls[i];
 
             (, returnData[i]) = address(this).delegatecall{gas: gasLimit}(

package/contracts/offchain-helpers/PendleOffchainStorage.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../interfaces/IPOffchainStorage.sol";
+
+contract PendleOffchainStorage is IPOffchainStorage, UUPSUpgradeable, AccessControlUpgradeable {
+    bytes32 public constant MAINTAINER = keccak256("MAINTAINER");
+
+    constructor() initializer {}
+
+    modifier onlyMaintainer() {
+        require(isMaintainer(msg.sender), "not maintainer");
+        _;
+    }
+
+    function isMaintainer(address addr) public view returns (bool) {
+        return (hasRole(DEFAULT_ADMIN_ROLE, addr) || hasRole(MAINTAINER, addr));
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                                CORE
+    //////////////////////////////////////////////////////////////*/
+
+    mapping(bytes32 => bytes) internal _storage;
+
+    function setStorageUint256(bytes32 key, uint256 value) external onlyMaintainer {
+        _setStorage(key, abi.encode(value));
+    }
+
+    function setStorage(bytes32 key, bytes memory value) external onlyMaintainer {
+        _setStorage(key, value);
+    }
+
+    function getUint256(bytes32 key) external view returns (uint256) {
+        return abi.decode(_storage[key], (uint256));
+    }
+
+    function _setStorage(bytes32 key, bytes memory value) internal {
+        _storage[key] = value;
+        emit SetStorage(key, value);
+    }
+
+    // TODO: update more getSomething functions later when theres a need
+
+    /*///////////////////////////////////////////////////////////////
+                            UPGRADABLE RELATED
+    //////////////////////////////////////////////////////////////*/
+    function initialize() external initializer {
+        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
+    }
+
+    function _authorizeUpgrade(address) internal view override {
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "not admin");
+    }
+
+    uint256[49] private __gap;
+}

package/contracts/offchain-helpers/SimulateHelper.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../core/libraries/Errors.sol";
+
+contract SimulateHelper {
+    address private immutable original;
+
+    constructor() {
+        original = address(this);
+    }
+
+    function multicallRevert(
+        uint256 gasLimit,
+        address[] calldata targets,
+        bytes[] calldata callDatas
+    ) public payable virtual returns (bytes[] memory res, uint256[] memory gasUsed) {
+        require(targets.length == callDatas.length, "length mismatch");
+
+        uint256 length = callDatas.length;
+        res = new bytes[](length);
+        gasUsed = new uint256[](length);
+        for (uint256 i = 0; i < length; ) {
+            uint256 gasBefore = gasleft();
+            (, res[i]) = original.delegatecall{gas: gasLimit}(
+                abi.encodeWithSignature("simulate(address,bytes)", targets[i], callDatas[i])
+            );
+            gasUsed[i] = gasBefore - gasleft();
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function simulate(address target, bytes calldata data) external payable {
+        (bool success, bytes memory result) = target.delegatecall(data);
+        revert Errors.SimulationResults(success, result);
+    }
+}

package/contracts/offchain-helpers/errors/SDKErrorsDirectory.sol

@@ -1,10 +1,24 @@
 pragma solidity ^0.8.0;
 
 library SDKErrorsDirectory {
+    error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
+    error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
+    error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
+    error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
+    error BulkNotMaintainer();
+    error BulkNotAdmin();
+    error BulkSellerAlreadyExisted(address token, address SY, address bulk);
+    error BulkSellerInvalidToken(address token, address SY);
+    error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
+    error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
     error ApproxFail();
     error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
     error ApproxBinarySearchInputInvalid(
-        uint256 approxGuessMin, uint256 approxGuessMax, uint256 minGuessMin, uint256 maxGuessMax
+        uint256 approxGuessMin,
+        uint256 approxGuessMax,
+        uint256 minGuessMin,
+        uint256 maxGuessMax
     );
     error MarketExpired();
     error MarketZeroAmountsInput();

package/contracts/oracles/PendleLpOracleLib.sol

@@ -18,7 +18,11 @@ library PendleLpOracleLib {
     function getLpToAssetRate(IPMarket market, uint32 duration) internal view returns (uint256) {
         (uint256 syIndex, uint256 pyIndex) = PendlePtOracleLib.getSYandPYIndexCurrent(market);
         uint256 lpToAssetRateRaw = _getLpToAssetRateRaw(market, duration, pyIndex);
-        return (lpToAssetRateRaw * syIndex) / pyIndex;
+        if (syIndex >= pyIndex) {
+            return lpToAssetRateRaw;
+        } else {
+            return (lpToAssetRateRaw * syIndex) / pyIndex;
+        }
     }
 
     function _getLpToAssetRateRaw(
@@ -28,20 +32,15 @@ library PendleLpOracleLib {
     ) private view returns (uint256 lpToAssetRateRaw) {
         MarketState memory state = market.readState(address(0));
 
-        MarketPreCompute memory comp = state.getMarketPreCompute(
-            PYIndex.wrap(pyIndex),
-            block.timestamp
-        );
-
         int256 totalHypotheticalAsset;
         if (state.expiry <= block.timestamp) {
             // 1 PT = 1 Asset post-expiry
-            totalHypotheticalAsset = state.totalPt + comp.totalAsset;
+            totalHypotheticalAsset = state.totalPt + PYIndexLib.syToAsset(PYIndex.wrap(pyIndex), state.totalSy);
         } else {
+            MarketPreCompute memory comp = state.getMarketPreCompute(PYIndex.wrap(pyIndex), block.timestamp);
+
             (int256 rateOracle, int256 rateHypTrade) = _getPtRatesRaw(market, state, duration);
-            int256 cParam = LogExpMath.exp(
-                comp.rateScalar.mulDown((rateOracle - comp.rateAnchor))
-            );
+            int256 cParam = LogExpMath.exp(comp.rateScalar.mulDown((rateOracle - comp.rateAnchor)));
 
             int256 tradeSize = (cParam.mulDown(comp.totalAsset) - state.totalPt).divDown(
                 PMath.IONE + cParam.divDown(rateHypTrade)

package/contracts/oracles/PendlePtOracle.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "./PendlePtOracleLib.sol";
 import "../interfaces/IPPtOracle.sol";
@@ -40,10 +40,7 @@ contract PendlePtOracle is BoringOwnableUpgradeable, IPPtOracle {
      * @param market market to get rate from
      * @param duration twap duration
      */
-    function getPtToAssetRate(
-        address market,
-        uint32 duration
-    ) external view returns (uint256 ptToAssetRate) {
+    function getPtToAssetRate(address market, uint32 duration) external view returns (uint256 ptToAssetRate) {
         ptToAssetRate = IPMarket(market).getPtToAssetRate(duration);
     }
 
@@ -60,20 +57,10 @@ contract PendlePtOracle is BoringOwnableUpgradeable, IPPtOracle {
     )
         external
         view
-        returns (
-            bool increaseCardinalityRequired,
-            uint16 cardinalityRequired,
-            bool oldestObservationSatisfied
-        )
+        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);
@@ -90,7 +77,9 @@ contract PendlePtOracle is BoringOwnableUpgradeable, IPPtOracle {
     }
 
     function _calcCardinalityRequiredRequired(uint32 duration) internal view returns (uint16) {
-        uint32 cardinalityRequired = (duration * BLOCK_CYCLE_DENOMINATOR) / blockCycleNumerator;
+        uint32 cardinalityRequired = (duration * BLOCK_CYCLE_DENOMINATOR + blockCycleNumerator - 1) /
+            blockCycleNumerator +
+            1;
         if (cardinalityRequired > type(uint16).max) {
             revert TwapDurationTooLarge(duration, cardinalityRequired);
         }

package/contracts/oracles/PendlePtOracleLib.sol

@@ -16,7 +16,11 @@ library PendlePtOracleLib {
      */
     function getPtToAssetRate(IPMarket market, uint32 duration) internal view returns (uint256) {
         (uint256 syIndex, uint256 pyIndex) = getSYandPYIndexCurrent(market);
-        return (getPtToAssetRateRaw(market,duration) * syIndex) / pyIndex;
+        if (syIndex >= pyIndex) {
+            return getPtToAssetRateRaw(market, duration);
+        } else {
+            return (getPtToAssetRateRaw(market, duration) * syIndex) / pyIndex;
+        }
     }
 
     function getPtToAssetRateRaw(IPMarket market, uint32 duration) internal view returns (uint256) {
@@ -27,17 +31,12 @@ library PendlePtOracleLib {
         } else {
             uint256 lnImpliedRate = _getMarketLnImpliedRate(market, duration);
             uint256 timeToExpiry = expiry - block.timestamp;
-            uint256 assetToPtRate =
-                MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry).Uint();
+            uint256 assetToPtRate = MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry).Uint();
             return PMath.ONE.divDown(assetToPtRate);
         }
     }
 
-    function getSYandPYIndexCurrent(IPMarket market)
-        internal
-        view
-        returns (uint256 syIndex, uint256 pyIndex)
-    {
+    function getSYandPYIndexCurrent(IPMarket market) internal view returns (uint256 syIndex, uint256 pyIndex) {
         (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
 
         syIndex = SY.exchangeRate();
@@ -50,11 +49,7 @@ library PendlePtOracleLib {
         }
     }
 
-    function _getMarketLnImpliedRate(IPMarket market, uint32 duration)
-        private
-        view
-        returns (uint256)
-    {
+    function _getMarketLnImpliedRate(IPMarket market, uint32 duration) private view returns (uint256) {
         uint32[] memory durations = new uint32[](2);
         durations[0] = duration;
 

package/contracts/oracles/samples/PendleLpGlpOracle.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../PendleLpOracleLib.sol";
 import "../../interfaces/IPPtOracle.sol";
@@ -18,19 +18,15 @@ contract PendleLpGlpOracle {
     address public immutable glpManager;
     error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
 
-    constructor(
-        address _ptOracle,
-        uint32 _twapDuration,
-        address _market,
-        address _glpManager
-    ) {
+    constructor(address _ptOracle, uint32 _twapDuration, address _market, address _glpManager) {
         twapDuration = _twapDuration;
         market = _market;
         glpManager = _glpManager;
 
-        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtOracle(
-            _ptOracle
-        ).getOracleState(market, twapDuration);
+        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtOracle(_ptOracle).getOracleState(
+            market,
+            twapDuration
+        );
 
         if (increaseCardinalityRequired || !oldestObservationSatisfied) {
             revert OracleNotReady(increaseCardinalityRequired, oldestObservationSatisfied);

package/contracts/oracles/samples/PendlePtGlpOracle.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../PendlePtOracleLib.sol";
 import "../../interfaces/IPPtOracle.sol";
@@ -21,19 +21,15 @@ contract PendlePtGlpOracle {
     address public immutable glpManager;
     error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
 
-    constructor(
-        address _ptOracle,
-        uint32 _twapDuration,
-        address _market,
-        address _glpManager
-    ) {
+    constructor(address _ptOracle, uint32 _twapDuration, address _market, address _glpManager) {
         twapDuration = _twapDuration;
         market = _market;
         glpManager = _glpManager;
 
-        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtOracle(
-            _ptOracle
-        ).getOracleState(market, twapDuration);
+        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtOracle(_ptOracle).getOracleState(
+            market,
+            twapDuration
+        );
 
         if (increaseCardinalityRequired || !oldestObservationSatisfied) {
             revert OracleNotReady(increaseCardinalityRequired, oldestObservationSatisfied);

package/contracts/oracles/samples/PendlePtUsdChainlinkOracle.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPPtOracle.sol";
 import "../../core/libraries/math/PMath.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 multiply with the default USD price of asset
@@ -20,21 +20,17 @@ contract PendlePtUsdChainlinkOracle {
 
     error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
 
-    constructor(
-        address _ptOracle,
-        uint32 _twapDuration,
-        address _market,
-        address _feed
-    ) {
+    constructor(address _ptOracle, uint32 _twapDuration, address _market, address _feed) {
         ptOracle = _ptOracle;
         twapDuration = _twapDuration;
         market = _market;
         feed = _feed;
         feedDecimals = IChainlinkAggregator(feed).decimals();
 
-        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtOracle(
-            _ptOracle
-        ).getOracleState(market, twapDuration);
+        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtOracle(_ptOracle).getOracleState(
+            market,
+            twapDuration
+        );
 
         if (increaseCardinalityRequired || !oldestObservationSatisfied) {
             revert OracleNotReady(increaseCardinalityRequired, oldestObservationSatisfied);
@@ -49,10 +45,7 @@ contract PendlePtUsdChainlinkOracle {
 
     function _getUnderlyingAssetPrice() internal view virtual returns (uint256) {
         uint256 rawPrice = uint256(IChainlinkAggregator(feed).latestAnswer());
-        return
-            feedDecimals < 18
-                ? rawPrice * 10**(18 - feedDecimals)
-                : rawPrice / 10**(feedDecimals - 18);
+        return feedDecimals < 18 ? rawPrice * 10 ** (18 - feedDecimals) : rawPrice / 10 ** (feedDecimals - 18);
     }
 
     function decimals() external pure virtual returns (uint8) {