@pendle/core-v2 3.0.0-beta-2 → 3.0.0-beta-4

package/contracts/limit/PendleOrderMixin.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity 0.8.21;
+pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
@@ -33,23 +33,26 @@ abstract contract PendleOrderMixin is
     using Address for address payable;
 
     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,bytes permit)"
+        "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)"
     );
 
-    uint256 internal constant _ORDER_DOES_NOT_EXIST = 0;
-    uint256 internal constant _ORDER_FILLED = 1;
+    uint128 internal constant _ORDER_DOES_NOT_EXIST = 0;
+    uint128 internal constant _ORDER_FILLED = 1;
 
     address public feeRecipient;
     uint96 public lnFeeRateRoot;
 
     address private immutable WNATIVE;
 
-    mapping(bytes32 => uint256) internal _remaining;
+    mapping(bytes32 => OrderStatus) internal _status;
+
+    uint256[100] private __gap;
 
     constructor(address _WNATIVE) {
         WNATIVE = _WNATIVE;
     }
 
+    // solhint-disable-next-line no-empty-blocks
     receive() external payable {}
 
     function initialize(address _feeRecipient, uint96 _lnFeeRateRoot) external initializer {
@@ -62,12 +65,12 @@ abstract contract PendleOrderMixin is
         external
         returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee)
     {
-        OrderType orderType = params[0].order.orderType;
         _validateOrdersSkipSig(params);
+        OrderType orderType = params[0].order.orderType;
         if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
-            return normalFillTokenForPY(params, receiver, maxTaking, callback);
+            return normalFillTokenForPY(Args(orderType, params, receiver, maxTaking, callback));
         } else {
-            return normalFillPYForToken(params, receiver, maxTaking, callback);
+            return normalFillPYForToken(Args(orderType, params, receiver, maxTaking, callback));
         }
     }
 
@@ -75,38 +78,37 @@ abstract contract PendleOrderMixin is
         external
         returns (uint256 netOutputToTaker, uint256 netInputFromTaker, uint256 totalFee)
     {
-        OrderType orderType = params[0].order.orderType;
         _validateOrdersSkipSig(params);
+        OrderType orderType = params[0].order.orderType;
         if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
-            return flashFillTokenForPY(params, receiver, maxInput, callback);
+            return flashFillTokenForPY(Args(orderType, params, receiver, maxInput, callback));
         } else {
-            return flashFillPYForToken(params, receiver, maxInput, callback);
+            return flashFillPYForToken(Args(orderType, params, receiver, maxInput, callback));
         }
     }
 
     // ----------------- Core logic -----------------
 
+    // solhint-disable-next-line
     struct Args {
+        OrderType orderType;
         FillOrderParams[] params;
         address receiver;
         uint256 maxTaking; // or maxInput
         bytes callback;
     }
 
-    function normalFillTokenForPY(
-        FillOrderParams[] memory _params,
-        address _receiver,
-        uint256 _maxTaking,
-        bytes memory _callback
-    ) internal returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee) {
-        Args memory a = Args(_params, _receiver, _maxTaking, _callback);
-
-        OrderType orderType = a.params[0].order.orderType;
+    function normalFillTokenForPY(Args memory a)
+        internal
+        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee)
+    {
+        (address SY, address PT, address YT, bytes32[] memory orderHashes) =
+            _checkSig_doPermit_updMakingAndRemaining(a.params);
 
         // Token => This
-        (address SY, address PT, address YT, OnchainParams memory onchain) = _prep(a.params, true);
+        uint256[] memory fromMakers = _transferFromMakers_mintSy_updMakings(SY, a.params);
 
-        NormalResults memory out = LimitMath.calcNormalBatch(a.params, onchain);
+        NormalResults memory out = LimitMath.calcNormalBatch(a.params, YT, lnFeeRateRoot);
         (actualMaking, actualTaking, totalFee) = (out.totalMaking - out.totalFee, out.totalTaking, out.totalFee);
 
         require(actualTaking <= a.maxTaking, "LOP: maxTaking exceeded");
@@ -116,85 +118,75 @@ abstract contract PendleOrderMixin is
 
         // callback to Taker
         if (a.callback.length > 0) {
-            ILimitOrderCallee(msg.sender).normalFillCall(orderType, actualMaking, actualTaking, totalFee, a.callback);
+            ILimitOrderCallee(msg.sender).normalFillCall(a.orderType, actualMaking, actualTaking, totalFee, a.callback);
         }
 
         // Taker => Makers
-        address pyToMaker = (orderType == OrderType.SY_FOR_PT) ? PT : YT;
-        _transferFromMulti(IERC20(pyToMaker), msg.sender, a.params, out.netTakings);
+        address pyToMaker = (a.orderType == OrderType.SY_FOR_PT) ? PT : YT;
+        _transferToMakers(IERC20(pyToMaker), msg.sender, a.params, out.netTakings);
 
         // This => Fee
-        _transferOut(SY, onchain.feeRecipient, totalFee);
+        _transferOut(SY, feeRecipient, totalFee);
 
-        emit NormalFill(
-            orderType, YT, msg.sender, actualMaking, actualTaking, totalFee, out.totalMaking, out.totalTaking
-        );
+        // toMakers == netTakings
+        _checkSafety_emitEvents(a.params, orderHashes, fromMakers, out.netTakings, out.netFees, out.notionalVolumes);
     }
 
-    function normalFillPYForToken(
-        FillOrderParams[] memory _params,
-        address _receiver,
-        uint256 _maxTaking,
-        bytes memory _callback
-    ) internal returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee) {
-        Args memory a = Args(_params, _receiver, _maxTaking, _callback);
-
-        OrderType orderType = a.params[0].order.orderType;
-
-        (address SY, address PT, address YT, OnchainParams memory onchain) = _prep(a.params, false);
+    function normalFillPYForToken(Args memory a)
+        internal
+        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee)
+    {
+        (address SY, address PT, address YT, bytes32[] memory orderHashes) =
+            _checkSig_doPermit_updMakingAndRemaining(a.params);
 
-        NormalResults memory out = LimitMath.calcNormalBatch(a.params, onchain);
+        NormalResults memory out = LimitMath.calcNormalBatch(a.params, YT, lnFeeRateRoot);
         (actualMaking, actualTaking, totalFee) = (out.totalMaking, out.totalTaking + out.totalFee, out.totalFee);
 
         require(actualTaking <= a.maxTaking, "LOP: maxTaking exceeded");
 
         // Makers => Taker
-        address pyFromMaker = (orderType == OrderType.PT_FOR_SY) ? PT : YT;
-        _transferFromMulti(IERC20(pyFromMaker), a.params, a.receiver, out.netMakings);
+        address pyFromMaker = (a.orderType == OrderType.PT_FOR_SY) ? PT : YT;
+        _transferFromMakers(IERC20(pyFromMaker), a.params, a.receiver, out.netMakings);
 
         // callback to Taker
         if (a.callback.length > 0) {
-            ILimitOrderCallee(msg.sender).normalFillCall(orderType, actualMaking, actualTaking, totalFee, a.callback);
+            ILimitOrderCallee(msg.sender).normalFillCall(a.orderType, actualMaking, actualTaking, totalFee, a.callback);
         }
 
         // Taker => This
         _transferFrom(IERC20(SY), msg.sender, address(this), actualTaking);
 
         // This => Makers
-        _redeemSy_transferOut(SY, a.params, out.totalTaking, out.netTakings);
+        uint256[] memory toMakers = _redeemSy_transferToMakers(SY, a.params, out.netTakings);
 
         // This => Fee
-        _transferOut(SY, onchain.feeRecipient, totalFee);
+        _transferOut(SY, feeRecipient, totalFee);
 
-        emit NormalFill(
-            orderType, YT, msg.sender, actualMaking, actualTaking, totalFee, out.totalMaking, out.totalTaking
-        );
+        // fromMakers == netMakings
+        _checkSafety_emitEvents(a.params, orderHashes, out.netMakings, toMakers, out.netFees, out.notionalVolumes);
     }
 
     // ----------------- Flash functions -----------------
 
-    function flashFillTokenForPY(
-        FillOrderParams[] memory _params,
-        address _receiver,
-        uint256 _maxInput,
-        bytes memory _callback
-    ) internal returns (uint256 totalPYToTaker, uint256 totalSyFromTaker, uint256 totalFee) {
-        Args memory a = Args(_params, _receiver, _maxInput, _callback);
-
-        OrderType orderType = a.params[0].order.orderType;
+    function flashFillTokenForPY(Args memory a)
+        internal
+        returns (uint256 totalPYToTaker, uint256 totalSyFromTaker, uint256 totalFee)
+    {
+        (address SY, address PT, address YT, bytes32[] memory orderHashes) =
+            _checkSig_doPermit_updMakingAndRemaining(a.params);
 
         // Token => This
-        (address SY, address PT, address YT, OnchainParams memory onchain) = _prep(a.params, true);
+        uint256[] memory fromMakers = _transferFromMakers_mintSy_updMakings(SY, a.params);
 
         NormalResults memory out;
-        (totalSyFromTaker, totalPYToTaker, totalFee, out) = LimitMath.calcFlashBatch(a.params, onchain);
+        (totalSyFromTaker, totalPYToTaker, totalFee, out) = LimitMath.calcFlashBatch(a.params, YT, lnFeeRateRoot);
 
         require(totalSyFromTaker <= a.maxTaking, "LOP: maxInput exceeded");
 
         // callback to Taker
         if (a.callback.length > 0) {
             ILimitOrderCallee(msg.sender).flashFillCall(
-                orderType, totalPYToTaker, totalSyFromTaker, totalFee, a.callback
+                a.orderType, totalPYToTaker, totalSyFromTaker, totalFee, a.callback
             );
         }
 
@@ -204,7 +196,7 @@ abstract contract PendleOrderMixin is
         // This => YT
         _transferOut(SY, YT, totalSyFromTaker + out.totalMaking - out.totalFee);
 
-        bool isPtToMaker = (orderType == OrderType.SY_FOR_PT);
+        bool isPtToMaker = (a.orderType == OrderType.SY_FOR_PT);
         address pyToMaker = isPtToMaker ? PT : YT;
         {
             address receiverPt = isPtToMaker ? address(this) : a.receiver;
@@ -215,48 +207,42 @@ abstract contract PendleOrderMixin is
         }
 
         // This => Makers
-        _transferFromMulti(IERC20(pyToMaker), address(this), a.params, out.netTakings);
+        _transferToMakers(IERC20(pyToMaker), address(this), a.params, out.netTakings);
 
         // This => Fee
-        _transferOut(SY, onchain.feeRecipient, out.totalFee);
+        _transferOut(SY, feeRecipient, totalFee);
 
-        emit FlashFill(
-            orderType, YT, msg.sender, totalPYToTaker, totalSyFromTaker, totalFee, out.totalMaking, out.totalTaking
-        );
+        // toMakers == netTakings
+        _checkSafety_emitEvents(a.params, orderHashes, fromMakers, out.netTakings, out.netFees, out.notionalVolumes);
     }
 
-    function flashFillPYForToken(
-        FillOrderParams[] memory _params,
-        address _receiver,
-        uint256 _maxInput,
-        bytes memory _callback
-    ) internal returns (uint256 totalSyToTaker, uint256 totalPYFromTaker, uint256 totalFee) {
-        Args memory a = Args(_params, _receiver, _maxInput, _callback);
-
-        OrderType orderType = a.params[0].order.orderType;
-
-        (address SY, address PT, address YT, OnchainParams memory onchain) = _prep(a.params, false);
+    function flashFillPYForToken(Args memory a)
+        internal
+        returns (uint256 totalSyToTaker, uint256 totalPYFromTaker, uint256 totalFee)
+    {
+        (address SY, address PT, address YT, bytes32[] memory orderHashes) =
+            _checkSig_doPermit_updMakingAndRemaining(a.params);
 
         NormalResults memory out;
-        (totalPYFromTaker, totalSyToTaker, totalFee, out) = LimitMath.calcFlashBatch(a.params, onchain);
+        (totalPYFromTaker, totalSyToTaker, totalFee, out) = LimitMath.calcFlashBatch(a.params, YT, lnFeeRateRoot);
 
         require(totalPYFromTaker <= a.maxTaking, "LOP: maxInput exceeded");
 
         // callback to Taker
         if (a.callback.length > 0) {
             ILimitOrderCallee(msg.sender).flashFillCall(
-                orderType, totalSyToTaker, totalPYFromTaker, totalFee, a.callback
+                a.orderType, totalSyToTaker, totalPYFromTaker, totalFee, a.callback
             );
         }
 
-        bool ptFromTaker = (orderType == OrderType.YT_FOR_SY);
+        bool ptFromTaker = (a.orderType == OrderType.YT_FOR_SY);
         address pyFromTaker = ptFromTaker ? PT : YT;
         address pyFromMaker = ptFromTaker ? YT : PT;
 
         // Taker => YT
         _transferFrom(IERC20(pyFromTaker), msg.sender, YT, totalPYFromTaker);
         // Maker => YT
-        _transferFromMulti(IERC20(pyFromMaker), a.params, YT, out.netMakings);
+        _transferFromMakers(IERC20(pyFromMaker), a.params, YT, out.netMakings);
 
         // YT => This
         IPYieldToken(YT).redeemPY(address(this));
@@ -265,24 +251,21 @@ abstract contract PendleOrderMixin is
         _transferOut(SY, a.receiver, totalSyToTaker);
 
         // This => Makers
-        _redeemSy_transferOut(SY, a.params, out.totalTaking, out.netTakings);
+        uint256[] memory toMakers = _redeemSy_transferToMakers(SY, a.params, out.netTakings);
 
         // This => Fee
-        _transferOut(SY, onchain.feeRecipient, out.totalFee);
+        _transferOut(SY, feeRecipient, totalFee);
 
-        emit FlashFill(
-            orderType, YT, msg.sender, totalSyToTaker, totalPYFromTaker, totalFee, out.totalMaking, out.totalTaking
-        );
+        // fromMakers == netMakings
+        _checkSafety_emitEvents(a.params, orderHashes, out.netMakings, toMakers, out.netFees, out.notionalVolumes);
     }
 
     // ----------------- verify & convert functions -----------------
-
     function _validateOrdersSkipSig(FillOrderParams[] memory params) internal view {
         uint256 len = params.length;
         require(len != 0, "LOP: empty batch");
 
         (address YT, OrderType orderType) = (params[0].order.YT, params[0].order.orderType);
-        bool isTokenOut = (orderType == OrderType.PT_FOR_SY || orderType == OrderType.YT_FOR_SY);
 
         uint256 expiry = IPYieldToken(YT).expiry();
         require(block.timestamp < expiry, "LOP: PY expired");
@@ -294,56 +277,77 @@ abstract contract PendleOrderMixin is
             require(order.YT == YT, "LOP: not same YT");
             require(block.timestamp < order.expiry, "LOP: order expired");
             require(order.nonce >= nonce[order.maker], "LOP: order invalidated");
-
-            if (isTokenOut) require(order.token != WNATIVE, "LOP: invalid tokenOut");
-            // else assert(order.token!=NATIVE) // always true
         }
     }
 
-    function _prep(FillOrderParams[] memory params, bool tokenToSy)
+    function _checkSig_doPermit_updMakingAndRemaining(FillOrderParams[] memory params)
         internal
-        returns (address SY, address PT, address YT, OnchainParams memory onchain)
+        returns (address SY, address PT, address YT, bytes32[] memory orderHashes)
     {
-        _checkSig_doPermit_updMakingAndRemaining(params); // state changes to avoid reentrancy
-
-        YT = params[0].order.YT;
-        SY = IPYieldToken(YT).SY();
-        PT = IPYieldToken(YT).PT();
-
-        if (tokenToSy) {
-            _transferIn_mintSy(SY, params);
-        }
-
-        onchain = getOnchainParams(YT);
-    }
-
-    function _checkSig_doPermit_updMakingAndRemaining(FillOrderParams[] memory params) internal {
         uint256 len = params.length;
+        orderHashes = new bytes32[](len);
+
         for (uint256 i = 0; i < len; i = _inc1(i)) {
             FillOrderParams memory param = params[i];
 
-            (bytes32 orderHash, uint256 remainingMakerAmount) = _checkSig_doPermit(param.order, param.signature);
+            (bytes32 orderHash, uint256 remainingMakerAmount, uint256 filledMakerAmount) =
+                _checkSig_doPermit(param.order, param.signature);
             uint256 netMaking = PMath.min(param.makingAmount, remainingMakerAmount);
 
             unchecked {
                 remainingMakerAmount = remainingMakerAmount - netMaking;
-                _remaining[orderHash] = remainingMakerAmount + 1;
-
-                emit OrderRemainingUpdated(orderHash, remainingMakerAmount);
+                _status[orderHash] =
+                    OrderStatus((remainingMakerAmount + 1).Uint128(), (filledMakerAmount + netMaking).Uint128());
             }
 
             param.makingAmount = netMaking;
+
+            orderHashes[i] = orderHash;
+        }
+
+        YT = params[0].order.YT;
+        SY = IPYieldToken(YT).SY();
+        PT = IPYieldToken(YT).PT();
+    }
+
+    function _checkSafety_emitEvents(
+        FillOrderParams[] memory params,
+        bytes32[] memory hashes,
+        uint256[] memory fromMakers,
+        uint256[] memory toMakers,
+        uint256[] memory netFees,
+        uint256[] memory notionalVolumes
+    ) internal {
+        uint256 len = hashes.length;
+
+        for (uint256 i = 0; i < len; i = _inc1(i)) {
+            require(fromMakers[i].mulDown(params[i].order.failSafeRate) <= toMakers[i], "LOP: fail safe");
+        }
+
+        for (uint256 i = 0; i < len; i = _inc1(i)) {
+            Order memory order = params[i].order;
+            emit OrderFilled(
+                hashes[i],
+                order.orderType,
+                order.YT,
+                order.token,
+                fromMakers[i],
+                toMakers[i],
+                netFees[i],
+                notionalVolumes[i]
+            );
         }
     }
 
     function _checkSig_doPermit(Order memory order, bytes memory signature)
         internal
-        returns (bytes32, /*orderHash*/ uint256 /*remainingMakerAmount*/ )
+        returns (bytes32, /*orderHash*/ uint256, /*remainingMakerAmount*/ uint256 /*filledMakerAmount*/ )
     {
         bytes32 orderHash = hashOrder(order);
-        uint256 remainingMakerAmount = _remaining[orderHash];
+        OrderStatus memory status = _status[orderHash];
+        (uint256 remainingMakerAmount, uint256 filledMakerAmount) = (status.remaining, status.filledAmount);
 
-        if (remainingMakerAmount == _ORDER_FILLED) return (orderHash, 0);
+        if (remainingMakerAmount == _ORDER_FILLED) return (orderHash, 0, filledMakerAmount);
 
         if (remainingMakerAmount == _ORDER_DOES_NOT_EXIST) {
             require(SignatureChecker.isValidSignatureNow(order.maker, orderHash, signature), "LOP: bad signature");
@@ -355,7 +359,7 @@ abstract contract PendleOrderMixin is
                 // proceed only if permit length is enough to store address
                 (address token, bytes memory permit) = order.permit.decodeTargetAndCalldata();
                 _permitMemory(token, permit);
-                require(_remaining[orderHash] == _ORDER_DOES_NOT_EXIST, "LOP: reentrancy detected");
+                require(_status[orderHash].remaining == _ORDER_DOES_NOT_EXIST, "LOP: reentrancy detected");
             }
         } else {
             unchecked {
@@ -363,35 +367,32 @@ abstract contract PendleOrderMixin is
             }
         }
 
-        return (orderHash, remainingMakerAmount);
+        return (orderHash, remainingMakerAmount, filledMakerAmount);
     }
 
     // ----------------- simple helper functions functions -----------------
 
-    function _transferIn_mintSy(address SY, FillOrderParams[] memory params) internal {
+    function _transferFromMakers_mintSy_updMakings(address SY, FillOrderParams[] memory params)
+        internal
+        returns (uint256[] memory fromMakers)
+    {
         uint256 len = params.length;
-        (bool isSame, address commonToken) = _isSameTokens(params);
-        uint256 totalMakingCommon = 0;
-
-        for (uint256 i = 0; i < len; i = _inc1(i)) {
-            FillOrderParams memory param = params[i];
-            if (param.makingAmount == 0) continue;
+        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)) {
+                _transferIn(sharedToken, params[r].order.maker, params[r].makingAmount);
+                totalMaking += params[r].makingAmount;
+                fromMakers[r] = params[r].makingAmount;
+            }
 
-            _transferIn(param.order.token, param.order.maker, param.makingAmount);
-            if (isSame) totalMakingCommon += param.makingAmount;
-        }
+            if (sharedToken == SY || totalMaking == 0) continue;
 
-        if (isSame) {
-            if (commonToken == SY || totalMakingCommon == 0) return;
-            uint256 totalSy = __mintSy_Single(SY, commonToken, totalMakingCommon);
-            for (uint256 i = 0; i < len; i = _inc1(i)) {
-                params[i].makingAmount = params[i].makingAmount * totalSy / totalMakingCommon;
-            }
-        } else {
-            for (uint256 i = 0; i < len; i = _inc1(i)) {
-                FillOrderParams memory param = params[i];
-                if (param.makingAmount == 0 || param.order.token == SY) continue;
-                param.makingAmount = __mintSy_Single(SY, param.order.token, param.makingAmount);
+            uint256 totalSy = __mintSy_Single(SY, sharedToken, totalMaking);
+            for (uint256 i = l; i < r; i = _inc1(i)) {
+                params[i].makingAmount = params[i].makingAmount * totalSy / totalMaking;
             }
         }
     }
@@ -401,81 +402,87 @@ abstract contract PendleOrderMixin is
             _wrap_unwrap_ETH(WNATIVE, NATIVE, netTokenIn);
             token = NATIVE;
         }
+        _safeApproveInf(token, SY);
         return
             IStandardizedYield(SY).deposit{value: token == NATIVE ? netTokenIn : 0}(address(this), token, netTokenIn, 0);
     }
 
-    function _redeemSy_transferOut(
-        address SY,
-        FillOrderParams[] memory params,
-        uint256 totalSyOut,
-        uint256[] memory netSyOuts
-    ) internal {
+    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;
-        (bool isSame, address commonToken) = _isSameTokens(params);
+        toMakers = new uint256[](len);
+
+        for ((uint256 l, uint256 r) = (0, 0); l < len; l = r) {
+            address sharedToken = params[l].order.token;
+            uint256 totalSy = 0;
 
-        if (isSame) {
-            if (commonToken == SY) {
-                _transferFromMulti(IERC20(SY), address(this), params, netSyOuts);
-                return;
+            for (; r < len && __stillShared(sharedToken, params[r].order.token); r = _inc1(r)) {
+                totalSy += netSyOuts[r];
             }
 
-            uint256 totalTokenOut = __redeemSy_Single(address(this), SY, commonToken, totalSyOut);
-            for (uint256 i = 0; i < len; i = _inc1(i)) {
-                Order memory order = params[i].order;
-                uint256 netOut = netSyOuts[i] * totalTokenOut / totalSyOut;
-                if (order.token == NATIVE) payable(order.receiver).sendValue(netOut);
-                else IERC20(order.token).safeTransfer(order.receiver, netOut);
+            if (sharedToken == SY) {
+                for (uint256 i = l; i < r; i = _inc1(i)) {
+                    _transferOut(SY, params[i].order.receiver, netSyOuts[i]);
+                    toMakers[i] = netSyOuts[i];
+                }
+                continue;
             }
-        } else {
-            for (uint256 i = 0; i < len; i = _inc1(i)) {
-                Order memory order = params[i].order;
-                if (order.token == SY) {
-                    _transferOut(SY, order.receiver, netSyOuts[i]);
-                } else {
-                    __redeemSy_Single(order.receiver, SY, order.token, netSyOuts[i]);
+
+            if (r - l == 1) {
+                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)) {
+                    address token = params[i].order.token;
+                    toMakers[i] = netSyOuts[i] * totalToken / totalSy;
+                    if (sharedToken != token) {
+                        // WNATIVE case
+                        _wrap_unwrap_ETH(sharedToken, token, toMakers[i]);
+                    }
+                    _transferOut(token, params[i].order.receiver, toMakers[i]);
                 }
             }
         }
     }
 
+    function __stillShared(address currentShared, address nextToken) private view returns (bool) {
+        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)
     {
-        if (tokenOut == NATIVE) {
-            address tokenRedeemSy = IStandardizedYield(SY).isValidTokenOut(tokenOut) ? tokenOut : WNATIVE;
+        if (tokenOut == NATIVE || tokenOut == WNATIVE) {
+            address otherToken = tokenOut == NATIVE ? WNATIVE : NATIVE;
+            address tokenRedeemSy = IStandardizedYield(SY).isValidTokenOut(tokenOut) ? tokenOut : otherToken;
+
             netTokenOut = IStandardizedYield(SY).redeem(address(this), netSyIn, tokenRedeemSy, 0, false);
 
-            if (tokenRedeemSy == WNATIVE) {
-                _wrap_unwrap_ETH(WNATIVE, NATIVE, netTokenOut);
+            if (tokenOut != tokenRedeemSy) {
+                _wrap_unwrap_ETH(tokenRedeemSy, tokenOut, netTokenOut);
+            }
+
+            if (receiver != address(this)) {
+                _transferOut(tokenOut, receiver, netTokenOut);
             }
-            payable(receiver).sendValue(netTokenOut);
         } else {
             return IStandardizedYield(SY).redeem(receiver, netSyIn, tokenOut, 0, false);
         }
     }
 
-    function _isSameTokens(FillOrderParams[] memory params)
-        internal
-        pure
-        returns (bool, /*isSame*/ address /*commonToken*/ )
-    {
-        uint256 len = params.length;
-        address commonToken = params[0].order.token;
-        for (uint256 i = 1; i < len; i = _inc1(i)) {
-            if (params[i].order.token != commonToken) return (false, address(0));
-        }
-        return (true, commonToken);
-    }
-
     function _inc1(uint256 i) internal pure returns (uint256) {
         unchecked {
             return i + 1;
         }
     }
 
-    function _transferFromMulti(IERC20 token, FillOrderParams[] memory params, address to, uint256[] memory netIn)
+    function _transferFromMakers(IERC20 token, FillOrderParams[] memory params, address to, uint256[] memory netIn)
         internal
     {
         uint256 len = params.length;
@@ -484,7 +491,7 @@ abstract contract PendleOrderMixin is
         }
     }
 
-    function _transferFromMulti(IERC20 token, address payer, FillOrderParams[] memory params, uint256[] memory netOut)
+    function _transferToMakers(IERC20 token, address payer, FillOrderParams[] memory params, uint256[] memory netOut)
         internal
     {
         uint256 len = params.length;
@@ -499,17 +506,6 @@ abstract contract PendleOrderMixin is
         }
     }
 
-    // ----------------- Getters -----------------
-    function getOnchainParams(address YT) public returns (OnchainParams memory) {
-        uint256 timeToExpiry = IPYieldToken(YT).expiry() - block.timestamp;
-        return OnchainParams({
-            timeToExpiry: timeToExpiry,
-            pyIndex: IPYieldToken(YT).pyIndexCurrent(),
-            feeRecipient: feeRecipient,
-            lnFeeRateRoot: lnFeeRateRoot
-        });
-    }
-
     function hashOrder(Order memory order) public view returns (bytes32) {
         StaticOrder memory staticOrder;
         assembly {

package/contracts/limit/helpers/NonceManager.sol

@@ -8,6 +8,8 @@ contract NonceManager {
 
     mapping(address => uint256) public nonce;
 
+    uint256[100] private __gap;
+
     /// @notice Advances nonce by one
     function increaseNonce() external {
         advanceNonce(1);