@pendle/core-v2 6.3.0 → 6.3.1

package/contracts/offchain-helpers/BaseSplitCodeFactoryContract.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/BaseSplitCodeFactory.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 
 contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeableV2 {
     event Deployed(
@@ -17,10 +17,7 @@ contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeableV2 {
         __BoringOwnableV2_init(msg.sender);
     }
 
-    function deploy(
-        string memory name,
-        bytes calldata creationCode
-    )
+    function deploy(string memory name, bytes calldata creationCode)
         external
         onlyOwner
         returns (
@@ -30,8 +27,9 @@ contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeableV2 {
             uint256 creationCodeSizeB
         )
     {
-        (creationCodeContractA, creationCodeSizeA, creationCodeContractB, creationCodeSizeB) = BaseSplitCodeFactory
-            .setCreationCode(creationCode);
+        (
+            creationCodeContractA, creationCodeSizeA, creationCodeContractB, creationCodeSizeB
+        ) = BaseSplitCodeFactory.setCreationCode(creationCode);
         emit Deployed(name, creationCodeContractA, creationCodeSizeA, creationCodeContractB, creationCodeSizeB);
     }
 }

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/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

@@ -0,0 +1,149 @@
+// 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 {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;
+    using PMath for int256;
+    using LogExpMath for int256;
+
+    event FeeFactorSet(uint128 impliedRateToFeeFactor, uint128 routerLnFeeToLimitLnFeeFactor);
+    event SetterSet(address indexed setter);
+
+    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;
+    IPGovernanceProxy public immutable govProxy;
+
+    uint128 public impliedRateToFeeFactor;
+    uint128 public routerLnFeeToLimitLnFeeFactor;
+    address public setter;
+
+    modifier onlyOwnerOrSetter() {
+        require(msg.sender == setter || msg.sender == owner, "not setter or owner");
+        _;
+    }
+
+    constructor(address _router, address _limitRouter, address _govProxy) {
+        _disableInitializers();
+        router = _router;
+        limitRouter = IPLimitRouter(_limitRouter);
+        govProxy = IPGovernanceProxy(_govProxy);
+    }
+
+    function initialize(address _owner, uint128 _impliedRateToFeeFactor, uint128 _routerLnFeeToLimitLnFeeFactor)
+        external
+        initializer
+    {
+        __BoringOwnableV2_init(_owner);
+        _setFeeFactors(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor);
+    }
+
+    function setFees(address[] memory markets) external onlyOwnerOrSetter {
+        uint256 n = markets.length;
+
+        IPGovernanceProxy.Call[] memory calls = new IPGovernanceProxy.Call[](n + 1);
+
+        address[] memory YTs = new address[](n);
+        uint256[] memory limitLnFeeRateRoots = new uint256[](n);
+
+        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]);
+
+            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[n].target = address(limitRouter);
+        calls[n].callData = abi.encodeCall(
+            IPLimitRouter.setLnFeeRateRoots, (YTs, limitLnFeeRateRoots, /* allowZeroFees */ false)
+        );
+
+        govProxy.aggregateWithScopedAccess(calls);
+    }
+
+    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();
+
+        uint256 newFee = (impliedRate - PMath.ONE).mulDown(_impliedRateToFeeFactor) + PMath.ONE;
+        uint256 newLnFeeRateRoot = newFee.Int().ln().Uint();
+
+        routerLnFeeRateRoot = marketLnFee.min(newLnFeeRateRoot);
+        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
+        if (routerLnFeeRateRoot == marketLnFee) routerLnFeeRateRoot = 0;
+    }
+
+    function readFeesAndImpliedRate(address[] memory markets)
+        external
+        view
+        returns (
+            uint256[] memory routerLnFeeRateRoots,
+            uint256[] memory limitLnFeeRateRoots,
+            uint256[] memory lnImpliedRates
+        )
+    {
+        uint256 n = markets.length;
+        routerLnFeeRateRoots = new uint256[](n);
+        limitLnFeeRateRoots = new uint256[](n);
+        lnImpliedRates = new uint256[](n);
+
+        for (uint256 i = 0; i < n; ++i) {
+            MarketState memory state = IPMarket(markets[i]).readState(router);
+            routerLnFeeRateRoots[i] = state.lnFeeRateRoot;
+            lnImpliedRates[i] = state.lastLnImpliedRate;
+
+            (,, IPYieldToken yt) = IPMarket(markets[i]).readTokens();
+            try limitRouter.getLnFeeRateRoot(address(yt)) returns (uint256 _fee) {
+                limitLnFeeRateRoots[i] = _fee;
+            } catch {
+                limitLnFeeRateRoots[i] = 0;
+            }
+        }
+    }
+
+    // ============================== Admin functions ==============================
+
+    function setFeeFactors(uint128 _impliedRateToFeeFactor, uint128 _routerLnFeeToLimitLnFeeFactor) external onlyOwner {
+        _setFeeFactors(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor);
+    }
+
+    function _setFeeFactors(uint128 _impliedRateToFeeFactor, uint128 _routerLnFeeToLimitLnFeeFactor) internal {
+        impliedRateToFeeFactor = _impliedRateToFeeFactor;
+        routerLnFeeToLimitLnFeeFactor = _routerLnFeeToLimitLnFeeFactor;
+
+        emit FeeFactorSet(_impliedRateToFeeFactor, _routerLnFeeToLimitLnFeeFactor);
+    }
+
+    function setSetter(address _setter) external onlyOwner {
+        setter = _setter;
+        emit SetterSet(setter);
+    }
+}

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));
         }

package/contracts/offchain-helpers/PendleLPWrapperFactory.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import "./PendleLPWrapper.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
+import "./PendleLPWrapper.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 
 contract PendleLPWrapperFactory is BoringOwnableUpgradeableV2 {
     event LPWrapperCreated(address indexed lpToken, address indexed wrapper);

package/contracts/offchain-helpers/PendleMulticallV1.sol

@@ -15,7 +15,7 @@ contract PendleMulticallV1 {
     function aggregate(Call[] calldata calls) public payable virtual {
         uint256 length = calls.length;
         Call calldata call;
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call(call.callData);
@@ -31,15 +31,15 @@ contract PendleMulticallV1 {
         }
     }
 
-    function tryAggregate(
-        bool requireSuccess,
-        uint256 gasLimit,
-        Call[] calldata calls
-    ) public payable returns (Result[] memory returnData) {
+    function tryAggregate(bool requireSuccess, uint256 gasLimit, Call[] calldata calls)
+        public
+        payable
+        returns (Result[] memory returnData)
+    {
         uint256 length = calls.length;
         returnData = new Result[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call{gas: gasLimit}(calls[i].callData);

package/contracts/offchain-helpers/PendleMulticallV2.sol

@@ -17,7 +17,7 @@ contract PendleMulticallV2 {
     function aggregate(Call[] calldata calls) public payable virtual {
         uint256 length = calls.length;
         Call calldata call;
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call(call.callData);
@@ -33,15 +33,15 @@ contract PendleMulticallV2 {
         }
     }
 
-    function tryAggregate(
-        bool requireSuccess,
-        uint256 gasLimit,
-        Call[] calldata calls
-    ) public payable returns (Result[] memory returnData) {
+    function tryAggregate(bool requireSuccess, uint256 gasLimit, Call[] calldata calls)
+        public
+        payable
+        returns (Result[] memory returnData)
+    {
         uint256 length = calls.length;
         returnData = new Result[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             call = calls[i];
 
             (bool success, bytes memory resp) = call.target.call{gas: gasLimit}(calls[i].callData);
@@ -59,14 +59,15 @@ contract PendleMulticallV2 {
         }
     }
 
-    function tryAggregateRevert(
-        uint256 gasLimit,
-        Call[] calldata calls
-    ) public payable returns (bytes[] memory returnData) {
+    function tryAggregateRevert(uint256 gasLimit, Call[] calldata calls)
+        public
+        payable
+        returns (bytes[] memory returnData)
+    {
         uint256 length = calls.length;
         returnData = new bytes[](length);
         Call calldata call;
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             call = calls[i];
 
             (, returnData[i]) = address(this).delegatecall{gas: gasLimit}(

package/contracts/offchain-helpers/PendleOffchainStorage.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.17;
 
+import "../interfaces/IPOffchainStorage.sol";
 import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "../interfaces/IPOffchainStorage.sol";
 
 contract PendleOffchainStorage is IPOffchainStorage, UUPSUpgradeable, AccessControlUpgradeable {
     bytes32 public constant MAINTAINER = keccak256("MAINTAINER");

package/contracts/offchain-helpers/PendleWstETHPriceFeed.sol

@@ -1,9 +1,11 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../interfaces/IWstETH.sol";
 import "../interfaces/IPPriceFeed.sol";
-import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+import "../interfaces/IWstETH.sol";
+import {
+    AggregatorV2V3Interface as IChainlinkAggregator
+} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
 
 contract PendleWstETHPriceFeed is IPPriceFeed {
     // solhint-disable immutable-vars-naming

package/contracts/offchain-helpers/SimulateHelper.sol

@@ -10,17 +10,18 @@ contract SimulateHelper {
         original = address(this);
     }
 
-    function multicallRevert(
-        uint256 gasLimit,
-        address[] calldata targets,
-        bytes[] calldata callDatas
-    ) public payable virtual returns (bytes[] memory res, uint256[] memory gasUsed) {
+    function multicallRevert(uint256 gasLimit, address[] calldata targets, bytes[] calldata callDatas)
+        public
+        payable
+        virtual
+        returns (bytes[] memory res, uint256[] memory gasUsed)
+    {
         require(targets.length == callDatas.length, "length mismatch");
 
         uint256 length = callDatas.length;
         res = new bytes[](length);
         gasUsed = new uint256[](length);
-        for (uint256 i = 0; i < length; ) {
+        for (uint256 i = 0; i < length;) {
             uint256 gasBefore = gasleft();
             (, res[i]) = original.delegatecall{gas: gasLimit}(
                 abi.encodeWithSignature("simulate(address,bytes)", targets[i], callDatas[i])