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

package/contracts/limit/PendleOrderMixin.sol

@@ -33,7 +33,7 @@ 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;
@@ -50,6 +50,7 @@ abstract contract PendleOrderMixin is
         WNATIVE = _WNATIVE;
     }
 
+    // solhint-disable-next-line no-empty-blocks
     receive() external payable {}
 
     function initialize(address _feeRecipient, uint96 _lnFeeRateRoot) external initializer {
@@ -62,12 +63,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 +76,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 +116,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 +194,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 +205,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 +249,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,31 +275,16 @@ 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];
 
@@ -328,11 +294,44 @@ abstract contract PendleOrderMixin is
             unchecked {
                 remainingMakerAmount = remainingMakerAmount - netMaking;
                 _remaining[orderHash] = remainingMakerAmount + 1;
-
-                emit OrderRemainingUpdated(orderHash, remainingMakerAmount);
             }
 
             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]
+            );
         }
     }
 
@@ -368,30 +367,27 @@ abstract contract PendleOrderMixin is
 
     // ----------------- 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;
             }
         }
     }
@@ -405,77 +401,82 @@ abstract contract PendleOrderMixin is
             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 +485,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 +500,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/router/ActionAddRemoveLiq.sol

@@ -82,7 +82,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
         uint256 netSyReceived;
 
         if (!_isEmptyLimit(limit)) {
-            (netPtLeft, netSyReceived, netSyFee,) = _fillLimit(receiver, netPtLeft, limit);
+            (netPtLeft, netSyReceived, netSyFee,) = _fillLimit(market, netPtLeft, limit);
             _transferOut(address(PT), market, netPtLeft);
         }
 
@@ -166,7 +166,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
         uint256 netPtReceived;
 
         if (!_isEmptyLimit(limit)) {
-            (netSyLeft, netPtReceived, netSyFee,) = _fillLimit(receiver, netSyLeft, limit);
+            (netSyLeft, netPtReceived, netSyFee,) = _fillLimit(market, netSyLeft, limit);
             _transferOut(address(SY), market, netSyLeft);
         }
 
@@ -194,7 +194,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBase {
         uint256 minLpOut,
         uint256 minYtOut,
         TokenInput calldata input
-    ) external returns (uint256 netLpOut, uint256 netYtOut) {
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut) {
         (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
 
         uint256 netSyUsed = _mintSyFromToken(address(this), address(SY), 1, input);