@pendle/core-v2 6.3.0-fee-setter → 6.3.0-sweedtest

package/contracts/offchain-helpers/Broadcaster.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../interfaces/IPVotingController.sol";
 import "../LiquidityMining/libraries/WeekMath.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/TokenHelper.sol";
+import "../interfaces/IPVotingController.sol";
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/Proxy.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
 contract Broadcaster is Initializable, BoringOwnableUpgradeableV2, UUPSUpgradeable, TokenHelper {
     IPVotingController public immutable votingController;
@@ -28,7 +28,7 @@ contract Broadcaster is Initializable, BoringOwnableUpgradeableV2, UUPSUpgradeab
         lastBroadcastedWeek = currentWeek;
 
         votingController.finalizeEpoch();
-        for (uint256 i = 0; i < chainIds.length; ) {
+        for (uint256 i = 0; i < chainIds.length;) {
             uint64 chainId = chainIds[i];
             uint256 fee = votingController.getBroadcastResultFee(chainId);
             votingController.broadcastResults{value: fee}(chainId);

package/contracts/offchain-helpers/BytesLib.sol

@@ -439,8 +439,8 @@ library BytesLib {
                 let cc := add(_postBytes, 0x20)
 
                 for {
-                    // the next line is the loop condition:
-                    // while(uint256(mc < endWord) + cb == 2)
+                // the next line is the loop condition:
+                // while(uint256(mc < endWord) + cb == 2)
                 } eq(add(lt(mc, endMinusWord), cb), 2) {
                     mc := add(mc, 0x20)
                     cc := add(cc, 0x20)
@@ -527,9 +527,7 @@ library BytesLib {
 
                         // the next line is the loop condition:
                         // while(uint256(mc < end) + cb == 2)
-                        for {
-
-                        } eq(add(lt(mc, end), cb), 2) {
+                        for {} eq(add(lt(mc, end), cb), 2) {
                             sc := add(sc, 1)
                             mc := add(mc, 0x20)
                         } {

package/contracts/offchain-helpers/EmptyUUPS.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.8.17;
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
 contract EmptyUUPS is Initializable, UUPSUpgradeable, BoringOwnableUpgradeableV2 {
     constructor() initializer {}

package/contracts/offchain-helpers/ExpiredLpPtRedeemer.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: SEE LICENSE IN LICENSE
 pragma solidity ^0.8.0;
 
-import "../router/base/ActionBase.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../interfaces/IPActionMiscV3.sol";
 import "../interfaces/IPReflector.sol";
-import "../core/libraries/BoringOwnableUpgradeableV2.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../router/base/ActionBase.sol";
 import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
 contract ExpiredLpPtRedeemer is TokenHelper, ReentrancyGuardUpgradeable, BoringOwnableUpgradeableV2, UUPSUpgradeable {
     mapping(address => bool) public whitelistedMarkets;
@@ -46,11 +46,8 @@ contract ExpiredLpPtRedeemer is TokenHelper, ReentrancyGuardUpgradeable, BoringO
 
         if (netLpIn > 0) {
             _transferFrom(IERC20(market), msg.sender, market, netLpIn);
-            (uint256 netSyFromRemove, uint256 netPtFromRemove) = IPMarket(market).burn(
-                address(this),
-                address(this),
-                netLpIn
-            );
+            (uint256 netSyFromRemove, uint256 netPtFromRemove) =
+                IPMarket(market).burn(address(this), address(this), netLpIn);
 
             totalSyRedeem += netSyFromRemove;
             totalPtRedeem += netPtFromRemove;

package/contracts/offchain-helpers/LegacyNFTHelper.sol

@@ -20,11 +20,7 @@ interface StarNFTV1 {
     event ApprovalForAll(address indexed account, address indexed operator, bool approved);
     event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
     event TransferBatch(
-        address indexed operator,
-        address indexed from,
-        address indexed to,
-        uint256[] ids,
-        uint256[] values
+        address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values
     );
     event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
     event URI(string value, uint256 indexed id);

package/contracts/offchain-helpers/LimitBackendHelperV2.sol

@@ -2,11 +2,11 @@
 
 pragma solidity ^0.8.17;
 
-import "../interfaces/IPLimitRouter.sol";
+import "../core/libraries/Errors.sol";
 import "../core/libraries/TokenHelper.sol";
+import "../interfaces/IPLimitRouter.sol";
 import "../interfaces/IStandardizedYield.sol";
 import "../interfaces/IWETH.sol";
-import "../core/libraries/Errors.sol";
 import "./BytesLib.sol";
 
 contract LimitBackendHelperV2 is TokenHelper {
@@ -19,11 +19,11 @@ contract LimitBackendHelperV2 is TokenHelper {
     }
 
     /// @notice vanilla read
-    function readSingleToken(
-        address token,
-        address[] calldata owners,
-        address spender
-    ) public view returns (uint256[] memory balances, uint256[] memory allowances) {
+    function readSingleToken(address token, address[] calldata owners, address spender)
+        public
+        view
+        returns (uint256[] memory balances, uint256[] memory allowances)
+    {
         balances = new uint256[](owners.length);
         allowances = new uint256[](owners.length);
         for (uint256 i = 0; i < owners.length; i++) {
@@ -33,11 +33,11 @@ contract LimitBackendHelperV2 is TokenHelper {
     }
 
     /// @notice auto return balances and allowances the input tokens of the orders, based on type
-    function readMultiTokens(
-        address[] calldata tokens,
-        address[] calldata owners,
-        address spender
-    ) public view returns (uint256[] memory balances, uint256[] memory allowances) {
+    function readMultiTokens(address[] calldata tokens, address[] calldata owners, address spender)
+        public
+        view
+        returns (uint256[] memory balances, uint256[] memory allowances)
+    {
         require(tokens.length == owners.length, "Length mismatch");
         balances = new uint256[](owners.length);
         allowances = new uint256[](owners.length);

package/contracts/offchain-helpers/MarketSweed.sol

@@ -0,0 +1,246 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.17;
+
+import "../interfaces/IPMarket.sol";
+import "../router/math/MarketApproxLibOnchain.sol";
+import "../router/base/ActionBase.sol";
+import "../interfaces/IMarketSweed.sol";
+
+contract MarketSweed is ActionBase, IMarketSweed {
+    using PMath for uint256;
+    using PMath for int256;
+    using PYIndexLib for PYIndex;
+    using MarketMathCore for MarketState;
+    using PYIndexLib for IPYieldToken;
+
+    struct MarketTokens {
+        IStandardizedYield SY;
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+    }
+
+    // solhint-disable no-empty-blocks
+    constructor() {}
+
+    function seedAtImpliedRate(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input,
+        ApproxSweedParams calldata sweedParams
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut, int256 guessedAmountPtToSwap) {
+        MarketTokens memory tokens;
+        (tokens.SY, tokens.PT, tokens.YT) = IPMarket(market).readTokens();
+
+        _mintSyFromToken(address(this), address(tokens.SY), 1, input);
+
+        uint256 netPtOut;
+        (netPtOut, netYtOut, guessedAmountPtToSwap) = _swap(receiver, market, tokens, sweedParams);
+
+        uint256 netYtFromSeed;
+        (netLpOut, netYtFromSeed, ) = _seed(receiver, market, tokens, _selfBalance(tokens.SY), netPtOut);
+        netYtOut += netYtFromSeed;
+
+        if (netLpOut < minLpOut) revert("Slippage: INSUFFICIENT_LP_OUT");
+        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
+    }
+
+    function mintPYFromToken__noCall(
+        address YT,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPYOut) {
+        address SY = IPYieldToken(YT).SY();
+        _mintSyFromToken(YT, SY, 1, input);
+        netPYOut = IPYieldToken(YT).mintPY(msg.sender, msg.sender);
+    }
+
+    function _seed(
+        address receiver,
+        address market,
+        MarketTokens memory tokens,
+        uint256 netSyIn,
+        uint256 netPtIn
+    ) internal returns (uint256 /*netLpOut*/, uint256 /*netYtOut*/, uint256 /*netSyMintPy*/) {
+        uint256 netSyMintPy = _calcSyToMintPYSeed(market, tokens, netSyIn, netPtIn);
+
+        // transfer SY to mint PY
+        _transferOut(address(tokens.SY), address(tokens.YT), netSyMintPy);
+        uint256 netPYMinted = tokens.YT.mintPY(market, receiver);
+
+        // the rest of SY goes to market
+        uint256 netSyAddLiquidity = netSyIn - netSyMintPy;
+        _transferOut(address(tokens.SY), market, netSyAddLiquidity);
+        _transferOut(address(tokens.PT), market, netPtIn);
+
+        (uint256 netLpOut, , ) = IPMarket(market).mint(receiver, netSyAddLiquidity, netPYMinted + netPtIn);
+        return (netLpOut, netPYMinted, netSyMintPy);
+    }
+
+    function _swap(
+        address receiver,
+        address market,
+        MarketTokens memory tokens,
+        ApproxSweedParams memory sweedParams
+    ) internal returns (uint256 amountPtToAccount, uint256 amountYTToAccount, int256 guessedSwap) {
+        PYIndex index = _getPYIndex(market);
+        MarketState memory state = _readMarket(market);
+        MarketPreCompute memory comp = state.getMarketPreCompute(index, block.timestamp);
+
+        if (state.lastLnImpliedRate > sweedParams.targetLnImpliedRate) {
+            // Normalize maxPtToSwap
+            sweedParams.maxPtToSwap = PMath.min(
+                sweedParams.maxPtToSwap,
+                MarketApproxPtOutLibOnchain.calcMaxPtOut(comp, state.totalPt)
+            );
+
+            int256 amountSyToAccount;
+
+            (guessedSwap, amountSyToAccount) = _calcAmountPtToBuy(state, index, sweedParams);
+            amountPtToAccount = guessedSwap.Uint();
+
+            _transferOut(address(tokens.SY), market, amountSyToAccount.abs());
+            IPMarket(market).swapSyForExactPt(address(this), guessedSwap.abs(), EMPTY_BYTES);
+        } else {
+            // Normalize maxPtToSwap
+            sweedParams.maxPtToSwap = PMath.min(
+                sweedParams.maxPtToSwap,
+                MarketApproxPtInLibOnchain.calcSoftMaxPtIn(state, comp)
+            );
+
+            guessedSwap = _calcAmountPtToSell(state, index, sweedParams);
+
+            uint256 amountPtToSell = guessedSwap.neg().Uint();
+            amountYTToAccount = amountPtToSell;
+
+            _transferOut(address(tokens.SY), address(tokens.YT), index.assetToSyUp(amountPtToSell));
+            uint256 amountPYOut = tokens.YT.mintPY(market, receiver);
+
+            assert(amountPYOut >= amountPtToSell);
+
+            // this amount of SY will be used to add liquidity in later step
+            IPMarket(market).swapExactPtForSy(address(this), amountPtToSell, EMPTY_BYTES);
+        }
+    }
+
+    function _calcAmountPtToBuy(
+        MarketState memory state,
+        PYIndex index,
+        ApproxSweedParams memory sweedParams
+    ) internal view returns (int256 amountPtToSwapToAccount, int256 amountSyToAccount) {
+        int256 refAmt = sweedParams.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+        MarketState memory localState;
+
+        for (uint256 iter = 0; iter < sweedParams.maxIteration; ++iter) {
+            int256 guess;
+            if (iter == 0 && _isValidGuessOffchain(sweedParams, true)) {
+                guess = sweedParams.guessOffchain;
+            } else {
+                refAmt /= 2;
+                guess = accPtToAccount + refAmt;
+            }
+
+            _makeACopyTo(state, localState);
+            // Will not revert. maxPtToBuy should already be normalized
+            (int256 localAmountSyToAccount, , ) = localState.executeTradeCore(index, guess, block.timestamp);
+
+            if (PMath.isAApproxB(localState.lastLnImpliedRate, sweedParams.targetLnImpliedRate, sweedParams.eps)) {
+                return (guess, localAmountSyToAccount);
+            }
+
+            if (localState.lastLnImpliedRate > sweedParams.targetLnImpliedRate) {
+                accPtToAccount = guess;
+            }
+        }
+        revert("_calcAmountPtToBuy: failed");
+    }
+
+    function _calcAmountPtToSell(
+        MarketState memory state,
+        PYIndex index,
+        ApproxSweedParams memory sweedParams
+    ) internal view returns (int256 amountPtToSwapToAccount) {
+        int256 refAmt = sweedParams.maxPtToSwap.Int();
+        int256 accPtToAccount = 0;
+        MarketState memory localState;
+
+        for (uint256 iter = 0; iter < sweedParams.maxIteration; ++iter) {
+            int256 guess;
+            if (iter == 0 && _isValidGuessOffchain(sweedParams, false)) {
+                guess = sweedParams.guessOffchain;
+            } else {
+                refAmt /= 2;
+                guess = accPtToAccount - refAmt;
+            }
+
+            _makeACopyTo(state, localState);
+
+            // Will not revert. maxPtToSell should already be normalized
+            localState.executeTradeCore(index, guess, block.timestamp);
+
+            if (PMath.isAApproxB(localState.lastLnImpliedRate, sweedParams.targetLnImpliedRate, sweedParams.eps)) {
+                return guess;
+            }
+
+            if (localState.lastLnImpliedRate < sweedParams.targetLnImpliedRate) {
+                accPtToAccount = guess;
+            }
+        }
+        revert("_calcAmountPtToSell: failed");
+    }
+
+    function _calcSyToMintPYSeed(
+        address market,
+        MarketTokens memory tokens,
+        uint256 netSyIn,
+        uint256 netPtIn
+    ) internal returns (uint256 /* netSyMintPy */) {
+        uint256 netSyMintPy = netSyIn;
+        if (netPtIn > 0) {
+            (, , uint256 netSyDual, uint256 netPtDual) = _readMarket(market).addLiquidity(
+                netSyIn,
+                netPtIn,
+                block.timestamp
+            );
+            if (netPtDual < netPtIn) {
+                revert("MS: Bought too much PT");
+            }
+            netSyMintPy -= netSyDual;
+        }
+
+        MarketState memory state = _readMarket(market);
+        PYIndex pyIndex = tokens.YT.newIndex();
+        netSyMintPy =
+            (netSyMintPy * state.totalPt.Uint()) /
+            (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
+
+        return netSyMintPy;
+    }
+
+    function _getPYIndex(address market) internal returns (PYIndex) {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        return PYIndex.wrap(YT.pyIndexCurrent());
+    }
+
+    function _makeACopyTo(MarketState memory state, MarketState memory copiedState) internal pure {
+        copiedState.totalPt = state.totalPt;
+        copiedState.totalSy = state.totalSy;
+        copiedState.totalLp = state.totalLp;
+        copiedState.treasury = state.treasury;
+
+        copiedState.scalarRoot = state.scalarRoot;
+        copiedState.expiry = state.expiry;
+
+        copiedState.lnFeeRateRoot = state.lnFeeRateRoot;
+        copiedState.reserveFeePercent = state.reserveFeePercent;
+        copiedState.lastLnImpliedRate = state.lastLnImpliedRate;
+    }
+
+    function _isValidGuessOffchain(ApproxSweedParams memory sweedParams, bool isBuyingPt) internal pure returns (bool) {
+        if (sweedParams.guessOffchain == 0) return false;
+        if (isBuyingPt != (sweedParams.guessOffchain > 0)) return false;
+        return sweedParams.guessOffchain.abs() <= sweedParams.maxPtToSwap;
+    }
+}

package/contracts/offchain-helpers/Multicall2.sol

@@ -11,6 +11,7 @@ contract Multicall2 {
         address target;
         bytes callData;
     }
+
     struct Result {
         bool success;
         bytes returnData;
@@ -26,9 +27,10 @@ contract Multicall2 {
         }
     }
 
-    function blockAndAggregate(
-        Call[] memory calls
-    ) public returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData) {
+    function blockAndAggregate(Call[] memory calls)
+        public
+        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)
+    {
         (blockNumber, blockHash, returnData) = tryBlockAndAggregate(true, calls);
     }
 
@@ -77,10 +79,10 @@ contract Multicall2 {
         }
     }
 
-    function tryBlockAndAggregate(
-        bool requireSuccess,
-        Call[] memory calls
-    ) public returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData) {
+    function tryBlockAndAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)
+    {
         blockNumber = block.number;
         blockHash = blockhash(block.number);
         returnData = tryAggregate(requireSuccess, calls);

package/contracts/offchain-helpers/PendleExchangeRateOracle.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.17;
 
-import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/math/PMath.sol";
 import "../interfaces/IPExchangeRateOracle.sol";
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 
 contract PendleExchangeRateOracle is BoringOwnableUpgradeableV2, IPExchangeRateOracle {
     using PMath for uint256;
@@ -45,10 +45,7 @@ contract PendleExchangeRateOracle is BoringOwnableUpgradeableV2, IPExchangeRateO
 
     function setExchangeRate(uint128 rate, uint64 dataBlock, uint32 dataTimestamp) external onlyOwner {
         ExchangeRateData memory newData = ExchangeRateData({
-            rate: rate,
-            dataBlock: dataBlock,
-            dataTimestamp: dataTimestamp,
-            updatedAt: uint32(block.timestamp)
+            rate: rate, dataBlock: dataBlock, dataTimestamp: dataTimestamp, updatedAt: uint32(block.timestamp)
         });
         _setExchangeRate(newData);
     }
@@ -75,9 +72,8 @@ contract PendleExchangeRateOracle is BoringOwnableUpgradeableV2, IPExchangeRateO
 
     function _validateMetadata(ExchangeRateData memory oldData, ExchangeRateData memory newData) internal pure {
         if (
-            oldData.dataBlock >= newData.dataBlock ||
-            oldData.dataTimestamp >= newData.dataTimestamp ||
-            oldData.updatedAt + MIN_UPDATE_TIME_GAP >= newData.updatedAt
+            oldData.dataBlock >= newData.dataBlock || oldData.dataTimestamp >= newData.dataTimestamp
+                || oldData.updatedAt + MIN_UPDATE_TIME_GAP >= newData.updatedAt
         ) {
             revert InvalidMetadata(newData);
         }

package/contracts/offchain-helpers/PendleFeeSetter.sol

@@ -1,16 +1,16 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
+import {IPGovernanceProxy} from "../interfaces/IPGovernanceProxy.sol";
 import {IPLimitRouter} from "../interfaces/IPLimitRouter.sol";
 import {IPMarket, MarketState} from "../interfaces/IPMarket.sol";
 import {IPMarketFactory} from "../interfaces/IPMarketFactory.sol";
 import {IPYieldToken} from "../interfaces/IPYieldToken.sol";
-import {IPGovernanceProxy} from "../interfaces/IPGovernanceProxy.sol";
 
-import {PMath} from "../core/libraries/math/PMath.sol";
-import {LogExpMath} from "../core/libraries/math/LogExpMath.sol";
 import {BoringOwnableUpgradeableV2} from "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import {Errors} from "../core/libraries/Errors.sol";
+import {LogExpMath} from "../core/libraries/math/LogExpMath.sol";
+import {PMath} from "../core/libraries/math/PMath.sol";
 
 contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
     using PMath for uint256;
@@ -20,7 +20,7 @@ contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
     event FeeFactorSet(uint128 impliedRateToFeeFactor, uint128 routerLnFeeToLimitLnFeeFactor);
     event SetterSet(address indexed setter);
 
-    uint256 internal constant LIMIT_MAX_LN_FEE_RATE_ROOT = 48790164169432003; // ln(1.05)
+    uint256 internal constant LIMIT_MAX_LN_FEE_RATE_ROOT = 48_790_164_169_432_003; // ln(1.05)
 
     address public immutable router;
     IPLimitRouter public immutable limitRouter;
@@ -42,11 +42,10 @@ contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
         govProxy = IPGovernanceProxy(_govProxy);
     }
 
-    function initialize(
-        address _owner,
-        uint128 _impliedRateToFeeFactor,
-        uint128 _routerLnFeeToLimitLnFeeFactor
-    ) external initializer {
+    function initialize(address _owner, uint128 _impliedRateToFeeFactor, uint128 _routerLnFeeToLimitLnFeeFactor)
+        external
+        initializer
+    {
         __BoringOwnableV2_init(_owner);
         _setFeeFactors(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor);
     }
@@ -62,37 +61,31 @@ contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
         uint256 _impliedRateToFeeFactor = impliedRateToFeeFactor;
         uint256 _routerLnFeeToLimitLnFeeFactor = routerLnFeeToLimitLnFeeFactor;
         for (uint256 i = 0; i < n; ++i) {
-            (, , IPYieldToken yt) = IPMarket(markets[i]).readTokens();
-            (uint256 routerLnFeeRateRoot, uint256 limitLnFeeRateRoot) = _calcFee(
-                _impliedRateToFeeFactor,
-                _routerLnFeeToLimitLnFeeFactor,
-                markets[i]
-            );
+            (,, IPYieldToken yt) = IPMarket(markets[i]).readTokens();
+            (uint256 routerLnFeeRateRoot, uint256 limitLnFeeRateRoot) =
+                _calcFee(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor, markets[i]);
 
             YTs[i] = address(yt);
             limitLnFeeRateRoots[i] = limitLnFeeRateRoot;
 
             calls[i].target = IPMarket(markets[i]).factory();
-            calls[i].callData = abi.encodeCall(
-                IPMarketFactory.setOverriddenFee,
-                (router, markets[i], routerLnFeeRateRoot.Uint80())
-            );
+            calls[i].callData =
+                abi.encodeCall(IPMarketFactory.setOverriddenFee, (router, markets[i], routerLnFeeRateRoot.Uint80()));
         }
 
         calls[n].target = address(limitRouter);
         calls[n].callData = abi.encodeCall(
-            IPLimitRouter.setLnFeeRateRoots,
-            (YTs, limitLnFeeRateRoots, /* allowZeroFees */ false)
+            IPLimitRouter.setLnFeeRateRoots, (YTs, limitLnFeeRateRoots, /* allowZeroFees */ false)
         );
 
         govProxy.aggregateWithScopedAccess(calls);
     }
 
-    function _calcFee(
-        uint256 _impliedRateToFeeFactor,
-        uint256 _routerLnFeeToLimitLnFeeFactor,
-        address market
-    ) internal view returns (uint256 routerLnFeeRateRoot, uint256 limitLnFeeRateRoot) {
+    function _calcFee(uint256 _impliedRateToFeeFactor, uint256 _routerLnFeeToLimitLnFeeFactor, address market)
+        internal
+        view
+        returns (uint256 routerLnFeeRateRoot, uint256 limitLnFeeRateRoot)
+    {
         uint256 marketLnFee = IPMarket(market).getNonOverrideLnFeeRateRoot();
         MarketState memory state = IPMarket(market).readState(router);
         uint256 impliedRate = state.lastLnImpliedRate.Int().exp().Uint();
@@ -101,17 +94,14 @@ contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
         uint256 newLnFeeRateRoot = newFee.Int().ln().Uint();
 
         routerLnFeeRateRoot = marketLnFee.min(newLnFeeRateRoot);
-        limitLnFeeRateRoot = LIMIT_MAX_LN_FEE_RATE_ROOT.min(
-            routerLnFeeRateRoot.mulDown(_routerLnFeeToLimitLnFeeFactor)
-        );
+        limitLnFeeRateRoot = LIMIT_MAX_LN_FEE_RATE_ROOT.min(routerLnFeeRateRoot.mulDown(_routerLnFeeToLimitLnFeeFactor));
 
-        // Fix up `routerLnFeeRateRoot` for this case: https://github.com/pendle-finance/pendle-core-v2/blob/6169376d0a8c12030307e3d64d02e84b07ffe4f9/contracts/core/Market/v3/PendleMarketFactoryV3.sol#L131-L135
+        // Fix up `routerLnFeeRateRoot` for this case:
+        // https://github.com/pendle-finance/pendle-core-v2/blob/6169376d0a8c12030307e3d64d02e84b07ffe4f9/contracts/core/Market/v3/PendleMarketFactoryV3.sol#L131-L135
         if (routerLnFeeRateRoot == marketLnFee) routerLnFeeRateRoot = 0;
     }
 
-    function readFeesAndImpliedRate(
-        address[] memory markets
-    )
+    function readFeesAndImpliedRate(address[] memory markets)
         external
         view
         returns (
@@ -130,7 +120,7 @@ contract PendleFeeSetter is BoringOwnableUpgradeableV2 {
             routerLnFeeRateRoots[i] = state.lnFeeRateRoot;
             lnImpliedRates[i] = state.lastLnImpliedRate;
 
-            (, , IPYieldToken yt) = IPMarket(markets[i]).readTokens();
+            (,, IPYieldToken yt) = IPMarket(markets[i]).readTokens();
             try limitRouter.getLnFeeRateRoot(address(yt)) returns (uint256 _fee) {
                 limitLnFeeRateRoots[i] = _fee;
             } catch {

package/contracts/offchain-helpers/PendleGovernanceProxy.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
-import "../interfaces/IPPausingInterface.sol";
 import "../interfaces/IPGovernanceProxy.sol";
+import "../interfaces/IPPausingInterface.sol";
 import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
@@ -31,8 +31,8 @@ contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPG
     // to execute calls
 
     mapping(address caller => mapping(bytes4 selector => bool isAdmin)) public isSelectorAdminOf;
-    mapping(address caller => mapping(bytes4 selector => mapping(address target => bool isAllowed)))
-        public hasScopedAccess;
+    mapping(address caller => mapping(bytes4 selector => mapping(address target => bool isAllowed))) public
+        hasScopedAccess;
 
     modifier onlyGuardian() {
         require(hasRole(GUARDIAN, msg.sender) || hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "PGP: n/a");
@@ -65,12 +65,9 @@ contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPG
         }
     }
 
-    function modifyScopedAccess(
-        address caller,
-        address[] memory targets,
-        bytes4 selector,
-        bool[] memory accesses
-    ) external {
+    function modifyScopedAccess(address caller, address[] memory targets, bytes4 selector, bool[] memory accesses)
+        external
+    {
         require(targets.length == accesses.length, "PGP: Array length mismatch");
         require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender) || isSelectorAdminOf[msg.sender][selector], "PGP: n/a");
 
@@ -95,7 +92,7 @@ contract PendleGovernanceProxy is AccessControlUpgradeable, UUPSUpgradeable, IPG
 
     function pause(address[] calldata addrs) external onlyGuardian {
         uint256 length = addrs.length;
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             IPPausingInterface(addrs[i]).pause();
             unchecked {
                 ++i;

package/contracts/offchain-helpers/PendleLPWrapper.sol

@@ -3,9 +3,9 @@ pragma solidity ^0.8.0;
 
 import "../core/erc20/PendleERC20.sol";
 import "../core/libraries/TokenHelper.sol";
-import "../interfaces/IPMarket.sol";
-import "../interfaces/IPLPWrapperFactory.sol";
 import "../interfaces/ILPWrapper.sol";
+import "../interfaces/IPLPWrapperFactory.sol";
+import "../interfaces/IPMarket.sol";
 
 contract PendleLPWrapper is PendleERC20, TokenHelper, ILPWrapper {
     address public immutable LP;
@@ -32,7 +32,16 @@ contract PendleLPWrapper is PendleERC20, TokenHelper, ILPWrapper {
         _transferOut(LP, receiver, netWrapIn);
     }
 
-    function _beforeTokenTransfer(address /*from*/, address /*to*/, uint256 /*amount*/) internal override {
+    function _beforeTokenTransfer(
+        address,
+        /*from*/
+        address,
+        /*to*/
+        uint256 /*amount*/
+    )
+        internal
+        override
+    {
         if (!isRewardRedemptionDisabled) {
             IPMarket(LP).redeemRewards(address(this));
         }