@pendle/core-v2 2.29.4 → 2.30.1

package/contracts/core/StandardizedYield/implementations/PendleWbEthSY.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../SYBase.sol";
 import "../../../interfaces/BinanceEth/IWBETH.sol";
@@ -25,10 +25,7 @@ contract PendleWbEthSY is SYBase {
                     DEPOSIT/REDEEM USING BASE TOKENS
     //////////////////////////////////////////////////////////////*/
 
-    function _deposit(
-        address tokenIn,
-        uint256 amountDeposited
-    ) internal override returns (uint256 amountSharesOut) {
+    function _deposit(address tokenIn, uint256 amountDeposited) internal override returns (uint256 amountSharesOut) {
         if (tokenIn == eth) {
             uint256 previousBalance = _selfBalance(wbETH);
             IWBETH(wbETH).deposit(amountDeposited, address(this));
@@ -98,11 +95,7 @@ contract PendleWbEthSY is SYBase {
         return token == wbETH;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, eth, 18);
     }
 }

package/contracts/core/StandardizedYield/implementations/PendleWstEthSY.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../SYBase.sol";
 import "../../../interfaces/IWstETH.sol";
@@ -48,9 +48,7 @@ contract PendleWstEthSY is SYBase {
             } else {
                 if (tokenIn == wETH) IWETH(wETH).withdraw(amountDeposited);
 
-                uint256 amountStEthSharesOut = IStETH(stETH).submit{ value: amountDeposited }(
-                    address(0)
-                );
+                uint256 amountStEthSharesOut = IStETH(stETH).submit{value: amountDeposited}(address(0));
                 amountStETH = IStETH(stETH).getPooledEthByShares(amountStEthSharesOut);
             }
             amountSharesOut = IWstETH(wstETH).wrap(amountStETH);
@@ -101,9 +99,7 @@ contract PendleWstEthSY is SYBase {
             if (tokenIn != stETH) {
                 uint256 totalShares = IStETH(stETH).getTotalShares();
                 uint256 totalPooledEth = IStETH(stETH).getTotalPooledEther();
-                uint256 amountStEthSharesOut = IStETH(stETH).getSharesByPooledEth(
-                    amountTokenToDeposit
-                );
+                uint256 amountStEthSharesOut = IStETH(stETH).getSharesByPooledEth(amountTokenToDeposit);
 
                 totalShares += amountStEthSharesOut;
                 totalPooledEth += amountTokenToDeposit;
@@ -146,11 +142,7 @@ contract PendleWstEthSY is SYBase {
         return token == stETH || token == wstETH;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, stETH, IERC20Metadata(stETH).decimals());
     }
 }

package/contracts/core/StandardizedYield/implementations/Silo/PendleSiloWithIncentiveSY.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: BUSL-1.1
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../SYBaseWithRewards.sol";
 import "../../../../interfaces/Silo/ISiloIncentiveController.sol";
@@ -102,11 +102,7 @@ contract PendleSiloWithIncentiveSY is SYBaseWithRewards {
                         SILO DATA FUNCITONS
     //////////////////////////////////////////////////////////////*/
 
-    function _getSiloInterestData()
-        internal
-        view
-        returns (uint256 totalDeposit, uint256 totalCollateralTokenSupply)
-    {
+    function _getSiloInterestData() internal view returns (uint256 totalDeposit, uint256 totalCollateralTokenSupply) {
         totalDeposit = ISiloLens(siloLens).totalDepositsWithInterest(silo, asset);
         totalCollateralTokenSupply = IERC20(collateralToken).totalSupply();
     }
@@ -155,11 +151,7 @@ contract PendleSiloWithIncentiveSY is SYBaseWithRewards {
         return token == asset || token == collateralToken;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, asset, IERC20Metadata(asset).decimals());
     }
 }

package/contracts/core/StandardizedYield/implementations/Stader/PendleETHXSY.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 import "../../SYBase.sol";
 import "../../../libraries/ArrayLib.sol";
 import "../../../../interfaces/Stader/IStaderStakeManager.sol";
@@ -13,10 +13,7 @@ contract PendleETHXSY is SYBase {
     address public immutable stakeManager;
     address public immutable ethx;
 
-    constructor(
-        address _stakeManager,
-        address _ethx
-    ) SYBase("SY Stader Staking ETHx", "SY-ETHx", _ethx) {
+    constructor(address _stakeManager, address _ethx) SYBase("SY Stader Staking ETHx", "SY-ETHx", _ethx) {
         stakeManager = _stakeManager;
         ethx = _ethx;
     }
@@ -30,8 +27,7 @@ contract PendleETHXSY is SYBase {
         uint256 amountDeposited
     ) internal virtual override returns (uint256 /*amountSharesOut*/) {
         if (tokenIn == NATIVE) {
-            return
-                IStaderStakeManager(stakeManager).deposit{ value: amountDeposited }(address(this));
+            return IStaderStakeManager(stakeManager).deposit{value: amountDeposited}(address(this));
         } else {
             return amountDeposited;
         }
@@ -100,11 +96,7 @@ contract PendleETHXSY is SYBase {
         return token == ethx;
     }
 
-    function assetInfo()
-        external
-        pure
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, NATIVE, 18);
     }
 }

package/contracts/core/StandardizedYield/implementations/Swell/PendleSwETH.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 import "../../SYBase.sol";
 import "../../../../interfaces/ISwETH.sol";
 
@@ -8,11 +8,7 @@ contract SwETHSY is SYBase {
 
     address public immutable swETH;
 
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _swETH
-    ) SYBase(_name, _symbol, _swETH) {
+    constructor(string memory _name, string memory _symbol, address _swETH) SYBase(_name, _symbol, _swETH) {
         swETH = _swETH;
     }
 
@@ -26,7 +22,7 @@ contract SwETHSY is SYBase {
     ) internal virtual override returns (uint256 /*amountSharesOut*/) {
         if (tokenIn == NATIVE) {
             uint256 preBalance = _selfBalance(swETH);
-            ISwETH(swETH).deposit{ value: amountDeposited }();
+            ISwETH(swETH).deposit{value: amountDeposited}();
             return _selfBalance(swETH) - preBalance;
         } else {
             // sweth
@@ -92,11 +88,7 @@ contract SwETHSY is SYBase {
         return token == swETH;
     }
 
-    function assetInfo()
-        external
-        pure
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external pure returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, NATIVE, 18);
     }
 }

package/contracts/core/StandardizedYield/implementations/Thena/PendleThenaSY.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../SYBaseWithRewards.sol";
 import "./ThenaLpHelper.sol";
@@ -39,12 +39,10 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
     /**
      * @dev See {SYBase-_deposit}
      */
-    function _deposit(address tokenIn, uint256 amountDeposited)
-        internal
-        virtual
-        override
-        returns (uint256 amountLpDeposited)
-    {
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountLpDeposited) {
         _withdrawAllFromGauge();
         if (tokenIn == pair) {
             amountLpDeposited = amountDeposited;
@@ -86,7 +84,7 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
     function _getRewardTokens() internal view virtual override returns (address[] memory res) {
         res = new address[](1 + externalRewardTokens.length);
         res[0] = THENA;
-        for(uint256 i = 1; i < res.length; ++i) {
+        for (uint256 i = 1; i < res.length; ++i) {
             res[i] = externalRewardTokens[i - 1];
         }
     }
@@ -99,12 +97,7 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
                     PREVIEW-RELATED
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        view
-        override
-        returns (uint256)
-    {
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
         if (tokenIn == pair) {
             return amountTokenToDeposit;
         } else {
@@ -112,12 +105,7 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
         }
     }
 
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        view
-        override
-        returns (uint256)
-    {
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem) internal view override returns (uint256) {
         if (tokenOut == pair) {
             return amountSharesToRedeem;
         } else {
@@ -151,15 +139,7 @@ contract PendleThenaSY is ThenaLpHelper, SYBaseWithRewards {
         return token == token0 || token == token1 || token == pair;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.LIQUIDITY, pair, IERC20Metadata(pair).decimals());
     }
 

package/contracts/core/StandardizedYield/implementations/Thena/ThenaLpHelper.sol

@@ -77,10 +77,7 @@ abstract contract ThenaLpHelper is TokenHelper, ThenaMath {
      * ==================================================================
      */
 
-    function _addLiquidity(
-        uint256 amount0ToAddLiq,
-        uint256 amount1ToAddLiq
-    ) private returns (uint256 amountLpOut) {
+    function _addLiquidity(uint256 amount0ToAddLiq, uint256 amount1ToAddLiq) private returns (uint256 amountLpOut) {
         (, , amountLpOut) = IThenaRouter(router).addLiquidity(
             token0,
             token1,
@@ -94,9 +91,7 @@ abstract contract ThenaLpHelper is TokenHelper, ThenaMath {
         );
     }
 
-    function _removeLiquidity(
-        uint256 amountLpToRemove
-    ) private returns (uint256 amountTokenA, uint256 amountTokenB) {
+    function _removeLiquidity(uint256 amountLpToRemove) private returns (uint256 amountTokenA, uint256 amountTokenB) {
         return
             IThenaRouter(router).removeLiquidity(
                 token0,
@@ -133,9 +128,7 @@ abstract contract ThenaLpHelper is TokenHelper, ThenaMath {
      * ==================================================================
      */
 
-    function _getNormalizedThenaData(
-        address tokenIn
-    ) internal view returns (ThenaData memory data) {
+    function _getNormalizedThenaData(address tokenIn) internal view returns (ThenaData memory data) {
         data.pair = pair;
         data.isStable = isStable;
         data.fee = IThenaFactory(factory).getFee(data.isStable);

package/contracts/core/StandardizedYield/implementations/Thena/ThenaMath.sol

@@ -41,25 +41,18 @@ abstract contract ThenaMath {
         address tokenIn,
         uint256 amountIn
     ) internal view returns (uint256) {
-        return
-            data.isStable
-                ? _getStableZapAmount(data, tokenIn, amountIn)
-                : _getVolatileZapAmount(data, amountIn);
+        return data.isStable ? _getStableZapAmount(data, tokenIn, amountIn) : _getVolatileZapAmount(data, amountIn);
     }
 
-    function _getVolatileZapAmount(
-        ThenaData memory data,
-        uint256 amountIn
-    ) private pure returns (uint256) {
-
-        uint256 numer0 = (TWO - FEE_DENOMINATOR) * data.reserve0 / FEE_DENOMINATOR;
+    function _getVolatileZapAmount(ThenaData memory data, uint256 amountIn) private pure returns (uint256) {
+        uint256 numer0 = ((TWO - FEE_DENOMINATOR) * data.reserve0) / FEE_DENOMINATOR;
         uint256 numer1 = PMath.square(numer0);
         uint256 numer2 = 4 * PMath.square(ONE - data.fee) * amountIn * data.reserve0;
 
         uint256 numer = PMath.sqrt(numer1 + numer2) - numer0;
         uint256 denom = 2 * PMath.square(ONE - data.fee);
 
-        return numer * FEE_DENOMINATOR / denom;
+        return (numer * FEE_DENOMINATOR) / denom;
     }
 
     function _getStableZapAmount(
@@ -71,23 +64,13 @@ abstract contract ThenaMath {
 
         while (!PMath.isAApproxB(params.guessMin, params.guessMax, binarySearchEps)) {
             params.amountSwapIn = (params.guessMax + params.guessMin) / 2;
-            params.amount1ToAddLiq = IThenaPair(data.pair).getAmountOut(
-                params.amountSwapIn,
-                tokenIn
-            );
-
-            params.newReserve0 = _getReserveAfterSwap(
-                params.amountSwapIn,
-                data.reserve0,
-                data.fee
-            );
+            params.amount1ToAddLiq = IThenaPair(data.pair).getAmountOut(params.amountSwapIn, tokenIn);
+
+            params.newReserve0 = _getReserveAfterSwap(params.amountSwapIn, data.reserve0, data.fee);
             params.newReserve1 = data.reserve1 - params.amount1ToAddLiq;
             params.amount0ToAddLiq = amountIn - params.amountSwapIn;
 
-            if (
-                params.amount0ToAddLiq * params.newReserve1 <
-                params.amount1ToAddLiq * params.newReserve0
-            ) {
+            if (params.amount0ToAddLiq * params.newReserve1 < params.amount1ToAddLiq * params.newReserve0) {
                 params.guessMax = params.amountSwapIn - 1; // need swap less
             } else {
                 params.guessMin = params.amountSwapIn + 1; // swap more
@@ -112,11 +95,7 @@ abstract contract ThenaMath {
         params.guessMax = (params.guessMin * FEE_DENOMINATOR) / (FEE_DENOMINATOR - data.fee);
     }
 
-    function _getReserveAfterSwap(
-        uint256 amountIn,
-        uint256 reserve,
-        uint256 fee
-    ) internal pure returns (uint256) {
+    function _getReserveAfterSwap(uint256 amountIn, uint256 reserve, uint256 fee) internal pure returns (uint256) {
         return reserve + amountIn - (amountIn * fee) / FEE_DENOMINATOR;
     }
 

package/contracts/core/StandardizedYield/implementations/Thena/ThenaPreview.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "./ThenaMath.sol";
 
@@ -14,12 +14,7 @@ interface IThenaSY {
     function pair() external view returns (address);
 }
 
-contract ThenaPreview is
-    IPendlePreviewHelper,
-    ThenaMath,
-    BoringOwnableUpgradeable,
-    UUPSUpgradeable
-{
+contract ThenaPreview is IPendlePreviewHelper, ThenaMath, BoringOwnableUpgradeable, UUPSUpgradeable {
     using PMath for uint256;
 
     address internal immutable factory;
@@ -35,10 +30,7 @@ contract ThenaPreview is
     // solhint-disable-next-line
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 
-    function previewDeposit(
-        address tokenIn,
-        uint256 amountTokenIn
-    ) external view returns (uint256 amountLpOut) {
+    function previewDeposit(address tokenIn, uint256 amountTokenIn) external view returns (uint256 amountLpOut) {
         address pair = IThenaSY(msg.sender).pair();
 
         ThenaData memory data = _getNormalizedPairData(pair, tokenIn);
@@ -79,22 +71,15 @@ contract ThenaPreview is
     }
 
     // @reference: Camelot
-    function _getSwapAmountOut(
-        ThenaData memory data,
-        uint256 amountIn
-    ) internal pure returns (uint256) {
+    function _getSwapAmountOut(ThenaData memory data, uint256 amountIn) internal pure returns (uint256) {
         if (!data.isStable) {
             amountIn = amountIn * (FEE_DENOMINATOR - data.fee);
             return (amountIn * data.reserve1) / (data.reserve0 * FEE_DENOMINATOR + amountIn);
         } else {
-            amountIn = (amountIn - (amountIn * data.fee) / FEE_DENOMINATOR).divDown(
-                data.decimals0
-            );
+            amountIn = (amountIn - (amountIn * data.fee) / FEE_DENOMINATOR).divDown(data.decimals0);
             uint256 reserveA = data.reserve0.divDown(data.decimals0);
             uint256 reserveB = data.reserve1.divDown(data.decimals1);
-            uint256 xy = reserveA.mulDown(reserveB).mulDown(
-                reserveA.squareDown() + reserveB.squareDown()
-            );
+            uint256 xy = reserveA.mulDown(reserveB).mulDown(reserveA.squareDown() + reserveB.squareDown());
             uint256 y = reserveB - _get_y(amountIn + reserveA, xy, reserveB);
             return y.mulDown(data.decimals1);
         }
@@ -117,25 +102,14 @@ contract ThenaPreview is
         }
 
         uint256 supply = IThenaPair(data.pair).totalSupply();
-        return
-            PMath.min(
-                (amount0ToAddLiq * supply) / data.reserve0,
-                (amount1ToAddLiq * supply) / data.reserve1
-            );
+        return PMath.min((amount0ToAddLiq * supply) / data.reserve0, (amount1ToAddLiq * supply) / data.reserve1);
     }
 
-    function _quote(
-        uint256 amountA,
-        uint256 reserveA,
-        uint256 reserveB
-    ) private pure returns (uint256 amountB) {
+    function _quote(uint256 amountA, uint256 reserveA, uint256 reserveB) private pure returns (uint256 amountB) {
         amountB = (amountA * reserveB) / reserveA;
     }
 
-    function _getNormalizedPairData(
-        address pair,
-        address pivotToken
-    ) internal view returns (ThenaData memory data) {
+    function _getNormalizedPairData(address pair, address pivotToken) internal view returns (ThenaData memory data) {
         data.pair = pair;
         data.isStable = IThenaPair(pair).isStable();
         data.fee = IThenaFactory(factory).getFee(data.isStable);
@@ -180,11 +154,7 @@ contract ThenaPreview is
     }
 
     function _f(uint256 x0, uint256 y) internal pure returns (uint256) {
-        return
-            (x0 * ((((y * y) / 1e18) * y) / 1e18)) /
-            1e18 +
-            (((((x0 * x0) / 1e18) * x0) / 1e18) * y) /
-            1e18;
+        return (x0 * ((((y * y) / 1e18) * y) / 1e18)) / 1e18 + (((((x0 * x0) / 1e18) * x0) / 1e18) * y) / 1e18;
     }
 
     function _d(uint256 x0, uint256 y) internal pure returns (uint256) {

package/contracts/core/YieldContracts/InterestManagerYT.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/IPYieldToken.sol";
 import "../../interfaces/IPPrincipalToken.sol";
@@ -36,10 +36,8 @@ abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
 
     function _distributeInterestForTwo(address user1, address user2) internal {
         uint256 index = _getInterestIndex();
-        if (user1 != address(0) && user1 != address(this))
-            _distributeInterestPrivate(user1, index);
-        if (user2 != address(0) && user2 != address(this))
-            _distributeInterestPrivate(user2, index);
+        if (user1 != address(0) && user1 != address(this)) _distributeInterestPrivate(user1, index);
+        if (user2 != address(0) && user2 != address(this)) _distributeInterestPrivate(user2, index);
     }
 
     function _doTransferOutInterest(
@@ -74,9 +72,7 @@ abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
 
         uint256 principal = _YTbalance(user);
 
-        uint256 interestFromYT = (principal * (currentIndex - prevIndex)).divDown(
-            prevIndex * currentIndex
-        );
+        uint256 interestFromYT = (principal * (currentIndex - prevIndex)).divDown(prevIndex * currentIndex);
 
         userInterest[user].accrued += interestFromYT.Uint128();
         userInterest[user].index = currentIndex.Uint128();

package/contracts/core/YieldContracts/PendlePrincipalToken.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/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -21,7 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPYieldContractFactory.sol";
 
@@ -106,8 +106,7 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
         uint32 expiry,
         bool doCacheIndexSameBlock
     ) external returns (address PT, address YT) {
-        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0)
-            revert Errors.YCFactoryInvalidExpiry();
+        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0) revert Errors.YCFactoryInvalidExpiry();
 
         if (getPT[SY][expiry] != address(0)) revert Errors.YCFactoryYieldContractExisted();
 

package/contracts/core/YieldContracts/PendleYieldToken.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";
 
@@ -23,12 +23,7 @@ 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,
-    PendleERC20Permit,
-    RewardManagerAbstract,
-    InterestManagerYT
-{
+contract PendleYieldToken is IPYieldToken, PendleERC20Permit, RewardManagerAbstract, InterestManagerYT {
     using PMath for uint256;
     using SafeERC20 for IERC20;
     using ArrayLib for uint256[];
@@ -98,11 +93,7 @@ contract PendleYieldToken is
         address[] memory receiverYTs = new address[](1);
         uint256[] memory amountSyToMints = new uint256[](1);
 
-        (receiverPTs[0], receiverYTs[0], amountSyToMints[0]) = (
-            receiverPT,
-            receiverYT,
-            _getFloatingSyAmount()
-        );
+        (receiverPTs[0], receiverYTs[0], amountSyToMints[0]) = (receiverPT, receiverYT, _getFloatingSyAmount());
 
         uint256[] memory amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
         amountPYOut = amountPYOuts[0];
@@ -117,8 +108,7 @@ contract PendleYieldToken is
         uint256 length = receiverPTs.length;
 
         if (length == 0) revert Errors.ArrayEmpty();
-        if (receiverYTs.length != length || amountSyToMints.length != length)
-            revert Errors.ArrayLengthMismatch();
+        if (receiverYTs.length != length || amountSyToMints.length != length) revert Errors.ArrayLengthMismatch();
 
         uint256 totalSyToMint = amountSyToMints.sum();
         if (totalSyToMint > _getFloatingSyAmount())
@@ -132,9 +122,7 @@ contract PendleYieldToken is
      * same time
      * @dev PT/YT must be transferred to this contract prior to calling
      */
-    function redeemPY(
-        address receiver
-    ) external nonReentrant updateData returns (uint256 amountSyOut) {
+    function redeemPY(address receiver) external nonReentrant updateData returns (uint256 amountSyOut) {
         address[] memory receivers = new address[](1);
         uint256[] memory amounts = new uint256[](1);
         (receivers[0], amounts[0]) = (receiver, _getAmountPYToRedeem());
@@ -307,13 +295,7 @@ contract PendleYieldToken is
             _mint(receiverYTs[i], amountPYOuts[i]);
             IPPrincipalToken(PT).mintByYT(receiverPTs[i], amountPYOuts[i]);
 
-            emit Mint(
-                msg.sender,
-                receiverPTs[i],
-                receiverYTs[i],
-                amountSyToMints[i],
-                amountPYOuts[i]
-            );
+            emit Mint(msg.sender, receiverPTs[i], receiverYTs[i], amountSyToMints[i], amountPYOuts[i]);
         }
     }
 
@@ -335,10 +317,7 @@ contract PendleYieldToken is
 
         for (uint256 i = 0; i < receivers.length; i++) {
             uint256 syInterestPostExpiry;
-            (amountSyOuts[i], syInterestPostExpiry) = _calcSyRedeemableFromPY(
-                amountPYToRedeems[i],
-                index
-            );
+            (amountSyOuts[i], syInterestPostExpiry) = _calcSyRedeemableFromPY(amountPYToRedeems[i], index);
             _transferOut(SY, receivers[i], amountSyOuts[i]);
             totalSyInterestPostExpiry += syInterestPostExpiry;
 
@@ -349,10 +328,7 @@ contract PendleYieldToken is
         }
     }
 
-    function _calcPYToMint(
-        uint256 amountSy,
-        uint256 indexCurrent
-    ) internal pure returns (uint256 amountPY) {
+    function _calcPYToMint(uint256 amountSy, uint256 indexCurrent) internal pure returns (uint256 amountPY) {
         // doesn't matter before or after expiry, since mintPY is only allowed before expiry
         return SYUtils.syToAsset(indexCurrent, amountSy);
     }
@@ -407,12 +383,9 @@ contract PendleYieldToken is
     }
 
     function _pyIndexCurrent() internal returns (uint256 currentIndex) {
-        if (doCacheIndexSameBlock && pyIndexLastUpdatedBlock == block.number)
-            return _pyIndexStored;
+        if (doCacheIndexSameBlock && pyIndexLastUpdatedBlock == block.number) return _pyIndexStored;
 
-        uint128 index128 = PMath
-            .max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored)
-            .Uint128();
+        uint128 index128 = PMath.max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored).Uint128();
 
         currentIndex = index128;
         _pyIndexStored = index128;
@@ -491,16 +464,11 @@ contract PendleYieldToken is
         return SYUtils.assetToSy(index, balanceOf(user)) + userInterest[user].accrued;
     }
 
-    function _updateRewardIndex()
-        internal
-        override
-        returns (address[] memory tokens, uint256[] memory indexes)
-    {
+    function _updateRewardIndex() internal override returns (address[] memory tokens, uint256[] memory indexes) {
         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();
         }