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

package/contracts/LiquidityMining/VotingController/VotingControllerStorageUpg.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPVeToken.sol";
 import "../../interfaces/IPVotingController.sol";
@@ -93,15 +93,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
     }
 
     /// @notice deprecated, only kept for compatibility reasons
-    function getUserPoolHistoryAt(
-        address user,
-        address pool,
-        uint256 index
-    ) external view returns (Checkpoint memory) {
+    function getUserPoolHistoryAt(address user, address pool, uint256 index) external view returns (Checkpoint memory) {
         return __dep_userPoolHistory[user][pool].get(index);
     }
 
-
     function getPoolData(
         address pool,
         uint128[] calldata wTimes
@@ -116,11 +111,7 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         )
     {
         PoolData storage data = poolData[pool];
-        (chainId, lastSlopeChangeAppliedAt, totalVote) = (
-            data.chainId,
-            data.lastSlopeChangeAppliedAt,
-            data.totalVote
-        );
+        (chainId, lastSlopeChangeAppliedAt, totalVote) = (data.chainId, data.lastSlopeChangeAppliedAt, data.totalVote);
 
         slopeChanges = new uint128[](wTimes.length);
         for (uint256 i = 0; i < wTimes.length; ++i) {
@@ -175,10 +166,7 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         return activeChainPools[chainId].values();
     }
 
-    function getUserPoolVote(
-        address user,
-        address pool
-    ) external view returns (UserPoolData memory) {
+    function getUserPoolVote(address user, address pool) external view returns (UserPoolData memory) {
         return userData[user].voteForPools[pool];
     }
 

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
@@ -13,11 +13,7 @@ import "../../core/libraries/Errors.sol";
 import "./VotingEscrowTokenBase.sol";
 import "../CrossChainMsg/PendleMsgSenderAppUpg.sol";
 
-contract VotingEscrowPendleMainchain is
-    VotingEscrowTokenBase,
-    IPVotingEscrowMainchain,
-    PendleMsgSenderAppUpg
-{
+contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMainchain, PendleMsgSenderAppUpg {
     using SafeERC20 for IERC20;
     using VeBalanceLib for VeBalance;
     using VeBalanceLib for LockedPosition;
@@ -25,8 +21,7 @@ contract VotingEscrowPendleMainchain is
     using EnumerableMap for EnumerableMap.UintToAddressMap;
 
     bytes private constant EMPTY_BYTES = abi.encode();
-    bytes private constant SAMPLE_SUPPLY_UPDATE_MESSAGE =
-        abi.encode(0, VeBalance(0, 0), EMPTY_BYTES);
+    bytes private constant SAMPLE_SUPPLY_UPDATE_MESSAGE = abi.encode(0, VeBalance(0, 0), EMPTY_BYTES);
     bytes private constant SAMPLE_POSITION_UPDATE_MESSAGE =
         abi.encode(0, VeBalance(0, 0), abi.encode(address(0), LockedPosition(0, 0)));
 
@@ -127,12 +122,7 @@ contract VotingEscrowPendleMainchain is
      * @notice update & return the current totalSupply, but does not broadcast info to other chains
      * @dev See `broadcastTotalSupply()` and `broadcastUserPosition()` for broadcasting
      */
-    function totalSupplyCurrent()
-        public
-        virtual
-        override(IPVeToken, VotingEscrowTokenBase)
-        returns (uint128)
-    {
+    function totalSupplyCurrent() public virtual override(IPVeToken, VotingEscrowTokenBase) returns (uint128) {
         (VeBalance memory supply, ) = _applySlopeChange();
         return supply.getCurrentValue();
     }
@@ -146,10 +136,7 @@ contract VotingEscrowPendleMainchain is
      * @notice updates and broadcast the position of `user` to different chains, also updates and
      * broadcasts totalSupply
      */
-    function broadcastUserPosition(
-        address user,
-        uint256[] calldata chainIds
-    ) public payable refundUnusedEth {
+    function broadcastUserPosition(address user, uint256[] calldata chainIds) public payable refundUnusedEth {
         if (user == address(0)) revert Errors.ZeroAddress();
         _broadcastPosition(user, chainIds);
     }
@@ -158,24 +145,17 @@ contract VotingEscrowPendleMainchain is
         return userHistory[user].length();
     }
 
-    function getUserHistoryAt(
-        address user,
-        uint256 index
-    ) external view returns (Checkpoint memory) {
+    function getUserHistoryAt(address user, uint256 index) external view returns (Checkpoint memory) {
         return userHistory[user].get(index);
     }
 
-    function getBroadcastSupplyFee(
-        uint256[] calldata chainIds
-    ) external view returns (uint256 fee) {
+    function getBroadcastSupplyFee(uint256[] calldata chainIds) external view returns (uint256 fee) {
         for (uint256 i = 0; i < chainIds.length; i++) {
             fee += _getSendMessageFee(chainIds[i], SAMPLE_SUPPLY_UPDATE_MESSAGE);
         }
     }
 
-    function getBroadcastPositionFee(
-        uint256[] calldata chainIds
-    ) external view returns (uint256 fee) {
+    function getBroadcastPositionFee(uint256[] calldata chainIds) external view returns (uint256 fee) {
         for (uint256 i = 0; i < chainIds.length; i++) {
             fee += _getSendMessageFee(chainIds[i], SAMPLE_POSITION_UPDATE_MESSAGE);
         }
@@ -249,13 +229,10 @@ contract VotingEscrowPendleMainchain is
 
         (VeBalance memory supply, ) = _applySlopeChange();
 
-        bytes memory userData = (
-            user == address(0) ? EMPTY_BYTES : abi.encode(user, positionData[user])
-        );
+        bytes memory userData = (user == address(0) ? EMPTY_BYTES : abi.encode(user, positionData[user]));
 
         for (uint256 i = 0; i < chainIds.length; ++i) {
-            if (!destinationContracts.contains(chainIds[i]))
-                revert Errors.ChainNotSupported(chainIds[i]);
+            if (!destinationContracts.contains(chainIds[i])) revert Errors.ChainNotSupported(chainIds[i]);
             _broadcast(chainIds[i], uint128(block.timestamp), supply, userData);
         }
 
@@ -265,12 +242,7 @@ contract VotingEscrowPendleMainchain is
         emit BroadcastTotalSupply(supply, chainIds);
     }
 
-    function _broadcast(
-        uint256 chainId,
-        uint128 msgTime,
-        VeBalance memory supply,
-        bytes memory userData
-    ) internal {
+    function _broadcast(uint256 chainId, uint128 msgTime, VeBalance memory supply, bytes memory userData) internal {
         _sendMessage(chainId, abi.encode(msgTime, supply, userData));
     }
 }

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleSidechain.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../libraries/VeBalanceLib.sol";
 import "../libraries/WeekMath.sol";
@@ -9,11 +9,7 @@ import "./VotingEscrowTokenBase.sol";
 import "../CrossChainMsg/PendleMsgReceiverAppUpg.sol";
 
 // solhint-disable no-empty-blocks
-contract VotingEscrowPendleSidechain is
-    VotingEscrowTokenBase,
-    PendleMsgReceiverAppUpg,
-    BoringOwnableUpgradeable
-{
+contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, PendleMsgReceiverAppUpg, BoringOwnableUpgradeable {
     uint256 public lastTotalSupplyReceivedAt;
 
     mapping(address => address) internal delegatorOf;
@@ -59,10 +55,7 @@ contract VotingEscrowPendleSidechain is
     }
 
     function _setNewUserPosition(bytes memory userData) internal {
-        (address userAddr, LockedPosition memory position) = abi.decode(
-            userData,
-            (address, LockedPosition)
-        );
+        (address userAddr, LockedPosition memory position) = abi.decode(userData, (address, LockedPosition));
         positionData[userAddr] = position;
         emit SetNewUserPosition(position);
     }

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowTokenBase.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPVeToken.sol";
 

package/contracts/LiquidityMining/libraries/VeBalanceLib.sol

@@ -19,27 +19,17 @@ library VeBalanceLib {
     uint128 internal constant MAX_LOCK_TIME = 104 weeks;
     uint256 internal constant USER_VOTE_MAX_WEIGHT = 10 ** 18;
 
-    function add(
-        VeBalance memory a,
-        VeBalance memory b
-    ) internal pure returns (VeBalance memory res) {
+    function add(VeBalance memory a, VeBalance memory b) internal pure returns (VeBalance memory res) {
         res.bias = a.bias + b.bias;
         res.slope = a.slope + b.slope;
     }
 
-    function sub(
-        VeBalance memory a,
-        VeBalance memory b
-    ) internal pure returns (VeBalance memory res) {
+    function sub(VeBalance memory a, VeBalance memory b) internal pure returns (VeBalance memory res) {
         res.bias = a.bias - b.bias;
         res.slope = a.slope - b.slope;
     }
 
-    function sub(
-        VeBalance memory a,
-        uint128 slope,
-        uint128 expiry
-    ) internal pure returns (VeBalance memory res) {
+    function sub(VeBalance memory a, uint128 slope, uint128 expiry) internal pure returns (VeBalance memory res) {
         res.slope = a.slope - slope;
         res.bias = a.bias - slope * expiry;
     }
@@ -65,9 +55,7 @@ library VeBalanceLib {
         return a.bias / a.slope;
     }
 
-    function convertToVeBalance(
-        LockedPosition memory position
-    ) internal pure returns (VeBalance memory res) {
+    function convertToVeBalance(LockedPosition memory position) internal pure returns (VeBalance memory res) {
         res.slope = position.amount / MAX_LOCK_TIME;
         res.bias = res.slope * position.expiry;
     }
@@ -80,10 +68,7 @@ library VeBalanceLib {
         res.bias = res.slope * position.expiry;
     }
 
-    function convertToVeBalance(
-        uint128 amount,
-        uint128 expiry
-    ) internal pure returns (uint128, uint128) {
+    function convertToVeBalance(uint128 amount, uint128 expiry) internal pure returns (uint128, uint128) {
         VeBalance memory balance = convertToVeBalance(LockedPosition(amount, expiry));
         return (balance.bias, balance.slope);
     }

package/contracts/LiquidityMining/libraries/VeHistoryLib.sol

@@ -36,9 +36,7 @@ library Checkpoints {
         if (pos > 0 && self._checkpoints[pos - 1].timestamp == WeekMath.getCurrentWeekStart()) {
             self._checkpoints[pos - 1].value = value;
         } else {
-            self._checkpoints.push(
-                Checkpoint({ timestamp: WeekMath.getCurrentWeekStart(), value: value })
-            );
+            self._checkpoints.push(Checkpoint({timestamp: WeekMath.getCurrentWeekStart(), value: value}));
         }
     }
 }

package/contracts/core/Market/MarketMathCore.sol

@@ -57,17 +57,13 @@ library MarketMathCore {
         uint256 syDesired,
         uint256 ptDesired,
         uint256 blockTime
-    )
-        internal
-        pure
-        returns (uint256 lpToReserve, uint256 lpToAccount, uint256 syUsed, uint256 ptUsed)
-    {
-        (
-            int256 _lpToReserve,
-            int256 _lpToAccount,
-            int256 _syUsed,
-            int256 _ptUsed
-        ) = addLiquidityCore(market, syDesired.Int(), ptDesired.Int(), blockTime);
+    ) internal pure returns (uint256 lpToReserve, uint256 lpToAccount, uint256 syUsed, uint256 ptUsed) {
+        (int256 _lpToReserve, int256 _lpToAccount, int256 _syUsed, int256 _ptUsed) = addLiquidityCore(
+            market,
+            syDesired.Int(),
+            ptDesired.Int(),
+            blockTime
+        );
 
         lpToReserve = _lpToReserve.Uint();
         lpToAccount = _lpToAccount.Uint();
@@ -130,11 +126,7 @@ library MarketMathCore {
         int256 syDesired,
         int256 ptDesired,
         uint256 blockTime
-    )
-        internal
-        pure
-        returns (int256 lpToReserve, int256 lpToAccount, int256 syUsed, int256 ptUsed)
-    {
+    ) internal pure returns (int256 lpToReserve, int256 lpToAccount, int256 syUsed, int256 ptUsed) {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
@@ -216,25 +208,12 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         MarketPreCompute memory comp = getMarketPreCompute(market, index, blockTime);
 
-        (netSyToAccount, netSyFee, netSyToReserve) = calcTrade(
-            market,
-            comp,
-            index,
-            netPtToAccount
-        );
+        (netSyToAccount, netSyFee, netSyToReserve) = calcTrade(market, comp, index, netPtToAccount);
 
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
-        _setNewMarketStateTrade(
-            market,
-            comp,
-            index,
-            netPtToAccount,
-            netSyToAccount,
-            netSyToReserve,
-            blockTime
-        );
+        _setNewMarketStateTrade(market, comp, index, netPtToAccount, netSyToAccount, netSyToReserve, blockTime);
     }
 
     function getMarketPreCompute(
@@ -281,8 +260,7 @@ library MarketMathCore {
 
         if (netPtToAccount > 0) {
             int256 postFeeExchangeRate = preFeeExchangeRate.divDown(fee);
-            if (postFeeExchangeRate < PMath.IONE)
-                revert Errors.MarketExchangeRateBelowOne(postFeeExchangeRate);
+            if (postFeeExchangeRate < PMath.IONE) revert Errors.MarketExchangeRateBelowOne(postFeeExchangeRate);
 
             fee = preFeeAssetToAccount.mulDown(PMath.IONE - fee);
         } else {
@@ -402,10 +380,7 @@ library MarketMathCore {
         res = logitP.ln();
     }
 
-    function _getRateScalar(
-        MarketState memory market,
-        uint256 timeToExpiry
-    ) internal pure returns (int256 rateScalar) {
+    function _getRateScalar(MarketState memory market, uint256 timeToExpiry) internal pure returns (int256 rateScalar) {
         rateScalar = (market.scalarRoot * IMPLIED_RATE_TIME.Int()) / timeToExpiry.Int();
         if (rateScalar <= 0) revert Errors.MarketRateScalarBelowZero(rateScalar);
     }

package/contracts/core/Market/OracleLib.sol

@@ -32,11 +32,7 @@ library OracleLib {
         Observation[65535] storage self,
         uint32 time
     ) public returns (uint16 cardinality, uint16 cardinalityNext) {
-        self[0] = Observation({
-            blockTimestamp: time,
-            lnImpliedRateCumulative: 0,
-            initialized: true
-        });
+        self[0] = Observation({blockTimestamp: time, lnImpliedRateCumulative: 0, initialized: true});
         return (1, 1);
     }
 
@@ -64,11 +60,7 @@ library OracleLib {
         self[indexUpdated] = transform(last, blockTimestamp, lnImpliedRate);
     }
 
-    function grow(
-        Observation[65535] storage self,
-        uint16 current,
-        uint16 next
-    ) public returns (uint16) {
+    function grow(Observation[65535] storage self, uint16 current, uint16 next) public returns (uint16) {
         if (current == 0) revert Errors.OracleUninitialized();
         // no-op if the passed next value isn't greater than the current next value
         if (next <= current) return current;
@@ -141,8 +133,7 @@ library OracleLib {
         if (!beforeOrAt.initialized) beforeOrAt = self[0];
 
         // ensure that the target is chronologically at or after the oldest observation
-        if (target < beforeOrAt.blockTimestamp)
-            revert Errors.OracleTargetTooOld(target, beforeOrAt.blockTimestamp);
+        if (target < beforeOrAt.blockTimestamp) revert Errors.OracleTargetTooOld(target, beforeOrAt.blockTimestamp);
 
         // if we've reached this point, we have to binary search
         return binarySearch(self, target, index, cardinality);
@@ -184,10 +175,8 @@ library OracleLib {
             // we're in the middle
             return (beforeOrAt.lnImpliedRateCumulative +
                 uint216(
-                    (uint256(
-                        atOrAfter.lnImpliedRateCumulative - beforeOrAt.lnImpliedRateCumulative
-                    ) * (target - beforeOrAt.blockTimestamp)) /
-                        (atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp)
+                    (uint256(atOrAfter.lnImpliedRateCumulative - beforeOrAt.lnImpliedRateCumulative) *
+                        (target - beforeOrAt.blockTimestamp)) / (atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp)
                 ));
         }
     }
@@ -204,14 +193,7 @@ library OracleLib {
 
         lnImpliedRateCumulative = new uint216[](secondsAgos.length);
         for (uint256 i = 0; i < lnImpliedRateCumulative.length; ++i) {
-            lnImpliedRateCumulative[i] = observeSingle(
-                self,
-                time,
-                secondsAgos[i],
-                lnImpliedRate,
-                index,
-                cardinality
-            );
+            lnImpliedRateCumulative[i] = observeSingle(self, time, secondsAgos[i], lnImpliedRate, index, cardinality);
         }
     }
 }

package/contracts/core/Market/PendleExternalRewardDistributor.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../libraries/math/PMath.sol";
@@ -28,8 +28,7 @@ contract PendleExternalRewardDistributor is
 
     modifier onlyValidMarket(address market) {
         require(
-            IPMarketFactory(marketFactory).isValidMarket(market) &&
-                block.timestamp < IPMarket(market).expiry(),
+            IPMarketFactory(marketFactory).isValidMarket(market) && block.timestamp < IPMarket(market).expiry(),
             "invalid market"
         );
         _;
@@ -43,9 +42,7 @@ contract PendleExternalRewardDistributor is
         __BoringOwnable_init();
     }
 
-    function getRewardTokens(
-        address market
-    ) external view returns (address[] memory) {
+    function getRewardTokens(address market) external view returns (address[] memory) {
         return rewardTokens[market];
     }
 
@@ -120,10 +117,7 @@ contract PendleExternalRewardDistributor is
         emit AddRewardToMarket(market, token, rewardData[market][token]);
     }
 
-    function _getUpdatedMarketReward(
-        address market,
-        address token
-    ) internal view returns (MarketRewardData memory) {
+    function _getUpdatedMarketReward(address market, address token) internal view returns (MarketRewardData memory) {
         MarketRewardData memory rwd = rewardData[market][token];
         uint128 newLastUpdated = uint128(PMath.min(uint128(block.timestamp), rwd.incentiveEndsAt));
         rwd.accumulatedReward += rwd.rewardPerSec * (newLastUpdated - rwd.lastUpdated);

package/contracts/core/Market/PendleGauge.sol

@@ -71,19 +71,13 @@ abstract contract PendleGauge is RewardManager, IPGauge {
         activeBalance[user] = newActiveBalance;
     }
 
-    function _calcVeBoostedLpBalance(
-        address user,
-        uint256 lpBalance
-    ) internal virtual returns (uint256) {
-        (uint256 vePendleSupply, uint256 vePendleBalance) = vePENDLE.totalSupplyAndBalanceCurrent(
-            user
-        );
+    function _calcVeBoostedLpBalance(address user, uint256 lpBalance) internal virtual returns (uint256) {
+        (uint256 vePendleSupply, uint256 vePendleBalance) = vePENDLE.totalSupplyAndBalanceCurrent(user);
         // Inspired by Curve's Gauge
         uint256 veBoostedLpBalance = (lpBalance * TOKENLESS_PRODUCTION) / 100;
         if (vePendleSupply > 0) {
             veBoostedLpBalance +=
-                (((_totalStaked() * vePendleBalance) / vePendleSupply) *
-                    (100 - TOKENLESS_PRODUCTION)) /
+                (((_totalStaked() * vePendleBalance) / vePendleSupply) * (100 - TOKENLESS_PRODUCTION)) /
                 100;
         }
         return veBoostedLpBalance;

package/contracts/core/Market/PendleMarket.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPMarket.sol";
 import "../../interfaces/IPMarketFactory.sol";
@@ -61,16 +61,14 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         int256 _initialAnchor,
         address _vePendle,
         address _gaugeController
-    )
-        PendleERC20Permit(NAME, SYMBOL, 18)
-        PendleGauge(IPPrincipalToken(_PT).SY(), _vePendle, _gaugeController)
-    {
+    ) PendleERC20Permit(NAME, SYMBOL, 18) PendleGauge(IPPrincipalToken(_PT).SY(), _vePendle, _gaugeController) {
         PT = IPPrincipalToken(_PT);
         SY = IStandardizedYield(PT.SY());
         YT = IPYieldToken(PT.YT());
 
-        (_storage.observationCardinality, _storage.observationCardinalityNext) = observations
-            .initialize(uint32(block.timestamp));
+        (_storage.observationCardinality, _storage.observationCardinalityNext) = observations.initialize(
+            uint32(block.timestamp)
+        );
 
         if (_scalarRoot <= 0) revert Errors.MarketScalarRootBelowZero(_scalarRoot);
 
@@ -92,12 +90,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         address receiver,
         uint256 netSyDesired,
         uint256 netPtDesired
-    )
-        external
-        nonReentrant
-        notExpired
-        returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed)
-    {
+    ) external nonReentrant notExpired returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed) {
         MarketState memory market = readState(msg.sender);
         PYIndex index = YT.newIndex();
 
@@ -169,11 +162,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         MarketState memory market = readState(msg.sender);
 
         uint256 netSyToReserve;
-        (netSyOut, netSyFee, netSyToReserve) = market.swapExactPtForSy(
-            YT.newIndex(),
-            exactPtIn,
-            block.timestamp
-        );
+        (netSyOut, netSyFee, netSyToReserve) = market.swapExactPtForSy(YT.newIndex(), exactPtIn, block.timestamp);
 
         if (receiver != address(this)) IERC20(SY).safeTransfer(receiver, netSyOut);
         IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
@@ -208,11 +197,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         MarketState memory market = readState(msg.sender);
 
         uint256 netSyToReserve;
-        (netSyIn, netSyFee, netSyToReserve) = market.swapSyForExactPt(
-            YT.newIndex(),
-            exactPtOut,
-            block.timestamp
-        );
+        (netSyIn, netSyFee, netSyToReserve) = market.swapSyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
 
         if (receiver != address(this)) IERC20(PT).safeTransfer(receiver, exactPtOut);
         IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
@@ -256,9 +241,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
                                 ORACLE
     //////////////////////////////////////////////////////////////*/
 
-    function observe(
-        uint32[] memory secondsAgos
-    ) external view returns (uint216[] memory lnImpliedRateCumulative) {
+    function observe(uint32[] memory secondsAgos) external view returns (uint216[] memory lnImpliedRateCumulative) {
         return
             observations.observe(
                 uint32(block.timestamp),
@@ -290,9 +273,9 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         market.totalSy = _storage.totalSy;
         market.totalLp = totalSupply().Int();
 
-        (market.treasury, market.lnFeeRateRoot, market.reserveFeePercent) = IPMarketFactory(
-            factory
-        ).getMarketConfig(router);
+        (market.treasury, market.lnFeeRateRoot, market.reserveFeePercent) = IPMarketFactory(factory).getMarketConfig(
+            router
+        );
 
         market.scalarRoot = scalarRoot;
         market.expiry = expiry;
@@ -327,11 +310,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
                             TRIVIAL FUNCTIONS
     //////////////////////////////////////////////////////////////*/
 
-    function readTokens()
-        external
-        view
-        returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT)
-    {
+    function readTokens() external view returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT) {
         _SY = SY;
         _PT = PT;
         _YT = YT;
@@ -363,11 +342,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
     }
 
     // solhint-disable-next-line ordering
-    function _afterTokenTransfer(
-        address from,
-        address to,
-        uint256 amount
-    ) internal override(PendleERC20, PendleGauge) {
+    function _afterTokenTransfer(address from, address to, uint256 amount) internal override(PendleERC20, PendleGauge) {
         PendleGauge._afterTokenTransfer(from, to, amount);
     }
 }

package/contracts/core/Market/PendleMarketFactory.sol

@@ -1,6 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
-
+pragma solidity ^0.8.17;
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
 import "../../interfaces/IPMarket.sol";
@@ -73,18 +72,13 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
      * Anyone is allowed to create a market on their own.
      */
     function createNewMarket(address PT, int256 scalarRoot, int256 initialAnchor) external returns (address market) {
-        if (!IPYieldContractFactory(yieldContractFactory).isPT(PT)) {
-            revert Errors.MarketFactoryInvalidPt();
-        }
+        if (!IPYieldContractFactory(yieldContractFactory).isPT(PT)) revert Errors.MarketFactoryInvalidPt();
         if (IPPrincipalToken(PT).isExpired()) revert Errors.MarketFactoryExpiredPt();
 
-        if (markets[PT][scalarRoot][initialAnchor] != address(0)) {
-            revert Errors.MarketFactoryMarketExists();
-        }
+        if (markets[PT][scalarRoot][initialAnchor] != address(0)) revert Errors.MarketFactoryMarketExists();
 
-        if (initialAnchor < minInitialAnchor) {
+        if (initialAnchor < minInitialAnchor)
             revert Errors.MarketFactoryInitialAnchorTooLow(initialAnchor, minInitialAnchor);
-        }
 
         market = BaseSplitCodeFactory._create2(
             0,
@@ -103,13 +97,14 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
         emit CreateNewMarket(market, PT, scalarRoot, initialAnchor);
     }
 
-    function getMarketConfig(address router)
-        external
-        view
-        returns (address _treasury, uint80 _lnFeeRateRoot, uint8 _reserveFeePercent)
-    {
-        (_treasury, _lnFeeRateRoot, _reserveFeePercent) =
-            (treasury, defaultFee.lnFeeRateRoot, defaultFee.reserveFeePercent);
+    function getMarketConfig(
+        address router
+    ) external view returns (address _treasury, uint80 _lnFeeRateRoot, uint8 _reserveFeePercent) {
+        (_treasury, _lnFeeRateRoot, _reserveFeePercent) = (
+            treasury,
+            defaultFee.lnFeeRateRoot,
+            defaultFee.reserveFeePercent
+        );
 
         FeeConfig memory over = overriddenFee[router];
         if (over.active) {
@@ -147,12 +142,10 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
     }
 
     function _verifyFeeConfig(uint80 newLnFeeRateRoot, uint8 newReserveFeePercent) internal view {
-        if (newLnFeeRateRoot > maxLnFeeRateRoot) {
+        if (newLnFeeRateRoot > maxLnFeeRateRoot)
             revert Errors.MarketFactoryLnFeeRateRootTooHigh(newLnFeeRateRoot, maxLnFeeRateRoot);
-        }
-        if (newReserveFeePercent > maxReserveFeePercent) {
+        if (newReserveFeePercent > maxReserveFeePercent)
             revert Errors.MarketFactoryReserveFeePercentTooHigh(newReserveFeePercent, maxReserveFeePercent);
-        }
     }
 
     function _emitNewMarketConfigEvent() internal {