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

package/contracts/interfaces/IPYieldContractFactory.sol

@@ -52,7 +52,9 @@ interface IPYieldContractFactory {
 
     function isYT(address) external view returns (bool);
 
-    function createYieldContract(address SY, uint32 expiry, bool doCacheIndexSameBlock)
-        external
-        returns (address PT, address YT);
+    function createYieldContract(
+        address SY,
+        uint32 expiry,
+        bool doCacheIndexSameBlock
+    ) external returns (address PT, address YT);
 }

package/contracts/interfaces/IPYieldToken.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
-import "./IPInterestManagerYT.sol";
-import "./IRewardManager.sol";
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "./IRewardManager.sol";
+import "./IPInterestManagerYT.sol";
 
 interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
     event NewInterestIndex(uint256 indexed newIndex);
@@ -27,13 +27,16 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
 
     function redeemPY(address receiver) external returns (uint256 amountSyOut);
 
-    function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
-        external
-        returns (uint256[] memory amountSyOuts);
+    function redeemPYMulti(
+        address[] calldata receivers,
+        uint256[] calldata amountPYToRedeems
+    ) external returns (uint256[] memory amountSyOuts);
 
-    function redeemDueInterestAndRewards(address user, bool redeemInterest, bool redeemRewards)
-        external
-        returns (uint256 interestOut, uint256[] memory rewardsOut);
+    function redeemDueInterestAndRewards(
+        address user,
+        bool redeemInterest,
+        bool redeemRewards
+    ) external returns (uint256 interestOut, uint256[] memory rewardsOut);
 
     function rewardIndexesCurrent() external returns (uint256[] memory);
 

package/contracts/interfaces/IPYieldTokenV2.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
-import "./IPInterestManagerYTV2.sol";
-import "./IRewardManager.sol";
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "./IRewardManager.sol";
+import "./IPInterestManagerYTV2.sol";
 
 interface IPYieldTokenV2 is IERC20Metadata, IRewardManager, IPInterestManagerYTV2 {
     event Mint(
@@ -29,13 +29,16 @@ interface IPYieldTokenV2 is IERC20Metadata, IRewardManager, IPInterestManagerYTV
 
     function redeemPY(address receiver) external returns (uint256 amountSyOut);
 
-    function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
-        external
-        returns (uint256[] memory amountSyOuts);
+    function redeemPYMulti(
+        address[] calldata receivers,
+        uint256[] calldata amountPYToRedeems
+    ) external returns (uint256[] memory amountSyOuts);
 
-    function redeemDueInterestAndRewards(address user, bool redeemInterest, bool redeemRewards)
-        external
-        returns (uint256 interestOut, uint256[] memory rewardsOut);
+    function redeemDueInterestAndRewards(
+        address user,
+        bool redeemInterest,
+        bool redeemRewards
+    ) external returns (uint256 interestOut, uint256[] memory rewardsOut);
 
     function rewardIndexesCurrent() external returns (uint256[] memory);
 

package/contracts/interfaces/IStandardizedYield.sol

@@ -64,10 +64,12 @@ interface IStandardizedYield is IERC20Metadata {
      * Requirements:
      * - (`tokenIn`) must be a valid base token.
      */
-    function deposit(address receiver, address tokenIn, uint256 amountTokenToDeposit, uint256 minSharesOut)
-        external
-        payable
-        returns (uint256 amountSharesOut);
+    function deposit(
+        address receiver,
+        address tokenIn,
+        uint256 amountTokenToDeposit,
+        uint256 minSharesOut
+    ) external payable returns (uint256 amountSharesOut);
 
     /**
      * @notice redeems an amount of base tokens by burning some shares
@@ -93,9 +95,9 @@ interface IStandardizedYield is IERC20Metadata {
     /**
      * @notice exchangeRate * syBalance / 1e18 must return the asset balance of the account
      * @notice vice-versa, if a user uses some amount of tokens equivalent to X asset, the amount of sy
-     * exchangeRate / 1e18
+     he can mint must be X * exchangeRate / 1e18
      * @dev SYUtils's assetToSy & syToAsset should be used instead of raw multiplication
-     *  & division
+     & division
      */
     function exchangeRate() external view returns (uint256 res);
 
@@ -144,21 +146,20 @@ interface IStandardizedYield is IERC20Metadata {
 
     function isValidTokenOut(address token) external view returns (bool);
 
-    function previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        external
-        view
-        returns (uint256 amountSharesOut);
+    function previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) external view returns (uint256 amountSharesOut);
 
-    function previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        external
-        view
-        returns (uint256 amountTokenOut);
+    function previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) external view returns (uint256 amountTokenOut);
 
     /**
      * @notice This function contains information to interpret what the asset is
      * @return assetType the type of the asset (0 for ERC20 tokens, 1 for AMM liquidity tokens,
-     *     2 for bridged yield bearing tokens like wstETH, rETH on Arbi whose the underlying asset doesn't exist on the
-     * chain)
+        2 for bridged yield bearing tokens like wstETH, rETH on Arbi whose the underlying asset doesn't exist on the chain)
      * @return assetAddress the address of the asset
      * @return assetDecimals the decimals of the asset
      */

package/contracts/limit/LimitMathCore.sol

@@ -2,8 +2,8 @@
 
 pragma solidity ^0.8.0;
 
-import "../core/Market/MarketMathCore.sol";
 import "../interfaces/IPLimitRouter.sol";
+import "../core/Market/MarketMathCore.sol";
 import "../interfaces/IPMarketFactory.sol";
 
 library LimitMathCore {
@@ -12,29 +12,37 @@ library LimitMathCore {
     using PMath for uint256;
     using PMath for int256;
 
-    function calcBatch(FillOrderParams[] memory params, address YT, uint256 lnFeeRateRoot)
-        internal
-        returns (IPLimitOrderType.FillResults memory out)
-    {
-        return calcBatch(
-            params, IPYieldToken(YT).expiry() - block.timestamp, IPYieldToken(YT).pyIndexCurrent(), lnFeeRateRoot
-        );
+    function calcBatch(
+        FillOrderParams[] memory params,
+        address YT,
+        uint256 lnFeeRateRoot
+    ) internal returns (IPLimitOrderType.FillResults memory out) {
+        return
+            calcBatch(
+                params,
+                IPYieldToken(YT).expiry() - block.timestamp,
+                IPYieldToken(YT).pyIndexCurrent(),
+                lnFeeRateRoot
+            );
     }
 
     // --- PURE FUNCTIONS ---
-    function calcBatch(FillOrderParams[] memory params, uint256 timeToExpiry, uint256 pyIndex, uint256 lnFeeRateRoot)
-        internal
-        pure
-        returns (IPLimitOrderType.FillResults memory out)
-    {
+    function calcBatch(
+        FillOrderParams[] memory params,
+        uint256 timeToExpiry,
+        uint256 pyIndex,
+        uint256 lnFeeRateRoot
+    ) internal pure returns (IPLimitOrderType.FillResults memory out) {
         uint256 len = params.length;
         out.netMakings = new uint256[](len);
         out.netTakings = new uint256[](len);
         out.netFees = new uint256[](len);
         out.notionalVolumes = new uint256[](len);
 
-        function(uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calc =
-            getCalcFunctions(params[0].order.orderType);
+        function(uint256, uint256, PYIndex, uint256)
+            internal
+            pure
+            returns (uint256, uint256, uint256) calc = getCalcFunctions(params[0].order.orderType);
 
         uint256 feeRate = impliedRateToExchangeRate(lnFeeRateRoot, timeToExpiry);
 
@@ -45,8 +53,12 @@ library LimitMathCore {
             uint256 exchangeRate = impliedRateToExchangeRate(param.order.lnImpliedRate, timeToExpiry);
 
             out.netMakings[i] = param.makingAmount;
-            (out.netTakings[i], out.netFees[i], out.notionalVolumes[i]) =
-                calc(out.netMakings[i], exchangeRate, PYIndex.wrap(pyIndex), feeRate);
+            (out.netTakings[i], out.netFees[i], out.notionalVolumes[i]) = calc(
+                out.netMakings[i],
+                exchangeRate,
+                PYIndex.wrap(pyIndex),
+                feeRate
+            );
 
             require(out.netTakings[i] > 0, "LOP: can't swap 0 amount");
 
@@ -57,11 +69,12 @@ library LimitMathCore {
         }
     }
 
-    function calcSyForPt(uint256 makeSy, uint256 r, PYIndex index, uint256 f)
-        internal
-        pure
-        returns (uint256 takePt, uint256 fee, uint256 notionalVolume)
-    {
+    function calcSyForPt(
+        uint256 makeSy,
+        uint256 r,
+        PYIndex index,
+        uint256 f
+    ) internal pure returns (uint256 takePt, uint256 fee, uint256 notionalVolume) {
         // takePt = makeSy * index * r
         // fee = makeSy * (f - 1) / f
         // notionalVolume = makeSy
@@ -71,11 +84,12 @@ library LimitMathCore {
         notionalVolume = makeSy;
     }
 
-    function calcPtForSy(uint256 makePt, uint256 r, PYIndex index, uint256 f)
-        internal
-        pure
-        returns (uint256 takeSy, uint256 fee, uint256 notionalVolume)
-    {
+    function calcPtForSy(
+        uint256 makePt,
+        uint256 r,
+        PYIndex index,
+        uint256 f
+    ) internal pure returns (uint256 takeSy, uint256 fee, uint256 notionalVolume) {
         // takeAsset = make / r
         // takeSy = takeAsset / index
         // fee = takeSy * (f-1)
@@ -86,11 +100,12 @@ library LimitMathCore {
         notionalVolume = takeSy;
     }
 
-    function calcSyForYt(uint256 makeSy, uint256 r, PYIndex index, uint256 f)
-        internal
-        pure
-        returns (uint256 takeYt, uint256 fee, uint256 notionalVolume)
-    {
+    function calcSyForYt(
+        uint256 makeSy,
+        uint256 r,
+        PYIndex index,
+        uint256 f
+    ) internal pure returns (uint256 takeYt, uint256 fee, uint256 notionalVolume) {
         // pt = makeSy * index * r
         // yt = pt / (r-1)
         // fee = makeSy * (f-1) / (r-1)
@@ -102,11 +117,12 @@ library LimitMathCore {
         notionalVolume = makeSy.divDown(pt_yt_ratio);
     }
 
-    function calcYtForSy(uint256 makeYt, uint256 r, PYIndex index, uint256 f)
-        internal
-        pure
-        returns (uint256 takeSy, uint256 fee, uint256 notionalVolume)
-    {
+    function calcYtForSy(
+        uint256 makeYt,
+        uint256 r,
+        PYIndex index,
+        uint256 f
+    ) internal pure returns (uint256 takeSy, uint256 fee, uint256 notionalVolume) {
         // pt = yt * (r-1)
         // takeSy = pt / r / index
         // feeSy = takeSy * (f-1) / f / (r-1)
@@ -122,7 +138,9 @@ library LimitMathCore {
         return MarketMathCore._getExchangeRateFromImpliedRate(lnRate, timeToExpiry).Uint();
     }
 
-    function getCalcFunctions(IPLimitOrderType.OrderType t)
+    function getCalcFunctions(
+        IPLimitOrderType.OrderType t
+    )
         internal
         pure
         returns (function(uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calc)

package/contracts/limit/LimitRouterBase.sol

@@ -2,15 +2,15 @@
 
 pragma solidity ^0.8.17;
 
+import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
+import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
+import "../interfaces/IPLimitRouter.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/TokenHelper.sol";
-import "../interfaces/IPLimitRouter.sol";
 import "../interfaces/IStandardizedYield.sol";
+import "./helpers/NonceManager.sol";
 import "../interfaces/IWETH.sol";
 import {LimitMathCore as LimitMath} from "./LimitMathCore.sol";
-import "./helpers/NonceManager.sol";
-import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
-import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
 
 abstract contract LimitRouterBase is
     EIP712Upgradeable,
@@ -22,14 +22,15 @@ abstract contract LimitRouterBase is
     using SafeERC20 for IERC20;
     using PMath for uint256;
 
-    bytes32 internal constant LIMIT_ORDER_TYPEHASH = keccak256(
-        "Order(uint256 salt,uint256 expiry,uint256 nonce,uint8 orderType,address token,address YT,address maker,address receiver,uint256 makingAmount,uint256 lnImpliedRate,uint256 failSafeRate,bytes permit)"
-    );
+    bytes32 internal constant LIMIT_ORDER_TYPEHASH =
+        keccak256(
+            "Order(uint256 salt,uint256 expiry,uint256 nonce,uint8 orderType,address token,address YT,address maker,address receiver,uint256 makingAmount,uint256 lnImpliedRate,uint256 failSafeRate,bytes permit)"
+        );
 
     uint128 internal constant _ORDER_DOES_NOT_EXIST = 0;
     uint128 internal constant _ORDER_FILLED = 1;
-    uint256 internal constant NEW_PRIME = 12_421;
-    uint256 internal constant MAX_LN_FEE_RATE_ROOT = 48_790_164_169_432_003; // ln(1.05)
+    uint256 internal constant NEW_PRIME = 12421;
+    uint256 internal constant MAX_LN_FEE_RATE_ROOT = 48790164169432003; // ln(1.05)
 
     bytes private constant EMPTY_BYTES = abi.encode();
 
@@ -69,8 +70,7 @@ abstract contract LimitRouterBase is
         FillOrderParams[] memory params,
         address receiver,
         uint256 maxTaking,
-        bytes calldata,
-        /*optData*/
+        bytes calldata /*optData*/,
         bytes memory callback
     ) external returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
         params = _validateSkipSigAndFilterOrders(params);
@@ -94,18 +94,16 @@ abstract contract LimitRouterBase is
         bytes callback;
     }
 
-    function fillNoOrders(bytes memory callback)
-        internal
-        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn)
-    {
+    function fillNoOrders(
+        bytes memory callback
+    ) internal returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
         callbackReturn = callbackIfNeeded(0, 0, 0, callback);
         return (0, 0, 0, callbackReturn);
     }
 
-    function fillTokenForPY(Args memory a)
-        internal
-        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn)
-    {
+    function fillTokenForPY(
+        Args memory a
+    ) internal returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
         (address SY, address PT, address YT, bytes32[] memory orderHashes) = _checkSig_updMakingAndStatus(a.params);
 
         // Token => This
@@ -133,10 +131,9 @@ abstract contract LimitRouterBase is
         _emitEvents(a.params, orderHashes, fromMakers, out.netTakings, out.netFees, out.notionalVolumes);
     }
 
-    function fillPYForToken(Args memory a)
-        internal
-        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn)
-    {
+    function fillPYForToken(
+        Args memory a
+    ) internal returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
         (address SY, address PT, address YT, bytes32[] memory orderHashes) = _checkSig_updMakingAndStatus(a.params);
 
         FillResults memory out = LimitMath.calcBatch(a.params, YT, getLnFeeRateRoot(YT));
@@ -165,11 +162,9 @@ abstract contract LimitRouterBase is
     }
 
     // ----------------- verify & convert functions -----------------
-    function _validateSkipSigAndFilterOrders(FillOrderParams[] memory params)
-        internal
-        view
-        returns (FillOrderParams[] memory res)
-    {
+    function _validateSkipSigAndFilterOrders(
+        FillOrderParams[] memory params
+    ) internal view returns (FillOrderParams[] memory res) {
         uint256 len = params.length;
         require(len != 0, "LOP: empty batch");
 
@@ -197,18 +192,19 @@ abstract contract LimitRouterBase is
         }
     }
 
-    function _checkSig_updMakingAndStatus(FillOrderParams[] memory params)
-        internal
-        returns (address SY, address PT, address YT, bytes32[] memory orderHashes)
-    {
+    function _checkSig_updMakingAndStatus(
+        FillOrderParams[] memory params
+    ) internal returns (address SY, address PT, address YT, bytes32[] memory orderHashes) {
         uint256 len = params.length;
         orderHashes = new bytes32[](len);
 
         for (uint256 i = 0; i < len; i++) {
             FillOrderParams memory param = params[i];
 
-            (bytes32 orderHash, uint256 remainingMakerAmount, uint256 filledMakerAmount) =
-                _checkSig(param.order, param.signature);
+            (bytes32 orderHash, uint256 remainingMakerAmount, uint256 filledMakerAmount) = _checkSig(
+                param.order,
+                param.signature
+            );
             uint256 netMaking = PMath.min(param.makingAmount, remainingMakerAmount);
 
             unchecked {
@@ -256,17 +252,26 @@ abstract contract LimitRouterBase is
         }
     }
 
-    function callbackIfNeeded(uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callback)
-        internal
-        returns (bytes memory callbackReturn)
-    {
+    function callbackIfNeeded(
+        uint256 actualMaking,
+        uint256 actualTaking,
+        uint256 totalFee,
+        bytes memory callback
+    ) internal returns (bytes memory callbackReturn) {
         if (callback.length > 0) {
-            callbackReturn =
-                IPLimitRouterCallback(msg.sender).limitRouterCallback(actualMaking, actualTaking, totalFee, callback);
+            callbackReturn = IPLimitRouterCallback(msg.sender).limitRouterCallback(
+                actualMaking,
+                actualTaking,
+                totalFee,
+                callback
+            );
         }
     }
 
-    function _checkSig(Order memory order, bytes memory signature)
+    function _checkSig(
+        Order memory order,
+        bytes memory signature
+    )
         public
         view
         returns (
@@ -296,10 +301,10 @@ abstract contract LimitRouterBase is
 
     // ----------------- simple helper functions functions -----------------
 
-    function _transferFromMakers_mintSy_updMakings(address SY, FillOrderParams[] memory params)
-        internal
-        returns (uint256[] memory fromMakers)
-    {
+    function _transferFromMakers_mintSy_updMakings(
+        address SY,
+        FillOrderParams[] memory params
+    ) internal returns (uint256[] memory fromMakers) {
         uint256 len = params.length;
         fromMakers = new uint256[](len);
 
@@ -335,13 +340,19 @@ abstract contract LimitRouterBase is
         }
         _safeApproveInf(token, SY);
         return
-            IStandardizedYield(SY).deposit{value: token == NATIVE ? netTokenIn : 0}(address(this), token, netTokenIn, 0);
+            IStandardizedYield(SY).deposit{value: token == NATIVE ? netTokenIn : 0}(
+                address(this),
+                token,
+                netTokenIn,
+                0
+            );
     }
 
-    function _redeemSy_transferToMakers(address SY, FillOrderParams[] memory params, uint256[] memory netSyOuts)
-        internal
-        returns (uint256[] memory toMakers)
-    {
+    function _redeemSy_transferToMakers(
+        address SY,
+        FillOrderParams[] memory params,
+        uint256[] memory netSyOuts
+    ) internal returns (uint256[] memory toMakers) {
         uint256 len = params.length;
         toMakers = new uint256[](len);
 
@@ -390,14 +401,18 @@ abstract contract LimitRouterBase is
     }
 
     function __stillShared(address currentShared, address nextToken) private view returns (bool) {
-        return (currentShared == nextToken) || (currentShared == NATIVE && nextToken == WNATIVE)
-            || (currentShared == WNATIVE && nextToken == NATIVE);
+        return
+            (currentShared == nextToken) ||
+            (currentShared == NATIVE && nextToken == WNATIVE) ||
+            (currentShared == WNATIVE && nextToken == NATIVE);
     }
 
-    function __redeemSy_Single(address receiver, address SY, address tokenOut, uint256 netSyIn)
-        private
-        returns (uint256 netTokenOut)
-    {
+    function __redeemSy_Single(
+        address receiver,
+        address SY,
+        address tokenOut,
+        uint256 netSyIn
+    ) private returns (uint256 netTokenOut) {
         if (tokenOut == NATIVE || tokenOut == WNATIVE) {
             address otherToken = tokenOut == NATIVE ? WNATIVE : NATIVE;
             address tokenRedeemSy = IStandardizedYield(SY).isValidTokenOut(tokenOut) ? tokenOut : otherToken;
@@ -417,9 +432,12 @@ abstract contract LimitRouterBase is
     }
 
     // ! Allow self-fill of orders
-    function _transferFromMakers(IERC20 token, FillOrderParams[] memory params, address to, uint256[] memory netIn)
-        internal
-    {
+    function _transferFromMakers(
+        IERC20 token,
+        FillOrderParams[] memory params,
+        address to,
+        uint256[] memory netIn
+    ) internal {
         uint256 len = params.length;
         for (uint256 i = 0; i < len; i++) {
             if (params[i].order.maker == to) continue;
@@ -427,9 +445,12 @@ abstract contract LimitRouterBase is
         }
     }
 
-    function _transferToMakers(IERC20 token, address payer, FillOrderParams[] memory params, uint256[] memory netOut)
-        internal
-    {
+    function _transferToMakers(
+        IERC20 token,
+        address payer,
+        FillOrderParams[] memory params,
+        uint256[] memory netOut
+    ) internal {
         uint256 len = params.length;
         for (uint256 i = 0; i < len; i++) {
             if (payer == params[i].order.receiver) continue;
@@ -465,10 +486,11 @@ abstract contract LimitRouterBase is
     }
 
     /// @dev if zero fees are intended, it must be explicitly allowed again
-    function setLnFeeRateRoots(address[] memory YTs, uint256[] memory lnFeeRateRoots, bool allowZeroFees)
-        public
-        onlyHelperAndOwner
-    {
+    function setLnFeeRateRoots(
+        address[] memory YTs,
+        uint256[] memory lnFeeRateRoots,
+        bool allowZeroFees
+    ) public onlyHelperAndOwner {
         uint256 len = YTs.length;
         require(len == lnFeeRateRoots.length, "LOP: length mismatch");
 

package/contracts/limit/PendleLimitRouter.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../core/libraries/Errors.sol";
 import "./LimitRouterBase.sol";
+import "../core/libraries/Errors.sol";
 
 contract PendleLimitRouter is LimitRouterBase {
     using Address for address;
@@ -39,11 +39,9 @@ contract PendleLimitRouter is LimitRouterBase {
         }
     }
 
-    function orderStatusesRaw(bytes32[] memory orderHashes)
-        public
-        view
-        returns (uint256[] memory remainingsRaw, uint256[] memory filledAmounts)
-    {
+    function orderStatusesRaw(
+        bytes32[] memory orderHashes
+    ) public view returns (uint256[] memory remainingsRaw, uint256[] memory filledAmounts) {
         uint256 len = orderHashes.length;
         remainingsRaw = new uint256[](len);
         filledAmounts = new uint256[](len);
@@ -54,11 +52,9 @@ contract PendleLimitRouter is LimitRouterBase {
         }
     }
 
-    function orderStatuses(bytes32[] memory orderHashes)
-        external
-        view
-        returns (uint256[] memory remainings, uint256[] memory filledAmounts)
-    {
+    function orderStatuses(
+        bytes32[] memory orderHashes
+    ) external view returns (uint256[] memory remainings, uint256[] memory filledAmounts) {
         (remainings, filledAmounts) = orderStatusesRaw(orderHashes);
         for (uint256 i = 0; i < remainings.length; i++) {
             require(remainings[i] != _ORDER_DOES_NOT_EXIST, "LOP: Unknown order");

package/contracts/offchain-helpers/AddressProvider.sol

@@ -1,7 +1,7 @@
 pragma solidity ^0.8.17;
 
-import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../interfaces/IAddressProvider.sol";
+import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 
 contract AddressProvider is IAddressProvider, BoringOwnableUpgradeableV2 {
     mapping(uint256 => address) public get;

package/contracts/offchain-helpers/AutomateReady.sol

@@ -72,7 +72,7 @@ abstract contract AutomateReady {
     constructor(address _automate, address _taskCreator) {
         automate = IAutomate(_automate);
         _gelato = IAutomate(_automate).gelato();
-        (dedicatedMsgSender,) = IOpsProxyFactory(OPS_PROXY_FACTORY).getProxyOf(_taskCreator);
+        (dedicatedMsgSender, ) = IOpsProxyFactory(OPS_PROXY_FACTORY).getProxyOf(_taskCreator);
     }
 
     /**
@@ -83,7 +83,7 @@ abstract contract AutomateReady {
      */
     function _transfer(uint256 _fee, address _feeToken) internal {
         if (_feeToken == ETH) {
-            (bool success,) = _gelato.call{value: _fee}("");
+            (bool success, ) = _gelato.call{value: _fee}("");
             require(success, "_transfer: ETH transfer failed");
         } else {
             SafeERC20.safeTransfer(IERC20(_feeToken), _gelato, _fee);