@pendle/core-v2 3.0.0-beta-11 → 3.0.0-beta-13

package/contracts/interfaces/Thena/IThenaGaugeV2.sol

@@ -2,7 +2,6 @@
 
 pragma solidity ^0.8.0;
 
-
 interface IThenaGaugeV2 {
     function emergency() external returns (bool);
 
@@ -15,4 +14,4 @@ interface IThenaGaugeV2 {
     function getReward() external;
 
     function balanceOf(address account) external view returns (uint256);
-}
+}

package/contracts/interfaces/Thena/IThenaPair.sol

@@ -16,15 +16,13 @@ interface IThenaPair {
     function getReserves() external view returns (uint _reserve0, uint _reserve1, uint _blockTimestampLast);
     function getAmountOut(uint, address) external view returns (uint);
 
-    function name() external view returns(string memory);
-    function symbol() external view returns(string memory);
+    function name() external view returns (string memory);
+    function symbol() external view returns (string memory);
     function totalSupply() external view returns (uint);
     function decimals() external view returns (uint8);
 
     function claimable0(address _user) external view returns (uint);
     function claimable1(address _user) external view returns (uint);
 
-    function isStable() external view returns(bool);
-
-
+    function isStable() external view returns (bool);
 }

package/contracts/limit/LimitMathCore.sol

@@ -12,42 +12,53 @@ library LimitMathCore {
     using PMath for uint256;
     using PMath for int256;
 
-    function calcNormalBatch(FillOrderParams[] memory params, address YT, uint256 lnFeeRateRoot)
-        internal
-        returns (IPOrderMixinType.NormalResults memory out)
-    {
-        return calcNormalBatch(
-            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 calcNormalBatch(
+    function calcBatch(
         FillOrderParams[] memory params,
         uint256 timeToExpiry,
         uint256 pyIndex,
         uint256 lnFeeRateRoot
-    ) internal pure returns (IPOrderMixinType.NormalResults memory out) {
+    ) 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) calcNormal =
-            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);
 
-        for (uint256 i = 0; i < len; i = inc1(i)) {
+        for (uint256 i = 0; i < len; i++) {
             FillOrderParams memory param = params[i];
             if (param.makingAmount == 0) continue; // nothing changes
 
             uint256 exchangeRate = impliedRateToExchangeRate(param.order.lnImpliedRate, timeToExpiry);
 
             out.netMakings[i] = param.makingAmount;
-            (out.netTakings[i], out.netFees[i], out.notionalVolumes[i]) =
-                calcNormal(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");
 
@@ -58,28 +69,30 @@ library LimitMathCore {
         }
     }
 
-    function calcSyForPtNormal(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)
+        // fee = makeSy * (f - 1) / f
         // notionalVolume = makeSy
 
         takePt = index.syToAsset(makeSy).mulDown(r);
-        fee = makeSy * (f - PMath.ONE) / f;
+        fee = (makeSy * (f - PMath.ONE)) / f;
         notionalVolume = makeSy;
     }
 
-    function calcPtForSyNormal(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)/f
+        // fee = takeSy * (f-1)
         // notionalVolume = takeSy
 
         takeSy = index.assetToSy(makePt.divDown(r));
@@ -87,35 +100,37 @@ library LimitMathCore {
         notionalVolume = takeSy;
     }
 
-    function calcSyForYtNormal(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) / f) / (r-1)
+        // fee = makeSy * (f-1) / (r-1)
         // notionalVolume = makeSy / (r-1)
         uint256 pt_yt_ratio = r - PMath.ONE;
 
-        takeYt = index.syToAsset(makeSy) * r / pt_yt_ratio;
-        fee = makeSy * (f - PMath.ONE) / pt_yt_ratio;
+        takeYt = (index.syToAsset(makeSy) * r) / pt_yt_ratio;
+        fee = (makeSy * (f - PMath.ONE)) / pt_yt_ratio;
         notionalVolume = makeSy.divDown(pt_yt_ratio);
     }
 
-    function calcYtForSyNormal(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) / (r-1)
+        // feeSy = takeSy * (f-1) / f / (r-1)
         // notionalVolume = takeSy / (r-1)
         uint256 pt_yt_ratio = r - PMath.ONE;
 
-        takeSy = index.assetToSy(makeYt * pt_yt_ratio / r);
-        fee = (takeSy * (f - PMath.ONE) / f).divDown(pt_yt_ratio);
+        takeSy = index.assetToSy((makeYt * pt_yt_ratio) / r);
+        fee = ((takeSy * (f - PMath.ONE)) / f).divDown(pt_yt_ratio);
         notionalVolume = takeSy.divDown(pt_yt_ratio);
     }
 
@@ -123,27 +138,21 @@ library LimitMathCore {
         return MarketMathCore._getExchangeRateFromImpliedRate(lnRate, timeToExpiry).Uint();
     }
 
-    function inc1(uint256 i) internal pure returns (uint256) {
-        unchecked {
-            return i + 1;
-        }
-    }
-
-    function getCalcFunctions(IPOrderMixinType.OrderType t)
+    function getCalcFunctions(
+        IPLimitOrderType.OrderType t
+    )
         internal
         pure
-        returns (
-            function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calcNormal
-        )
+        returns (function(uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calc)
     {
-        if (t == IPOrderMixinType.OrderType.SY_FOR_PT) {
-            return (calcSyForPtNormal);
-        } else if (t == IPOrderMixinType.OrderType.PT_FOR_SY) {
-            return (calcPtForSyNormal);
-        } else if (t == IPOrderMixinType.OrderType.SY_FOR_YT) {
-            return (calcSyForYtNormal);
+        if (t == IPLimitOrderType.OrderType.SY_FOR_PT) {
+            return (calcSyForPt);
+        } else if (t == IPLimitOrderType.OrderType.PT_FOR_SY) {
+            return (calcPtForSy);
+        } else if (t == IPLimitOrderType.OrderType.SY_FOR_YT) {
+            return (calcSyForYt);
         } else {
-            return (calcYtForSyNormal);
+            return (calcYtForSy);
         }
     }
 }

package/contracts/limit/{PendleOrderMixin.sol → LimitRouterBase.sol}

@@ -12,7 +12,7 @@ import "./helpers/NonceManager.sol";
 import "../interfaces/IWETH.sol";
 import {LimitMathCore as LimitMath} from "./LimitMathCore.sol";
 
-abstract contract PendleOrderMixin is
+abstract contract LimitRouterBase is
     EIP712Upgradeable,
     IPLimitRouter,
     BoringOwnableUpgradeable,
@@ -22,9 +22,10 @@ abstract contract PendleOrderMixin 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;
@@ -53,22 +54,24 @@ abstract contract PendleOrderMixin is
         setFeeRecipient(_feeRecipient);
     }
 
-    function normalFill(FillOrderParams[] memory params, address receiver, uint256 maxTaking, bytes memory callback)
-        external
-        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn)
-    {
+    function fill(
+        FillOrderParams[] memory params,
+        address receiver,
+        uint256 maxTaking,
+        bytes calldata /*optData*/,
+        bytes memory callback
+    ) external returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn) {
         _validateOrdersSkipSig(params);
         OrderType orderType = params[0].order.orderType;
         if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
-            return normalFillTokenForPY(Args(orderType, params, receiver, maxTaking, callback));
+            return fillTokenForPY(Args(orderType, params, receiver, maxTaking, callback));
         } else {
-            return normalFillPYForToken(Args(orderType, params, receiver, maxTaking, callback));
+            return fillPYForToken(Args(orderType, params, receiver, maxTaking, callback));
         }
     }
 
     // ----------------- Core logic -----------------
 
-    // solhint-disable-next-line
     struct Args {
         OrderType orderType;
         FillOrderParams[] params;
@@ -77,16 +80,15 @@ abstract contract PendleOrderMixin is
         bytes callback;
     }
 
-    function normalFillTokenForPY(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
         uint256[] memory fromMakers = _transferFromMakers_mintSy_updMakings(SY, a.params);
 
-        NormalResults memory out = LimitMath.calcNormalBatch(a.params, YT, getLnFeeRateRoot(YT));
+        FillResults memory out = LimitMath.calcBatch(a.params, YT, getLnFeeRateRoot(YT));
         (actualMaking, actualTaking, totalFee) = (out.totalMaking - out.totalFee, out.totalTaking, out.totalFee);
 
         require(actualTaking <= a.maxTaking, "LOP: maxTaking exceeded");
@@ -96,8 +98,12 @@ abstract contract PendleOrderMixin is
 
         // callback to Taker
         if (a.callback.length > 0) {
-            callbackReturn =
-                IPLimitRouterCallback(msg.sender).normalFillCallback(actualMaking, actualTaking, totalFee, a.callback);
+            callbackReturn = IPLimitRouterCallback(msg.sender).limitRouterCallback(
+                actualMaking,
+                actualTaking,
+                totalFee,
+                a.callback
+            );
         }
 
         // Taker => Makers
@@ -111,13 +117,12 @@ abstract contract PendleOrderMixin is
         _checkSafety_emitEvents(a.params, orderHashes, fromMakers, out.netTakings, out.netFees, out.notionalVolumes);
     }
 
-    function normalFillPYForToken(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);
 
-        NormalResults memory out = LimitMath.calcNormalBatch(a.params, YT, getLnFeeRateRoot(YT));
+        FillResults memory out = LimitMath.calcBatch(a.params, YT, getLnFeeRateRoot(YT));
         (actualMaking, actualTaking, totalFee) = (out.totalMaking, out.totalTaking + out.totalFee, out.totalFee);
 
         require(actualTaking <= a.maxTaking, "LOP: maxTaking exceeded");
@@ -128,8 +133,12 @@ abstract contract PendleOrderMixin is
 
         // callback to Taker
         if (a.callback.length > 0) {
-            callbackReturn =
-                IPLimitRouterCallback(msg.sender).normalFillCallback(actualMaking, actualTaking, totalFee, a.callback);
+            callbackReturn = IPLimitRouterCallback(msg.sender).limitRouterCallback(
+                actualMaking,
+                actualTaking,
+                totalFee,
+                a.callback
+            );
         }
 
         // Taker => This
@@ -155,7 +164,7 @@ abstract contract PendleOrderMixin is
         uint256 expiry = IPYieldToken(YT).expiry();
         require(block.timestamp < expiry, "LOP: PY expired");
 
-        for (uint256 i = 0; i < len; i = _inc1(i)) {
+        for (uint256 i = 0; i < len; i++) {
             Order memory order = params[i].order;
 
             require(order.orderType == orderType, "LOP: not same orderType");
@@ -165,18 +174,19 @@ abstract contract PendleOrderMixin 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 = _inc1(i)) {
+        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 {
@@ -207,11 +217,11 @@ abstract contract PendleOrderMixin is
     ) internal {
         uint256 len = hashes.length;
 
-        for (uint256 i = 0; i < len; i = _inc1(i)) {
+        for (uint256 i = 0; i < len; i++) {
             require(fromMakers[i].mulDown(params[i].order.failSafeRate) <= toMakers[i], "LOP: fail safe");
         }
 
-        for (uint256 i = 0; i < len; i = _inc1(i)) {
+        for (uint256 i = 0; i < len; i++) {
             Order memory order = params[i].order;
             emit OrderFilled(
                 hashes[i],
@@ -226,7 +236,10 @@ abstract contract PendleOrderMixin is
         }
     }
 
-    function _checkSig(Order memory order, bytes memory signature)
+    function _checkSig(
+        Order memory order,
+        bytes memory signature
+    )
         internal
         view
         returns (
@@ -256,17 +269,17 @@ abstract contract PendleOrderMixin 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);
 
         for ((uint256 l, uint256 r) = (0, 0); l < len; l = r) {
             address sharedToken = params[l].order.token;
             uint256 totalMaking = 0;
-            for (; r < len && params[r].order.token == sharedToken; r = _inc1(r)) {
+            for (; r < len && params[r].order.token == sharedToken; r++) {
                 _transferIn(sharedToken, params[r].order.maker, params[r].makingAmount);
                 totalMaking += params[r].makingAmount;
                 fromMakers[r] = params[r].makingAmount;
@@ -275,7 +288,7 @@ abstract contract PendleOrderMixin is
             if (sharedToken == SY || totalMaking == 0) continue;
 
             uint256 totalSy = __mintSy_Single(SY, sharedToken, totalMaking);
-            for (uint256 i = l; i < r; i = _inc1(i)) {
+            for (uint256 i = l; i < r; i++) {
                 params[i].makingAmount = (params[i].makingAmount * totalSy) / totalMaking;
             }
         }
@@ -288,13 +301,19 @@ abstract contract PendleOrderMixin 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) {
         // netSyOuts all > 0, guarantee in LimitMath
 
         uint256 len = params.length;
@@ -304,12 +323,12 @@ abstract contract PendleOrderMixin is
             address sharedToken = params[l].order.token;
             uint256 totalSy = 0;
 
-            for (; r < len && __stillShared(sharedToken, params[r].order.token); r = _inc1(r)) {
+            for (; r < len && __stillShared(sharedToken, params[r].order.token); r++) {
                 totalSy += netSyOuts[r];
             }
 
             if (sharedToken == SY) {
-                for (uint256 i = l; i < r; i = _inc1(i)) {
+                for (uint256 i = l; i < r; i++) {
                     _transferOut(SY, params[i].order.receiver, netSyOuts[i]);
                     toMakers[i] = netSyOuts[i];
                 }
@@ -320,7 +339,7 @@ abstract contract PendleOrderMixin is
                 toMakers[l] = __redeemSy_Single(params[l].order.receiver, SY, sharedToken, netSyOuts[l]);
             } else {
                 uint256 totalToken = __redeemSy_Single(address(this), SY, sharedToken, totalSy);
-                for (uint256 i = l; i < r; i = _inc1(i)) {
+                for (uint256 i = l; i < r; i++) {
                     address token = params[i].order.token;
                     toMakers[i] = (netSyOuts[i] * totalToken) / totalSy;
                     if (sharedToken != token) {
@@ -334,14 +353,18 @@ abstract contract PendleOrderMixin 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;
@@ -360,36 +383,30 @@ abstract contract PendleOrderMixin is
         }
     }
 
-    function _inc1(uint256 i) internal pure returns (uint256) {
-        unchecked {
-            return i + 1;
-        }
-    }
-
     // ! 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 = _inc1(i)) {
+        for (uint256 i = 0; i < len; i++) {
             if (params[i].order.maker == to) continue;
             token.safeTransferFrom(params[i].order.maker, to, netIn[i]);
         }
     }
 
-    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;
-        if (payer == address(this)) {
-            for (uint256 i = 0; i < len; i = _inc1(i)) {
-                token.safeTransfer(params[i].order.receiver, netOut[i]);
-            }
-        } else {
-            for (uint256 i = 0; i < len; i = _inc1(i)) {
-                if (payer == params[i].order.receiver) continue;
-                token.safeTransferFrom(payer, params[i].order.receiver, netOut[i]);
-            }
+        for (uint256 i = 0; i < len; i++) {
+            if (payer == params[i].order.receiver) continue;
+            token.safeTransferFrom(payer, params[i].order.receiver, netOut[i]);
         }
     }
 
@@ -415,7 +432,7 @@ abstract contract PendleOrderMixin is
         uint256 len = YTs.length;
         require(len == lnFeeRateRoots.length, "LOP: length mismatch");
 
-        for (uint256 i = 0; i < len; i = _inc1(i)) {
+        for (uint256 i = 0; i < len; i++) {
             require(lnFeeRateRoots[i] > 0, "LOP: zero fee not allowed");
             __lnFeeRateRoot[YTs[i]] = lnFeeRateRoots[i];
         }

package/contracts/limit/PendleLimitRouter.sol

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "./PendleOrderMixin.sol";
+import "./LimitRouterBase.sol";
 import "../core/libraries/Errors.sol";
 
-contract PendleLimitRouter is PendleOrderMixin {
+contract PendleLimitRouter is LimitRouterBase {
     using Address for address;
 
-    constructor(address _WNATIVE) PendleOrderMixin(_WNATIVE) {
+    constructor(address _WNATIVE) LimitRouterBase(_WNATIVE) {
         _disableInitializers();
     }
 
@@ -29,11 +29,9 @@ contract PendleLimitRouter is PendleOrderMixin {
         emit OrderCanceled(msg.sender, orderHash);
     }
 
-    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);
@@ -44,11 +42,9 @@ contract PendleLimitRouter is PendleOrderMixin {
         }
     }
 
-    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");