@pendle/core-v2 6.3.0 → 6.3.1

package/contracts/core/Market/PendleMarketV6.sol

@@ -6,16 +6,16 @@ import "../../interfaces/IPMarketFactory.sol";
 import "../../interfaces/IPMarketSwapCallback.sol";
 
 import "../erc20/PendleERC20.sol";
-import "./PendleGauge.sol";
-import "./OracleLib.sol";
 import "../libraries/StringLib.sol";
+import "./OracleLib.sol";
+import "./PendleGauge.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[65535];
+    using OracleLib for OracleLib.Observation[65_535];
     using StringLib for string;
     using StringLib for StringLib.slice;
 
@@ -59,7 +59,7 @@ contract PendleMarketV6 is PendleERC20, PendleGauge, IPMarket {
 
     MarketStorage public _storage;
 
-    OracleLib.Observation[65535] public observations;
+    OracleLib.Observation[65_535] public observations;
 
     modifier notExpired() {
         if (isExpired()) revert Errors.MarketExpired();
@@ -81,9 +81,8 @@ 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);
 
@@ -110,21 +109,18 @@ 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) {
@@ -136,10 +132,12 @@ 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);
     }
@@ -148,11 +146,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);
@@ -171,18 +169,19 @@ 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();
 
@@ -198,8 +197,9 @@ 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,17 +212,18 @@ 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();
@@ -240,8 +241,9 @@ 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();
@@ -277,14 +279,13 @@ 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 {
@@ -310,10 +311,8 @@ 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;
@@ -380,11 +379,10 @@ 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,10 +45,8 @@ 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 {
@@ -60,10 +58,12 @@ 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,7 +40,8 @@ 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));
 
@@ -69,10 +70,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/IPYieldToken.sol";
 import "../../interfaces/IPPrincipalToken.sol";
+import "../../interfaces/IPYieldToken.sol";
 
-import "./SYUtils.sol";
 import "../libraries/math/PMath.sol";
+import "./SYUtils.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/IPYieldToken.sol";
-import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPInterestManagerYT.sol";
+import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
+import "../../interfaces/IPYieldToken.sol";
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-import "../libraries/math/PMath.sol";
-import "../libraries/TokenHelper.sol";
 import "../StandardizedYield/SYUtils.sol";
+import "../libraries/TokenHelper.sol";
+import "../libraries/math/PMath.sol";
 
 /*
 With YT yielding more SYs overtime, which is allowed to be redeemed by users, the reward distribution should
@@ -40,11 +40,10 @@ 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/MiniHelpers.sol";
 import "../libraries/Errors.sol";
+import "../libraries/MiniHelpers.sol";
 
 import "../erc20/PendleERC20.sol";
 
@@ -29,13 +29,9 @@ 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;

package/contracts/core/YieldContracts/PendleYieldContractFactoryUpg.sol

@@ -28,11 +28,11 @@ import "../../interfaces/IPYieldContractFactory.sol";
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
-import "../libraries/ExpiryUtilsLib.sol";
 import "../libraries/BaseSplitCodeFactory.sol";
-import "../libraries/MiniHelpers.sol";
-import "../libraries/Errors.sol";
 import "../libraries/BoringOwnableUpgradeableV2.sol";
+import "../libraries/Errors.sol";
+import "../libraries/ExpiryUtilsLib.sol";
+import "../libraries/MiniHelpers.sol";
 import "../libraries/StringLib.sol";
 
 import "./PendlePrincipalToken.sol";
@@ -105,18 +105,19 @@ contract PendleYieldContractFactoryUpg is BoringOwnableUpgradeableV2, IPYieldCon
      * @notice Create a pair of (PT, YT) from any SY and valid expiry. Anyone can create a yield contract
      * @dev It's intentional to make expiry an uint32 to guard against fat fingers. uint32.max is year 2106
      */
-    function createYieldContract(
-        address SY,
-        uint32 expiry,
-        bool doCacheIndexSameBlock
-    ) external returns (address PT, address YT) {
-        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0) revert Errors.YCFactoryInvalidExpiry();
+    function createYieldContract(address SY, uint32 expiry, bool doCacheIndexSameBlock)
+        external
+        returns (address PT, address YT)
+    {
+        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0) {
+            revert Errors.YCFactoryInvalidExpiry();
+        }
 
         if (getPT[SY][expiry] != address(0)) revert Errors.YCFactoryYieldContractExisted();
 
         IStandardizedYield _SY = IStandardizedYield(SY);
 
-        (, , uint8 assetDecimals) = _SY.assetInfo();
+        (,, uint8 assetDecimals) = _SY.assetInfo();
 
         string memory syCoreName = _SY.name().stripPrefix(SY_NAME_PREF);
         string memory syCoreSymbol = _SY.symbol().stripPrefix(SY_SYMBOL_PREF);
@@ -172,16 +173,18 @@ contract PendleYieldContractFactoryUpg is BoringOwnableUpgradeableV2, IPYieldCon
     }
 
     function setInterestFeeRate(uint128 newInterestFeeRate) public onlyOwner {
-        if (newInterestFeeRate > maxInterestFeeRate)
+        if (newInterestFeeRate > maxInterestFeeRate) {
             revert Errors.YCFactoryInterestFeeRateTooHigh(newInterestFeeRate, maxInterestFeeRate);
+        }
 
         interestFeeRate = newInterestFeeRate;
         emit SetInterestFeeRate(newInterestFeeRate);
     }
 
     function setRewardFeeRate(uint128 newRewardFeeRate) public onlyOwner {
-        if (newRewardFeeRate > maxRewardFeeRate)
+        if (newRewardFeeRate > maxRewardFeeRate) {
             revert Errors.YCFactoryRewardFeeRateTooHigh(newRewardFeeRate, maxRewardFeeRate);
+        }
 
         rewardFeeRate = newRewardFeeRate;
         emit SetRewardFeeRate(newRewardFeeRate);

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -3,26 +3,26 @@ pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-import "../../interfaces/IStandardizedYield.sol";
-import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPPrincipalToken.sol";
+import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IStandardizedYield.sol";
 
-import "../libraries/math/PMath.sol";
-import "../libraries/ArrayLib.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
 import "../StandardizedYield/SYUtils.sol";
+import "../libraries/ArrayLib.sol";
 import "../libraries/Errors.sol";
 import "../libraries/MiniHelpers.sol";
+import "../libraries/math/PMath.sol";
 
 import "../RewardManager/RewardManagerAbstract.sol";
 import "../erc20/PendleERC20.sol";
 import "./InterestManagerYT.sol";
 
 /**
-Invariance to maintain:
-- 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:
+ * - 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 PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, InterestManagerYT {
     using PMath for uint256;
     using SafeERC20 for IERC20;
@@ -87,10 +87,13 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
      * @notice Tokenize SY into PT + YT of equal qty. Every unit of asset of SY will create 1 PT + 1 YT
      * @dev SY must be transferred to this contract prior to calling
      */
-    function mintPY(
-        address receiverPT,
-        address receiverYT
-    ) external nonReentrant notExpired updateData returns (uint256 amountPYOut) {
+    function mintPY(address receiverPT, address receiverYT)
+        external
+        nonReentrant
+        notExpired
+        updateData
+        returns (uint256 amountPYOut)
+    {
         address[] memory receiverPTs = new address[](1);
         address[] memory receiverYTs = new address[](1);
         uint256[] memory amountSyToMints = new uint256[](1);
@@ -113,8 +116,9 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         if (receiverYTs.length != length || amountSyToMints.length != length) revert Errors.ArrayLengthMismatch();
 
         uint256 totalSyToMint = amountSyToMints.sum();
-        if (totalSyToMint > _getFloatingSyAmount())
+        if (totalSyToMint > _getFloatingSyAmount()) {
             revert Errors.YieldContractInsufficientSy(totalSyToMint, _getFloatingSyAmount());
+        }
 
         amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
     }
@@ -140,10 +144,12 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
      * @dev PT/YT must be transferred to this contract prior to calling
      * @dev fails if unable to redeem the total PY amount in `amountPYToRedeems`
      */
-    function redeemPYMulti(
-        address[] calldata receivers,
-        uint256[] calldata amountPYToRedeems
-    ) external nonReentrant updateData returns (uint256[] memory amountSyOuts) {
+    function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
+        external
+        nonReentrant
+        updateData
+        returns (uint256[] memory amountSyOuts)
+    {
         if (receivers.length != amountPYToRedeems.length) revert Errors.ArrayLengthMismatch();
         if (receivers.length == 0) revert Errors.ArrayEmpty();
         amountSyOuts = _redeemPY(receivers, amountPYToRedeems);
@@ -159,11 +165,12 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
      * time, unless users redeem their dueInterest or redeemPY. Due to this, it is required to
      * update users' accruedReward STRICTLY BEFORE transferring out their interest.
      */
-    function redeemDueInterestAndRewards(
-        address user,
-        bool redeemInterest,
-        bool redeemRewards
-    ) external nonReentrant updateData returns (uint256 interestOut, uint256[] memory rewardsOut) {
+    function redeemDueInterestAndRewards(address user, bool redeemInterest, bool redeemRewards)
+        external
+        nonReentrant
+        updateData
+        returns (uint256 interestOut, uint256[] memory rewardsOut)
+    {
         if (!redeemInterest && !redeemRewards) revert Errors.YCNothingToRedeem();
 
         // if redeemRewards == true, this line must be here for obvious reason
@@ -274,7 +281,9 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
             uint256[] memory userRewardOwed
         )
     {
-        if (postExpiry.firstPYIndex == 0) revert Errors.YCPostExpiryDataNotSet();
+        if (postExpiry.firstPYIndex == 0) {
+            revert Errors.YCPostExpiryDataNotSet();
+        }
 
         firstPYIndex = postExpiry.firstPYIndex;
         totalSyInterestForTreasury = postExpiry.totalSyInterestForTreasury;
@@ -289,11 +298,10 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         }
     }
 
-    function _mintPY(
-        address[] memory receiverPTs,
-        address[] memory receiverYTs,
-        uint256[] memory amountSyToMints
-    ) internal returns (uint256[] memory amountPYOuts) {
+    function _mintPY(address[] memory receiverPTs, address[] memory receiverYTs, uint256[] memory amountSyToMints)
+        internal
+        returns (uint256[] memory amountPYOuts)
+    {
         amountPYOuts = new uint256[](amountSyToMints.length);
 
         uint256 index = _pyIndexCurrent();
@@ -312,10 +320,10 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         return MiniHelpers.isCurrentlyExpired(expiry);
     }
 
-    function _redeemPY(
-        address[] memory receivers,
-        uint256[] memory amountPYToRedeems
-    ) internal returns (uint256[] memory amountSyOuts) {
+    function _redeemPY(address[] memory receivers, uint256[] memory amountPYToRedeems)
+        internal
+        returns (uint256[] memory amountSyOuts)
+    {
         uint256 totalAmountPYToRedeem = amountPYToRedeems.sum();
         IPPrincipalToken(PT).burnByYT(address(this), totalAmountPYToRedeem);
         if (!isExpired()) _burn(address(this), totalAmountPYToRedeem);
@@ -342,10 +350,11 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         return SYUtils.syToAsset(indexCurrent, amountSy);
     }
 
-    function _calcSyRedeemableFromPY(
-        uint256 amountPY,
-        uint256 indexCurrent
-    ) internal view returns (uint256 syToUser, uint256 syInterestPostExpiry) {
+    function _calcSyRedeemableFromPY(uint256 amountPY, uint256 indexCurrent)
+        internal
+        view
+        returns (uint256 syToUser, uint256 syInterestPostExpiry)
+    {
         syToUser = SYUtils.assetToSy(indexCurrent, amountPY);
         if (isExpired()) {
             uint256 totalSyRedeemable = SYUtils.assetToSy(postExpiry.firstPYIndex, amountPY);
@@ -415,10 +424,12 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         return IStandardizedYield(SY).getRewardTokens();
     }
 
-    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();
 
         if (isExpired()) {
@@ -482,7 +493,9 @@ contract PendleYieldToken is IPYieldToken, PendleERC20, RewardManagerAbstract, I
         tokens = getRewardTokens();
         if (isExpired()) {
             indexes = new uint256[](tokens.length);
-            for (uint256 i = 0; i < tokens.length; i++) indexes[i] = postExpiry.firstRewardIndex[tokens[i]];
+            for (uint256 i = 0; i < tokens.length; i++) {
+                indexes[i] = postExpiry.firstRewardIndex[tokens[i]];
+            }
         } else {
             indexes = IStandardizedYield(SY).rewardIndexesCurrent();
         }

package/contracts/core/erc20/PendleERC20.sol

@@ -160,11 +160,13 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
      * - the caller must have allowance for ``from``'s tokens of at least
      * `amount`.
      */
-    function transferFrom(
-        address from,
-        address to,
-        uint256 amount
-    ) external virtual override nonReentrant returns (bool) {
+    function transferFrom(address from, address to, uint256 amount)
+        external
+        virtual
+        override
+        nonReentrant
+        returns (bool)
+    {
         address spender = _msgSender();
         _spendAllowance(from, spender, amount);
         _transfer(from, to, amount);
@@ -204,7 +206,8 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
         _afterTokenTransfer(from, to, amount);
     }
 
-    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
+    /**
+     * @dev Creates `amount` tokens and assigns them to `account`, increasing
      * the total supply.
      *
      * Emits a {Transfer} event with `from` set to the zero address.