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

package/contracts/offchain-helpers/BalanceReader.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../interfaces/IPMarket.sol";
 import "../interfaces/IStandardizedYield.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
 contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeableV2 {
     struct UserMarketInfo {
@@ -66,12 +66,7 @@ contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeableV2 {
         }
     }
 
-    function _redeemRewards(IPMarket market, address user)
-        internal
-        returns (
-            uint256[] memory /*rewardsOut*/
-        )
-    {
+    function _redeemRewards(IPMarket market, address user) internal returns (uint256[] memory /*rewardsOut*/) {
         try market.redeemRewards(user) returns (uint256[] memory rewardsOut) {
             return rewardsOut;
         } catch {
@@ -79,15 +74,13 @@ contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeableV2 {
         }
     }
 
-    function _redeemDueInterestAndRewards(IPYieldToken YT, address user)
-        internal
-        returns (
-            uint256, /*interestOut*/
-            uint256[] memory /*rewardsOut*/
-        )
-    {
+    function _redeemDueInterestAndRewards(
+        IPYieldToken YT,
+        address user
+    ) internal returns (uint256 /*interestOut*/, uint256[] memory /*rewardsOut*/) {
         try YT.redeemDueInterestAndRewards(user, true, true) returns (
-            uint256 interestOut, uint256[] memory rewardsOut
+            uint256 interestOut,
+            uint256[] memory rewardsOut
         ) {
             return (interestOut, rewardsOut);
         } catch {
@@ -95,12 +88,7 @@ contract BalanceReader is UUPSUpgradeable, BoringOwnableUpgradeableV2 {
         }
     }
 
-    function _claimRewards(IStandardizedYield SY, address user)
-        internal
-        returns (
-            uint256[] memory /*rewardsOut*/
-        )
-    {
+    function _claimRewards(IStandardizedYield SY, address user) internal returns (uint256[] memory /*rewardsOut*/) {
         try SY.claimRewards(user) returns (uint256[] memory rewardsOut) {
             return rewardsOut;
         } catch {

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/BaseSplitCodeFactory.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
+import "../core/libraries/BaseSplitCodeFactory.sol";
 
 contract BaseSplitCodeFactoryContract is BoringOwnableUpgradeableV2 {
     event Deployed(
@@ -17,7 +17,10 @@ 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 (
@@ -27,9 +30,8 @@ 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/Proxy.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/Proxy.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,7 +527,9 @@ 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 "../core/libraries/BoringOwnableUpgradeableV2.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.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 "../core/libraries/BoringOwnableUpgradeableV2.sol";
+import "../router/base/ActionBase.sol";
 import "../interfaces/IPActionMiscV3.sol";
 import "../interfaces/IPReflector.sol";
-import "../router/base/ActionBase.sol";
-import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
 
 contract ExpiredLpPtRedeemer is TokenHelper, ReentrancyGuardUpgradeable, BoringOwnableUpgradeableV2, UUPSUpgradeable {
     mapping(address => bool) public whitelistedMarkets;
@@ -46,8 +46,11 @@ 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,7 +20,11 @@ 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 "../core/libraries/Errors.sol";
-import "../core/libraries/TokenHelper.sol";
 import "../interfaces/IPLimitRouter.sol";
+import "../core/libraries/TokenHelper.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,7 +11,6 @@ contract Multicall2 {
         address target;
         bytes callData;
     }
-
     struct Result {
         bool success;
         bytes returnData;
@@ -27,10 +26,9 @@ 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);
     }
 
@@ -79,10 +77,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,7 +45,10 @@ 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);
     }
@@ -72,8 +75,9 @@ 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/PendleGovernanceProxy.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
-import "../interfaces/IPGovernanceProxy.sol";
 import "../interfaces/IPPausingInterface.sol";
+import "../interfaces/IPGovernanceProxy.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,9 +65,12 @@ 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");
 
@@ -92,7 +95,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/ILPWrapper.sol";
-import "../interfaces/IPLPWrapperFactory.sol";
 import "../interfaces/IPMarket.sol";
+import "../interfaces/IPLPWrapperFactory.sol";
+import "../interfaces/ILPWrapper.sol";
 
 contract PendleLPWrapper is PendleERC20, TokenHelper, ILPWrapper {
     address public immutable LP;
@@ -32,16 +32,7 @@ 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 "../core/libraries/BoringOwnableUpgradeableV2.sol";
-import "./PendleLPWrapper.sol";
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "./PendleLPWrapper.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 
 contract PendleLPWrapperFactory is BoringOwnableUpgradeableV2 {
     event LPWrapperCreated(address indexed lpToken, address indexed wrapper);

package/contracts/offchain-helpers/PendleMerkleDepositor.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+contract PendleMerkleDepositor {
+    using SafeERC20 for IERC20;
+
+    event MerkleDeposit(bytes32 indexed campaignId, address indexed from, address indexed token, uint256 amount);
+
+    address public constant NATIVE = address(0);
+    address public immutable merkleDistributor;
+
+    constructor(address _merkleDistributor) {
+        merkleDistributor = _merkleDistributor;
+    }
+
+    /// @notice The `tokens` array must be sorted in strictly ascending order with no duplicates.
+    function depositToMerkleCampaign(
+        bytes32 campaignId,
+        address[] calldata tokens,
+        uint256[] calldata amounts
+    ) external payable {
+        uint256 length = tokens.length;
+
+        require(length != 0, "PMD: empty array");
+        require(length == amounts.length, "PMD: array length mismatch");
+
+        uint256 amountNative;
+        for (uint256 i = 0; i < length; ++i) {
+            if (i != length - 1) require(_lt(tokens[i], tokens[i + 1]), "PMD: invalid tokens order");
+            if (tokens[i] == NATIVE) amountNative = amounts[i];
+        }
+
+        require(amountNative == msg.value, "PMD: msg.value mismatch");
+
+        for (uint256 i = 0; i < length; ++i) {
+            if (amounts[i] != 0) {
+                uint256 preBalance = _tokenBalance(tokens[i], merkleDistributor);
+                _transferFrom(tokens[i], msg.sender, merkleDistributor, amounts[i]);
+                uint256 amountDeposited = _tokenBalance(tokens[i], merkleDistributor) - preBalance;
+
+                emit MerkleDeposit(campaignId, msg.sender, tokens[i], amountDeposited);
+            }
+        }
+    }
+
+    function _tokenBalance(address token, address account) internal view returns (uint256) {
+        return token == NATIVE ? account.balance : IERC20(token).balanceOf(account);
+    }
+
+    function _transferFrom(address token, address from, address to, uint256 amount) internal {
+        if (token == NATIVE) {
+            (bool success, ) = to.call{value: amount}("");
+            require(success, "PMD: eth send failed");
+        } else {
+            IERC20(token).safeTransferFrom(from, to, amount);
+        }
+    }
+
+    function _lt(address token0, address token1) internal pure returns (bool) {
+        return token0 < token1;
+    }
+}

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,15 +59,14 @@ 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,11 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../interfaces/IPPriceFeed.sol";
 import "../interfaces/IWstETH.sol";
-import {
-    AggregatorV2V3Interface as IChainlinkAggregator
-} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+import "../interfaces/IPPriceFeed.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,18 +10,17 @@ 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])