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

package/contracts/core/Market/OracleLib.sol

@@ -13,29 +13,31 @@ library OracleLib {
         // 1 SLOT = 256 bits
     }
 
-    function transform(Observation memory last, uint32 blockTimestamp, uint96 lnImpliedRate)
-        public
-        pure
-        returns (Observation memory)
-    {
-        return Observation({
-            blockTimestamp: blockTimestamp,
-            lnImpliedRateCumulative: last.lnImpliedRateCumulative + uint216(lnImpliedRate)
-                * (blockTimestamp - last.blockTimestamp),
-            initialized: true
-        });
+    function transform(
+        Observation memory last,
+        uint32 blockTimestamp,
+        uint96 lnImpliedRate
+    ) public pure returns (Observation memory) {
+        return
+            Observation({
+                blockTimestamp: blockTimestamp,
+                lnImpliedRateCumulative: last.lnImpliedRateCumulative +
+                    uint216(lnImpliedRate) *
+                    (blockTimestamp - last.blockTimestamp),
+                initialized: true
+            });
     }
 
-    function initialize(Observation[65_535] storage self, uint32 time)
-        public
-        returns (uint16 cardinality, uint16 cardinalityNext)
-    {
+    function initialize(
+        Observation[65535] storage self,
+        uint32 time
+    ) public returns (uint16 cardinality, uint16 cardinalityNext) {
         self[0] = Observation({blockTimestamp: time, lnImpliedRateCumulative: 0, initialized: true});
         return (1, 1);
     }
 
     function write(
-        Observation[65_535] storage self,
+        Observation[65535] storage self,
         uint16 index,
         uint32 blockTimestamp,
         uint96 lnImpliedRate,
@@ -58,13 +60,13 @@ library OracleLib {
         self[indexUpdated] = transform(last, blockTimestamp, lnImpliedRate);
     }
 
-    function grow(Observation[65_535] 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;
         // store in each slot to prevent fresh SSTOREs in swaps
         // this data will not be used because the initialized boolean is still false
-        for (uint16 i = current; i != next;) {
+        for (uint16 i = current; i != next; ) {
             self[i].blockTimestamp = 1;
             unchecked {
                 ++i;
@@ -73,11 +75,12 @@ library OracleLib {
         return next;
     }
 
-    function binarySearch(Observation[65_535] storage self, uint32 target, uint16 index, uint16 cardinality)
-        public
-        view
-        returns (Observation memory beforeOrAt, Observation memory atOrAfter)
-    {
+    function binarySearch(
+        Observation[65535] storage self,
+        uint32 target,
+        uint16 index,
+        uint16 cardinality
+    ) public view returns (Observation memory beforeOrAt, Observation memory atOrAfter) {
         uint256 l = (index + 1) % cardinality; // oldest observation
         uint256 r = l + cardinality - 1; // newest observation
         uint256 i;
@@ -105,7 +108,7 @@ library OracleLib {
     }
 
     function getSurroundingObservations(
-        Observation[65_535] storage self,
+        Observation[65535] storage self,
         uint32 target,
         uint96 lnImpliedRate,
         uint16 index,
@@ -137,7 +140,7 @@ library OracleLib {
     }
 
     function observeSingle(
-        Observation[65_535] storage self,
+        Observation[65535] storage self,
         uint32 time,
         uint32 secondsAgo,
         uint96 lnImpliedRate,
@@ -154,8 +157,13 @@ library OracleLib {
 
         uint32 target = time - secondsAgo;
 
-        (Observation memory beforeOrAt, Observation memory atOrAfter) =
-            getSurroundingObservations(self, target, lnImpliedRate, index, cardinality);
+        (Observation memory beforeOrAt, Observation memory atOrAfter) = getSurroundingObservations(
+            self,
+            target,
+            lnImpliedRate,
+            index,
+            cardinality
+        );
 
         if (target == beforeOrAt.blockTimestamp) {
             // we're at the left boundary
@@ -165,17 +173,16 @@ library OracleLib {
             return atOrAfter.lnImpliedRateCumulative;
         } else {
             // we're in the middle
-            return (beforeOrAt.lnImpliedRateCumulative
-                    + uint216(
-                        (uint256(atOrAfter.lnImpliedRateCumulative - beforeOrAt.lnImpliedRateCumulative)
-                                * (target - beforeOrAt.blockTimestamp))
-                            / (atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp)
-                    ));
+            return (beforeOrAt.lnImpliedRateCumulative +
+                uint216(
+                    (uint256(atOrAfter.lnImpliedRateCumulative - beforeOrAt.lnImpliedRateCumulative) *
+                        (target - beforeOrAt.blockTimestamp)) / (atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp)
+                ));
         }
     }
 
     function observe(
-        Observation[65_535] storage self,
+        Observation[65535] storage self,
         uint32 time,
         uint32[] memory secondsAgos,
         uint96 lnImpliedRate,

package/contracts/core/Market/PendleGauge.sol

@@ -2,15 +2,15 @@
 pragma solidity ^0.8.0;
 
 import "../../interfaces/IPGauge.sol";
-import "../../interfaces/IPGaugeController.sol";
 import "../../interfaces/IPVeToken.sol";
+import "../../interfaces/IPGaugeController.sol";
 import "../../interfaces/IStandardizedYield.sol";
 
 import "../RewardManager/RewardManager.sol";
 
 /**
- * Invariants to maintain:
- * - before any changes to active balance, updateAndDistributeRewards() must be called
+Invariants to maintain:
+- before any changes to active balance, updateAndDistributeRewards() must be called
  */
 abstract contract PendleGauge is RewardManager, IPGauge {
     using PMath for uint256;
@@ -37,7 +37,7 @@ abstract contract PendleGauge is RewardManager, IPGauge {
 
     /**
      * @dev Since rewardShares is based on activeBalance, user's activeBalance must be updated AFTER
-     *     rewards is updated
+        rewards is updated
      * @dev It's intended to have user's activeBalance updated when rewards is redeemed
      */
     function _redeemRewards(address user) internal virtual returns (uint256[] memory rewardsOut) {
@@ -57,8 +57,7 @@ abstract contract PendleGauge is RewardManager, IPGauge {
     }
 
     /**
-     * @dev should only be callable from `_updateUserActiveBalanceForTwo` to guarantee user != address(0) && user !=
-     * address(this)
+     * @dev should only be callable from `_updateUserActiveBalanceForTwo` to guarantee user != address(0) && user != address(this)
      */
     function _updateUserActiveBalancePrivate(address user) private {
         assert(user != address(0) && user != address(this));
@@ -79,8 +78,9 @@ abstract contract PendleGauge is RewardManager, IPGauge {
         // Inspired by Curve's Gauge
         uint256 veBoostedLpBalance = (lpBalance * TOKENLESS_PRODUCTION) / 100;
         if (vePendleSupply > 0) {
-            veBoostedLpBalance += (((_totalStaked() * vePendleBalance) / vePendleSupply) * (100 - TOKENLESS_PRODUCTION))
-                / 100;
+            veBoostedLpBalance +=
+                (((_totalStaked() * vePendleBalance) / vePendleSupply) * (100 - TOKENLESS_PRODUCTION)) /
+                100;
         }
         return veBoostedLpBalance;
     }

package/contracts/core/Market/PendleMarketFactoryV6Upg.sol

@@ -3,12 +3,12 @@ pragma solidity ^0.8.17;
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
 import "../../interfaces/IPMarket.sol";
-import "../../interfaces/IPMarketFactory.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
+import "../../interfaces/IPMarketFactory.sol";
 
 import "../libraries/BaseSplitCodeFactory.sol";
-import "../libraries/BoringOwnableUpgradeableV2.sol";
 import "../libraries/Errors.sol";
+import "../libraries/BoringOwnableUpgradeableV2.sol";
 
 contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory {
     using EnumerableSet for EnumerableSet.AddressSet;
@@ -70,23 +70,22 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory
      * @notice Create a market between PT and its corresponding SY with scalar & anchor config.
      * Anyone is allowed to create a market on their own.
      */
-    function createNewMarket(address PT, int256 scalarRoot, int256 initialAnchor, uint80 lnFeeRateRoot)
-        external
-        returns (address market)
-    {
+    function createNewMarket(
+        address PT,
+        int256 scalarRoot,
+        int256 initialAnchor,
+        uint80 lnFeeRateRoot
+    ) external returns (address market) {
         if (!IPYieldContractFactory(yieldContractFactory).isPT(PT)) revert Errors.MarketFactoryInvalidPt();
         if (IPPrincipalToken(PT).isExpired()) revert Errors.MarketFactoryExpiredPt();
-        if (lnFeeRateRoot > maxLnFeeRateRoot) {
+        if (lnFeeRateRoot > maxLnFeeRateRoot)
             revert Errors.MarketFactoryLnFeeRateRootTooHigh(lnFeeRateRoot, maxLnFeeRateRoot);
-        }
 
-        if (markets[PT][scalarRoot][initialAnchor][lnFeeRateRoot] != address(0)) {
+        if (markets[PT][scalarRoot][initialAnchor][lnFeeRateRoot] != address(0))
             revert Errors.MarketFactoryMarketExists();
-        }
 
-        if (initialAnchor < minInitialAnchor) {
+        if (initialAnchor < minInitialAnchor)
             revert Errors.MarketFactoryInitialAnchorTooLow(initialAnchor, minInitialAnchor);
-        }
 
         market = BaseSplitCodeFactory._create2(
             0,
@@ -105,11 +104,10 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory
         emit CreateNewMarket(market, PT, scalarRoot, initialAnchor, lnFeeRateRoot);
     }
 
-    function getMarketConfig(address market, address router)
-        external
-        view
-        returns (address _treasury, uint80 _overriddenFee, uint8 _reserveFeePercent)
-    {
+    function getMarketConfig(
+        address market,
+        address router
+    ) external view returns (address _treasury, uint80 _overriddenFee, uint8 _reserveFeePercent) {
         (_treasury, _reserveFeePercent) = (treasury, reserveFeePercent);
         _overriddenFee = overriddenFee[router][market];
     }
@@ -121,9 +119,8 @@ contract PendleMarketFactoryV6Upg is BoringOwnableUpgradeableV2, IPMarketFactory
 
     function setTreasuryAndFeeReserve(address newTreasury, uint8 newReserveFeePercent) public onlyOwner {
         if (newTreasury == address(0)) revert Errors.MarketFactoryZeroTreasury();
-        if (newReserveFeePercent > maxReserveFeePercent) {
+        if (newReserveFeePercent > maxReserveFeePercent)
             revert Errors.MarketFactoryReserveFeePercentTooHigh(newReserveFeePercent, maxReserveFeePercent);
-        }
 
         treasury = newTreasury;
         reserveFeePercent = newReserveFeePercent;

package/contracts/core/Market/PendleMarketV6.sol

@@ -6,16 +6,16 @@ import "../../interfaces/IPMarketFactory.sol";
 import "../../interfaces/IPMarketSwapCallback.sol";
 
 import "../erc20/PendleERC20.sol";
-import "../libraries/StringLib.sol";
-import "./OracleLib.sol";
 import "./PendleGauge.sol";
+import "./OracleLib.sol";
+import "../libraries/StringLib.sol";
 
 /**
- * Invariance to maintain:
- * - Internal balances totalPt & totalSy not interfered by people transferring tokens in directly
- * - address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
- *     guaranteed by address(0) & address(this) check in each updateForTwo function
- */
+Invariance to maintain:
+- Internal balances totalPt & totalSy not interfered by people transferring tokens in directly
+- address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
+    guaranteed by address(0) & address(this) check in each updateForTwo function
+*/
 contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
     using PMath for uint256;
     using PMath for int256;
@@ -23,7 +23,7 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
     using SafeERC20 for IERC20;
     using PYIndexLib for IPYieldToken;
     using PYIndexLib for PYIndex;
-    using OracleLib for OracleLib.Observation[65_535];
+    using OracleLib for OracleLib.Observation[65535];
     using StringLib for string;
     using StringLib for StringLib.slice;
 
@@ -59,7 +59,7 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
 
     MarketStorage public _storage;
 
-    OracleLib.Observation[65_535] public observations;
+    OracleLib.Observation[65535] public observations;
 
     modifier notExpired() {
         if (isExpired()) revert Errors.MarketExpired();
@@ -81,8 +81,9 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
         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);
 
@@ -109,18 +110,21 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
      * @dev PT and SY should be transferred to this contract prior to calling
      * @dev will revert if PT is expired
      */
-    function mint(address receiver, uint256 netSyDesired, uint256 netPtDesired)
-        external
-        nonReentrant
-        notExpired
-        returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed)
-    {
+    function mint(
+        address receiver,
+        uint256 netSyDesired,
+        uint256 netPtDesired
+    ) external nonReentrant notExpired returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed) {
         MarketState memory market = readState(msg.sender);
         PYIndex index = YT.newIndex();
 
         uint256 lpToReserve;
 
-        (lpToReserve, netLpOut, netSyUsed, netPtUsed) = market.addLiquidity(netSyDesired, netPtDesired, block.timestamp);
+        (lpToReserve, netLpOut, netSyUsed, netPtUsed) = market.addLiquidity(
+            netSyDesired,
+            netPtDesired,
+            block.timestamp
+        );
 
         // initializing the market
         if (lpToReserve != 0) {
@@ -132,12 +136,10 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
 
         _writeState(market);
 
-        if (_selfBalance(SY) < market.totalSy.Uint()) {
+        if (_selfBalance(SY) < market.totalSy.Uint())
             revert Errors.MarketInsufficientSyReceived(_selfBalance(SY), market.totalSy.Uint());
-        }
-        if (_selfBalance(PT) < market.totalPt.Uint()) {
+        if (_selfBalance(PT) < market.totalPt.Uint())
             revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
-        }
 
         emit Mint(receiver, netLpOut, netSyUsed, netPtUsed);
     }
@@ -146,11 +148,11 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
      * @notice LP Holders can burn their LP to receive back SY & PT proportionally
      * to their share of the market
      */
-    function burn(address receiverSy, address receiverPt, uint256 netLpToBurn)
-        external
-        nonReentrant
-        returns (uint256 netSyOut, uint256 netPtOut)
-    {
+    function burn(
+        address receiverSy,
+        address receiverPt,
+        uint256 netLpToBurn
+    ) external nonReentrant returns (uint256 netSyOut, uint256 netPtOut) {
         MarketState memory market = readState(msg.sender);
 
         _burn(address(this), netLpToBurn);
@@ -169,19 +171,18 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
      * @notice Pendle Market allows swaps between PT & SY it is holding. This function
      * aims to swap an exact amount of PT to SY.
      * @dev steps working of this contract
-     *    - The outcome amount of SY will be precomputed by MarketMathLib
-     *    - Release the calculated amount of SY to receiver
-     *    - Callback to msg.sender if data.length > 0
-     *    - Ensure exactPtIn amount of PT has been transferred to this address
+       - The outcome amount of SY will be precomputed by MarketMathLib
+       - Release the calculated amount of SY to receiver
+       - Callback to msg.sender if data.length > 0
+       - Ensure exactPtIn amount of PT has been transferred to this address
      * @dev will revert if PT is expired
      * @param data bytes data to be sent in the callback (if any)
      */
-    function swapExactPtForSy(address receiver, uint256 exactPtIn, bytes calldata data)
-        external
-        nonReentrant
-        notExpired
-        returns (uint256 netSyOut, uint256 netSyFee)
-    {
+    function swapExactPtForSy(
+        address receiver,
+        uint256 exactPtIn,
+        bytes calldata data
+    ) external nonReentrant notExpired returns (uint256 netSyOut, uint256 netSyFee) {
         MarketState memory market = readState(msg.sender);
         PYIndex index = YT.newIndex();
 
@@ -197,9 +198,8 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
             IPMarketSwapCallback(msg.sender).swapCallback(exactPtIn.neg(), netSyOut.Int(), data);
         }
 
-        if (_selfBalance(PT) < market.totalPt.Uint()) {
+        if (_selfBalance(PT) < market.totalPt.Uint())
             revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
-        }
 
         if (index.syToAsset(netSyFee - netSyToReserve) == 0) {
             revert Errors.MarketZeroNetLPFee();
@@ -212,18 +212,17 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
      * @notice Pendle Market allows swaps between PT & SY it is holding. This function
      * aims to swap SY for an exact amount of PT.
      * @dev steps working of this function
-     *    - The exact outcome amount of PT will be transferred to receiver
-     *    - Callback to msg.sender if data.length > 0
-     *    - Ensure the calculated required amount of SY is transferred to this address
+       - The exact outcome amount of PT will be transferred to receiver
+       - Callback to msg.sender if data.length > 0
+       - Ensure the calculated required amount of SY is transferred to this address
      * @dev will revert if PT is expired
      * @param data bytes data to be sent in the callback (if any)
      */
-    function swapSyForExactPt(address receiver, uint256 exactPtOut, bytes calldata data)
-        external
-        nonReentrant
-        notExpired
-        returns (uint256 netSyIn, uint256 netSyFee)
-    {
+    function swapSyForExactPt(
+        address receiver,
+        uint256 exactPtOut,
+        bytes calldata data
+    ) external nonReentrant notExpired returns (uint256 netSyIn, uint256 netSyFee) {
         MarketState memory market = readState(msg.sender);
 
         PYIndex index = YT.newIndex();
@@ -241,9 +240,8 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
         }
 
         // have received enough SY
-        if (_selfBalance(SY) < market.totalSy.Uint()) {
+        if (_selfBalance(SY) < market.totalSy.Uint())
             revert Errors.MarketInsufficientSyReceived(_selfBalance(SY), market.totalSy.Uint());
-        }
 
         if (index.syToAsset(netSyFee - netSyToReserve) == 0) {
             revert Errors.MarketZeroNetLPFee();
@@ -279,13 +277,14 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
     //////////////////////////////////////////////////////////////*/
 
     function observe(uint32[] memory secondsAgos) external view returns (uint216[] memory lnImpliedRateCumulative) {
-        return observations.observe(
-            uint32(block.timestamp),
-            secondsAgos,
-            _storage.lastLnImpliedRate,
-            _storage.observationIndex,
-            _storage.observationCardinality
-        );
+        return
+            observations.observe(
+                uint32(block.timestamp),
+                secondsAgos,
+                _storage.lastLnImpliedRate,
+                _storage.observationIndex,
+                _storage.observationCardinality
+            );
     }
 
     function increaseObservationsCardinalityNext(uint16 cardinalityNext) external nonReentrant {
@@ -311,8 +310,10 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
 
         uint80 overriddenFee;
 
-        (market.treasury, overriddenFee, market.reserveFeePercent) =
-            IPMarketFactory(factory).getMarketConfig(address(this), router);
+        (market.treasury, overriddenFee, market.reserveFeePercent) = IPMarketFactory(factory).getMarketConfig(
+            address(this),
+            router
+        );
 
         market.lnFeeRateRoot = overriddenFee == 0 ? lnFeeRateRoot : overriddenFee;
         market.scalarRoot = scalarRoot;
@@ -379,10 +380,11 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
     }
 
     // solhint-disable-next-line ordering
-    function _beforeTokenTransfer(address from, address to, uint256 amount)
-        internal
-        override(PendleERC20, PendleGauge)
-    {
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal override(PendleERC20, PendleGauge) {
         PendleGauge._beforeTokenTransfer(from, to, amount);
     }
 

package/contracts/core/RewardManager/RewardManager.sol

@@ -45,8 +45,10 @@ abstract contract RewardManager is RewardManagerAbstract {
                 if (index == 0) index = INITIAL_REWARD_INDEX;
                 if (totalShares != 0) index += accrued.divDown(totalShares);
 
-                rewardState[token] =
-                    RewardState({index: index.Uint128(), lastBalance: (lastBalance + accrued).Uint128()});
+                rewardState[token] = RewardState({
+                    index: index.Uint128(),
+                    lastBalance: (lastBalance + accrued).Uint128()
+                });
                 indexes[i] = index;
             }
         } else {
@@ -58,12 +60,10 @@ abstract contract RewardManager is RewardManagerAbstract {
 
     /// @dev this function doesn't need redeemExternal since redeemExternal is bundled in updateRewardIndex
     /// @dev this function also has to update rewardState.lastBalance
-    function _doTransferOutRewards(address user, address receiver)
-        internal
-        virtual
-        override
-        returns (uint256[] memory rewardAmounts)
-    {
+    function _doTransferOutRewards(
+        address user,
+        address receiver
+    ) internal virtual override returns (uint256[] memory rewardAmounts) {
         address[] memory tokens = _getRewardTokens();
         rewardAmounts = new uint256[](tokens.length);
         for (uint256 i = 0; i < tokens.length; i++) {

package/contracts/core/RewardManager/RewardManagerAbstract.sol

@@ -40,8 +40,7 @@ abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
         if (user2 != address(0) && user2 != address(this)) _distributeRewardsPrivate(user2, tokens, indexes);
     }
 
-    // should only be callable from `_updateAndDistributeRewardsForTwo` to guarantee user != address(0) && user !=
-    // address(this)
+    // should only be callable from `_updateAndDistributeRewardsForTwo` to guarantee user != address(0) && user != address(this)
     function _distributeRewardsPrivate(address user, address[] memory tokens, uint256[] memory indexes) private {
         assert(user != address(0) && user != address(this));
 
@@ -70,10 +69,10 @@ abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
 
     function _redeemExternalReward() internal virtual;
 
-    function _doTransferOutRewards(address user, address receiver)
-        internal
-        virtual
-        returns (uint256[] memory rewardAmounts);
+    function _doTransferOutRewards(
+        address user,
+        address receiver
+    ) internal virtual returns (uint256[] memory rewardAmounts);
 
     function _rewardSharesUser(address user) internal view virtual returns (uint256);
 }

package/contracts/core/StandardizedYield/PYIndex.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
-import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IPPrincipalToken.sol";
 
-import "../libraries/math/PMath.sol";
 import "./SYUtils.sol";
+import "../libraries/math/PMath.sol";
 
 type PYIndex is uint256;
 

package/contracts/core/YieldContracts/InterestManagerYT.sol

@@ -1,16 +1,16 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../interfaces/IPInterestManagerYT.sol";
+import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPPrincipalToken.sol";
+import "../../interfaces/IPInterestManagerYT.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
-import "../../interfaces/IPYieldToken.sol";
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-import "../StandardizedYield/SYUtils.sol";
-import "../libraries/TokenHelper.sol";
 import "../libraries/math/PMath.sol";
+import "../libraries/TokenHelper.sol";
+import "../StandardizedYield/SYUtils.sol";
 
 /*
 With YT yielding more SYs overtime, which is allowed to be redeemed by users, the reward distribution should
@@ -40,10 +40,11 @@ abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
         if (user2 != address(0) && user2 != address(this)) _distributeInterestPrivate(user2, index);
     }
 
-    function _doTransferOutInterest(address user, address SY, address factory)
-        internal
-        returns (uint256 interestAmount)
-    {
+    function _doTransferOutInterest(
+        address user,
+        address SY,
+        address factory
+    ) internal returns (uint256 interestAmount) {
         address treasury = IPYieldContractFactory(factory).treasury();
         uint256 feeRate = IPYieldContractFactory(factory).interestFeeRate();
 

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -4,8 +4,8 @@ pragma solidity ^0.8.17;
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";
 
-import "../libraries/Errors.sol";
 import "../libraries/MiniHelpers.sol";
+import "../libraries/Errors.sol";
 
 import "../erc20/PendleERC20.sol";
 
@@ -29,9 +29,13 @@ contract PendlePrincipalToken is PendleERC20, Initializable, IPPrincipalToken {
         _;
     }
 
-    constructor(address _SY, string memory _name, string memory _symbol, uint8 __decimals, uint256 _expiry)
-        PendleERC20(_name, _symbol, __decimals)
-    {
+    constructor(
+        address _SY,
+        string memory _name,
+        string memory _symbol,
+        uint8 __decimals,
+        uint256 _expiry
+    ) PendleERC20(_name, _symbol, __decimals) {
         SY = _SY;
         expiry = _expiry;
         factory = msg.sender;