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

package/contracts/interfaces/IPLimitRouter.sol

@@ -50,7 +50,7 @@ struct Order {
     uint256 makingAmount;
     uint256 lnImpliedRate;
     uint256 failSafeRate;
-    bytes permit; // On first fill: permit.1.call(abi.encodePacked(permit.selector, permit.2))
+    bytes permit;
 }
 
 struct FillOrderParams {
@@ -59,7 +59,13 @@ struct FillOrderParams {
     uint256 makingAmount;
 }
 
-interface IPOrderMixin is IPOrderMixinType {
+interface IPLimitRouterCallback is IPOrderMixinType {
+    function normalFillCallback(uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory data)
+        external
+        returns (bytes memory);
+}
+
+interface IPLimitRouter is IPOrderMixinType {
     struct OrderStatus {
         uint128 filledAmount;
         uint128 remaining;
@@ -78,59 +84,15 @@ interface IPOrderMixin is IPOrderMixinType {
         uint256 notionalVolume
     );
 
-    /**
-     * (making, taking)
-     * SY_FOR_PT: (SY, PT)
-     * PT_FOR_SY: (PT, SY)
-     * SY_FOR_YT: (SY, YT)
-     * YT_FOR_SY: (YT, SY)
-     */
     // @dev actualMaking, actualTaking are in the SY form
     function normalFill(FillOrderParams[] memory params, address receiver, uint256 maxTaking, bytes calldata callback)
         external
-        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee);
-
-    /**
-     * (output, input)
-     * SY_FOR_PT: (YT, SY)
-     * PT_FOR_SY: (SY, YT)
-     * SY_FOR_YT: (PT, SY)
-     * YT_FOR_SY: (SY, PT)
-     */
-
-    // @dev netOutputToTaker, netInputFromTaker are in the SY form
-    function flashFill(FillOrderParams[] memory params, address receiver, uint256 maxInput, bytes calldata callback)
-        external
-        returns (uint256 netOutputToTaker, uint256 netInputFromTaker, uint256 totalFee);
+        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn);
 
     function feeRecipient() external view returns (address);
 
-    function lnFeeRateRoot() external view returns (uint96);
-
     function hashOrder(Order memory order) external view returns (bytes32);
-}
-
-interface ILimitOrderCallee is IPOrderMixinType {
-    /// Refer to normalFill
-    function normalFillCall(
-        OrderType orderType,
-        uint256 actualMaking,
-        uint256 actualTaking,
-        uint256 totalFee,
-        bytes memory data
-    ) external;
-
-    /// Refer to flashFill
-    function flashFillCall(
-        OrderType orderType,
-        uint256 netOutputToTaker,
-        uint256 netInputFromTaker,
-        uint256 totalFee,
-        bytes memory data
-    ) external;
-}
 
-interface IPLimitRouter is IPOrderMixin {
     function cancelSingle(Order calldata order) external;
 
     function cancelBatch(Order[] calldata orders) external;
@@ -146,4 +108,6 @@ interface IPLimitRouter is IPOrderMixin {
         returns (uint256[] memory remainings, uint256[] memory filledAmounts);
 
     function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+    function simulate(address target, bytes calldata data) external payable;
 }

package/contracts/interfaces/IPMerkleDistributor.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPMerkleDistributor {
+    event Claimed(address indexed user, address indexed receiver, uint256 amount);
+    event Verified(address indexed user, uint256 amountClaimable);
+    event SetMerkleRoot(bytes32 indexed merkleRoot);
+
+    error InvalidMerkleProof();
+
+    function claim(
+        address receiver,
+        uint256 totalAccrued,
+        bytes32[] calldata proof
+    ) external returns (uint256 amountOut);
+
+    function claimVerified(address receiver) external returns (uint256 amountOut);
+
+    function verify(
+        address user,
+        uint256 totalAccrued,
+        bytes32[] calldata proof
+    ) external returns (uint256 amountVerified);
+}

package/contracts/limit/LimitMathCore.sol

@@ -21,27 +21,6 @@ library LimitMathCore {
         );
     }
 
-    function calcFlashBatch(FillOrderParams[] memory params, address YT, uint256 lnFeeRateRoot)
-        internal
-        returns (
-            uint256 netInputFromTaker,
-            uint256 netOutputToTaker,
-            uint256 netFee,
-            IPOrderMixinType.NormalResults memory out
-        )
-    {
-        (, function (uint256, uint256, uint256, PYIndex) internal pure returns (uint256, uint256) calcFlash) =
-            getCalcFunctions(params[0].order.orderType);
-
-        uint256 timeToExpiry = IPYieldToken(YT).expiry() - block.timestamp;
-        uint256 pyIndex = IPYieldToken(YT).pyIndexCurrent();
-
-        out = calcNormalBatch(params, timeToExpiry, pyIndex, lnFeeRateRoot);
-        (netInputFromTaker, netOutputToTaker) =
-            calcFlash(out.totalMaking, out.totalTaking, out.totalFee, PYIndex.wrap(pyIndex));
-        netFee = out.totalFee;
-    }
-
     // --- PURE FUNCTIONS ---
     function calcNormalBatch(
         FillOrderParams[] memory params,
@@ -55,7 +34,7 @@ library LimitMathCore {
         out.netFees = new uint256[](len);
         out.notionalVolumes = new uint256[](len);
 
-        (function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calcNormal,) =
+        function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calcNormal =
             getCalcFunctions(params[0].order.orderType);
 
         uint256 feeRate = impliedRateToExchangeRate(lnFeeRateRoot, timeToExpiry);
@@ -89,7 +68,7 @@ library LimitMathCore {
         // notionalVolume = makeSy
 
         takePt = index.syToAsset(makeSy).mulDown(r);
-        fee = makeSy.mulDown(f - PMath.ONE);
+        fee = makeSy * (f - PMath.ONE) / f;
         notionalVolume = makeSy;
     }
 
@@ -103,8 +82,8 @@ library LimitMathCore {
         // fee = takeSy * (f-1)/f
         // notionalVolume = takeSy
 
-        takeSy = index.assetToSyUp(makePt.divDown(r));
-        fee = takeSy * (f - PMath.ONE) / f;
+        takeSy = index.assetToSy(makePt.divDown(r));
+        fee = takeSy.mulDown(f - PMath.ONE);
         notionalVolume = takeSy;
     }
 
@@ -117,10 +96,11 @@ library LimitMathCore {
         // yt = pt / (r-1)
         // fee = makeSy * ((f-1) / f) / (r-1)
         // notionalVolume = makeSy / (r-1)
+        uint256 pt_yt_ratio = r - PMath.ONE;
 
-        takeYt = index.syToAssetUp(makeSy) * r / (r - PMath.ONE);
-        fee = (makeSy * (f - PMath.ONE) / f).divDown(r - PMath.ONE);
-        notionalVolume = makeSy.divDown(r - PMath.ONE);
+        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)
@@ -132,55 +112,11 @@ library LimitMathCore {
         // takeSy = pt / r / index
         // feeSy = takeSy * (f-1) / (r-1)
         // notionalVolume = takeSy / (r-1)
+        uint256 pt_yt_ratio = r - PMath.ONE;
 
-        takeSy = index.assetToSyUp(makeYt * (r - PMath.ONE) / r);
-        fee = takeSy * (f - PMath.ONE) / (r - PMath.ONE);
-        notionalVolume = takeSy.divDown(r - PMath.ONE);
-    }
-
-    // Proof of index.syToAsset(index.assetToSyUp(takePt)) >= takePt at end of this file
-    function calcSyForPtFlash(uint256 makeSy, uint256 takePt, uint256 fee, PYIndex index)
-        internal
-        pure
-        returns (uint256 syFromTaker, uint256 ytToTaker)
-    {
-        uint256 syToMintPy = index.assetToSyUp(takePt);
-
-        syFromTaker = syToMintPy - (makeSy - fee);
-        ytToTaker = takePt;
-    }
-
-    function calcPtForSyFlash(uint256 makePt, uint256 takeSy, uint256 fee, PYIndex index)
-        internal
-        pure
-        returns (uint256 ytFromTaker, uint256 syToTaker)
-    {
-        uint256 syRedeemFromPy = index.assetToSy(makePt);
-        syToTaker = syRedeemFromPy - (takeSy + fee);
-
-        ytFromTaker = makePt;
-    }
-
-    function calcSyForYtFlash(uint256 makeSy, uint256 takeYt, uint256 fee, PYIndex index)
-        internal
-        pure
-        returns (uint256 syFromTaker, uint256 ptToTaker)
-    {
-        uint256 syToMintPy = index.assetToSyUp(takeYt);
-
-        syFromTaker = syToMintPy - (makeSy - fee);
-        ptToTaker = takeYt;
-    }
-
-    function calcYtForSyFlash(uint256 makeYt, uint256 takeSy, uint256 fee, PYIndex index)
-        internal
-        pure
-        returns (uint256 ptFromTaker, uint256 syToTaker)
-    {
-        uint256 syRedeemFromPy = index.assetToSy(makeYt);
-
-        syToTaker = syRedeemFromPy - (takeSy + fee);
-        ptFromTaker = makeYt;
+        takeSy = index.assetToSy(makeYt * pt_yt_ratio / r);
+        fee = (takeSy * (f - PMath.ONE) / f).divDown(pt_yt_ratio);
+        notionalVolume = takeSy.divDown(pt_yt_ratio);
     }
 
     function impliedRateToExchangeRate(uint256 lnRate, uint256 timeToExpiry) internal pure returns (uint256) {
@@ -193,39 +129,21 @@ library LimitMathCore {
         }
     }
 
-    /// @dev diff sig for calcNormal and calcFlash to avoid miscalling
     function getCalcFunctions(IPOrderMixinType.OrderType t)
         internal
         pure
         returns (
-            function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calcNormal,
-            function (uint256, uint256, uint256, PYIndex) internal pure returns (uint256, uint256) calcFlash
+            function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calcNormal
         )
     {
         if (t == IPOrderMixinType.OrderType.SY_FOR_PT) {
-            return (calcSyForPtNormal, calcSyForPtFlash);
+            return (calcSyForPtNormal);
         } else if (t == IPOrderMixinType.OrderType.PT_FOR_SY) {
-            return (calcPtForSyNormal, calcPtForSyFlash);
+            return (calcPtForSyNormal);
         } else if (t == IPOrderMixinType.OrderType.SY_FOR_YT) {
-            return (calcSyForYtNormal, calcSyForYtFlash);
+            return (calcSyForYtNormal);
         } else {
-            return (calcYtForSyNormal, calcYtForSyFlash);
+            return (calcYtForSyNormal);
         }
     }
 }
-
-/*
-Proof of index.syToAsset(index.assetToSyUp(x)) >= x
-
-let y = index.assetToSyUp(x)
-=> y <= (x+index-1) * 1e18  / index < y+1 (since floor of the division == y)
-=> (x+index-1) * 1e18  / index < y+1
-=> x+index-1 < (y+1) * index / 1e18
-=> x < (y+1) * index / 1e18 - index + 1
-
-=> x < y * index / 1e18 + index / 1e18 - index + 1
-It's obvious that "index / 1e18 - index + 1" < 0 as long as index >= 2
-
-=> y * index / 1e18 + index / 1e18 - index + 1 <= y * index / 1e18
-=> x <= y * index / 1e18
-*/

package/contracts/limit/PendleLimitRouter.sol

@@ -2,12 +2,9 @@
 pragma solidity ^0.8.17;
 
 import "./PendleOrderMixin.sol";
-import "./helpers/NonceManager.sol";
-import "../core/libraries/TokenHelper.sol";
-import "../interfaces/IAddressProvider.sol";
+import "../core/libraries/Errors.sol";
 
-contract PendleLimitRouter is PendleOrderMixin, IPLimitRouter {
-    using ArgumentsDecoder for bytes;
+contract PendleLimitRouter is PendleOrderMixin {
     using Address for address;
 
     constructor(address _WNATIVE) PendleOrderMixin(_WNATIVE) {
@@ -64,4 +61,9 @@ contract PendleLimitRouter is PendleOrderMixin, IPLimitRouter {
     function DOMAIN_SEPARATOR() external view returns (bytes32) {
         return _domainSeparatorV4();
     }
+
+    function simulate(address target, bytes calldata data) external payable {
+        (bool success, bytes memory result) = target.delegatecall(data);
+        revert Errors.SimulationResults(success, result);
+    }
 }

package/contracts/limit/PendleOrderMixin.sol

@@ -3,34 +3,24 @@
 pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "@openzeppelin/contracts/utils/Address.sol";
 import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
 import "../interfaces/IPLimitRouter.sol";
 import "../core/libraries/BoringOwnableUpgradeable.sol";
 import "../core/libraries/TokenHelper.sol";
 import "../interfaces/IStandardizedYield.sol";
-import "./helpers/Permitable.sol";
 import "./helpers/NonceManager.sol";
-import "./helpers/ArgumentsDecoder.sol";
 import "../interfaces/IWETH.sol";
 import {LimitMathCore as LimitMath} from "./LimitMathCore.sol";
 
 abstract contract PendleOrderMixin is
     EIP712Upgradeable,
-    IPOrderMixin,
-    Permitable,
+    IPLimitRouter,
     BoringOwnableUpgradeable,
     NonceManager,
     TokenHelper
 {
     using SafeERC20 for IERC20;
-    using PYIndexLib for PYIndex;
     using PMath for uint256;
-    using PMath for int256;
-    using PYIndexLib for IPYieldToken;
-    using ArgumentsDecoder for bytes;
-    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,uint256 failSafeRate,bytes permit)"
@@ -40,7 +30,9 @@ abstract contract PendleOrderMixin is
     uint128 internal constant _ORDER_FILLED = 1;
 
     address public feeRecipient;
-    uint96 public lnFeeRateRoot;
+
+    // YT => lnFeeRateRoot // not to be accessed directly
+    mapping(address => uint256) internal __lnFeeRateRoot;
 
     address private immutable WNATIVE;
 
@@ -55,15 +47,15 @@ abstract contract PendleOrderMixin is
     // solhint-disable-next-line no-empty-blocks
     receive() external payable {}
 
-    function initialize(address _feeRecipient, uint96 _lnFeeRateRoot) external initializer {
+    function initialize(address _feeRecipient) external initializer {
         __BoringOwnable_init();
         __EIP712_init("Pendle Limit Order Protocol", "1");
-        setFees(_feeRecipient, _lnFeeRateRoot);
+        setFeeRecipient(_feeRecipient);
     }
 
     function normalFill(FillOrderParams[] memory params, address receiver, uint256 maxTaking, bytes memory callback)
         external
-        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee)
+        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn)
     {
         _validateOrdersSkipSig(params);
         OrderType orderType = params[0].order.orderType;
@@ -74,19 +66,6 @@ abstract contract PendleOrderMixin is
         }
     }
 
-    function flashFill(FillOrderParams[] memory params, address receiver, uint256 maxInput, bytes memory callback)
-        external
-        returns (uint256 netOutputToTaker, uint256 netInputFromTaker, uint256 totalFee)
-    {
-        _validateOrdersSkipSig(params);
-        OrderType orderType = params[0].order.orderType;
-        if (orderType == OrderType.SY_FOR_PT || orderType == OrderType.SY_FOR_YT) {
-            return flashFillTokenForPY(Args(orderType, params, receiver, maxInput, callback));
-        } else {
-            return flashFillPYForToken(Args(orderType, params, receiver, maxInput, callback));
-        }
-    }
-
     // ----------------- Core logic -----------------
 
     // solhint-disable-next-line
@@ -94,21 +73,20 @@ abstract contract PendleOrderMixin is
         OrderType orderType;
         FillOrderParams[] params;
         address receiver;
-        uint256 maxTaking; // or maxInput
+        uint256 maxTaking;
         bytes callback;
     }
 
     function normalFillTokenForPY(Args memory a)
         internal
-        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee)
+        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn)
     {
-        (address SY, address PT, address YT, bytes32[] memory orderHashes) =
-            _checkSig_doPermit_updMakingAndRemaining(a.params);
+        (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, lnFeeRateRoot);
+        NormalResults memory out = LimitMath.calcNormalBatch(a.params, YT, getLnFeeRateRoot(YT));
         (actualMaking, actualTaking, totalFee) = (out.totalMaking - out.totalFee, out.totalTaking, out.totalFee);
 
         require(actualTaking <= a.maxTaking, "LOP: maxTaking exceeded");
@@ -118,7 +96,8 @@ abstract contract PendleOrderMixin is
 
         // callback to Taker
         if (a.callback.length > 0) {
-            ILimitOrderCallee(msg.sender).normalFillCall(a.orderType, actualMaking, actualTaking, totalFee, a.callback);
+            callbackReturn =
+                IPLimitRouterCallback(msg.sender).normalFillCallback(actualMaking, actualTaking, totalFee, a.callback);
         }
 
         // Taker => Makers
@@ -134,12 +113,11 @@ abstract contract PendleOrderMixin is
 
     function normalFillPYForToken(Args memory a)
         internal
-        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee)
+        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee, bytes memory callbackReturn)
     {
-        (address SY, address PT, address YT, bytes32[] memory orderHashes) =
-            _checkSig_doPermit_updMakingAndRemaining(a.params);
+        (address SY, address PT, address YT, bytes32[] memory orderHashes) = _checkSig_updMakingAndStatus(a.params);
 
-        NormalResults memory out = LimitMath.calcNormalBatch(a.params, YT, lnFeeRateRoot);
+        NormalResults memory out = LimitMath.calcNormalBatch(a.params, YT, getLnFeeRateRoot(YT));
         (actualMaking, actualTaking, totalFee) = (out.totalMaking, out.totalTaking + out.totalFee, out.totalFee);
 
         require(actualTaking <= a.maxTaking, "LOP: maxTaking exceeded");
@@ -150,7 +128,8 @@ abstract contract PendleOrderMixin is
 
         // callback to Taker
         if (a.callback.length > 0) {
-            ILimitOrderCallee(msg.sender).normalFillCall(a.orderType, actualMaking, actualTaking, totalFee, a.callback);
+            callbackReturn =
+                IPLimitRouterCallback(msg.sender).normalFillCallback(actualMaking, actualTaking, totalFee, a.callback);
         }
 
         // Taker => This
@@ -166,100 +145,6 @@ abstract contract PendleOrderMixin is
         _checkSafety_emitEvents(a.params, orderHashes, out.netMakings, toMakers, out.netFees, out.notionalVolumes);
     }
 
-    // ----------------- Flash functions -----------------
-
-    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
-        uint256[] memory fromMakers = _transferFromMakers_mintSy_updMakings(SY, a.params);
-
-        NormalResults memory out;
-        (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(
-                a.orderType, totalPYToTaker, totalSyFromTaker, totalFee, a.callback
-            );
-        }
-
-        // Taker => This
-        _transferFrom(IERC20(SY), msg.sender, address(this), totalSyFromTaker);
-
-        // This => YT
-        _transferOut(SY, YT, totalSyFromTaker + out.totalMaking - out.totalFee);
-
-        bool isPtToMaker = (a.orderType == OrderType.SY_FOR_PT);
-        address pyToMaker = isPtToMaker ? PT : YT;
-        {
-            address receiverPt = isPtToMaker ? address(this) : a.receiver;
-            address receiverYt = isPtToMaker ? a.receiver : address(this);
-
-            // PT => receiverPt, YT => receiverYt
-            IPYieldToken(YT).mintPY(receiverPt, receiverYt);
-        }
-
-        // This => Makers
-        _transferToMakers(IERC20(pyToMaker), address(this), a.params, out.netTakings);
-
-        // This => Fee
-        _transferOut(SY, feeRecipient, totalFee);
-
-        // toMakers == netTakings
-        _checkSafety_emitEvents(a.params, orderHashes, fromMakers, out.netTakings, out.netFees, out.notionalVolumes);
-    }
-
-    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, YT, lnFeeRateRoot);
-
-        require(totalPYFromTaker <= a.maxTaking, "LOP: maxInput exceeded");
-
-        // callback to Taker
-        if (a.callback.length > 0) {
-            ILimitOrderCallee(msg.sender).flashFillCall(
-                a.orderType, totalSyToTaker, totalPYFromTaker, totalFee, a.callback
-            );
-        }
-
-        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
-        _transferFromMakers(IERC20(pyFromMaker), a.params, YT, out.netMakings);
-
-        // YT => This
-        IPYieldToken(YT).redeemPY(address(this));
-
-        // This => Taker
-        _transferOut(SY, a.receiver, totalSyToTaker);
-
-        // This => Makers
-        uint256[] memory toMakers = _redeemSy_transferToMakers(SY, a.params, out.netTakings);
-
-        // This => Fee
-        _transferOut(SY, feeRecipient, totalFee);
-
-        // 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;
@@ -280,7 +165,7 @@ abstract contract PendleOrderMixin is
         }
     }
 
-    function _checkSig_doPermit_updMakingAndRemaining(FillOrderParams[] memory params)
+    function _checkSig_updMakingAndStatus(FillOrderParams[] memory params)
         internal
         returns (address SY, address PT, address YT, bytes32[] memory orderHashes)
     {
@@ -291,7 +176,7 @@ abstract contract PendleOrderMixin is
             FillOrderParams memory param = params[i];
 
             (bytes32 orderHash, uint256 remainingMakerAmount, uint256 filledMakerAmount) =
-                _checkSig_doPermit(param.order, param.signature);
+                _checkSig(param.order, param.signature);
             uint256 netMaking = PMath.min(param.makingAmount, remainingMakerAmount);
 
             unchecked {
@@ -341,8 +226,9 @@ abstract contract PendleOrderMixin is
         }
     }
 
-    function _checkSig_doPermit(Order memory order, bytes memory signature)
+    function _checkSig(Order memory order, bytes memory signature)
         internal
+        view
         returns (
             bytes32,
             /*orderHash*/
@@ -355,20 +241,10 @@ abstract contract PendleOrderMixin is
         OrderStatus memory status = _status[orderHash];
         (uint256 remainingMakerAmount, uint256 filledMakerAmount) = (status.remaining, status.filledAmount);
 
-        if (remainingMakerAmount == _ORDER_FILLED) return (orderHash, 0, filledMakerAmount);
-
         if (remainingMakerAmount == _ORDER_DOES_NOT_EXIST) {
             require(SignatureChecker.isValidSignatureNow(order.maker, orderHash, signature), "LOP: bad signature");
 
             remainingMakerAmount = order.makingAmount;
-
-            // permit if there is such
-            if (order.permit.length >= 20) {
-                // proceed only if permit length is enough to store address
-                (address token, bytes memory permit) = order.permit.decodeTargetAndCalldata();
-                _permitMemory(token, permit);
-                require(_status[orderHash].remaining == _ORDER_DOES_NOT_EXIST, "LOP: reentrancy detected");
-            }
         } else {
             unchecked {
                 remainingMakerAmount -= 1;
@@ -525,9 +401,23 @@ abstract contract PendleOrderMixin is
         return _hashTypedDataV4(keccak256(abi.encode(LIMIT_ORDER_TYPEHASH, staticOrder, keccak256(order.permit))));
     }
 
+    function getLnFeeRateRoot(address YT) public view returns (uint256 res) {
+        res = __lnFeeRateRoot[YT];
+        require(res > 0, "LOP: fee not set");
+    }
+
     // ----------------- Owner -----------------
-    function setFees(address _feeRecipient, uint96 _lnFeeRateRoot) public onlyOwner {
+    function setFeeRecipient(address _feeRecipient) public onlyOwner {
         feeRecipient = _feeRecipient;
-        lnFeeRateRoot = _lnFeeRateRoot;
+    }
+
+    function setLnFeeRateRoots(address[] memory YTs, uint256[] memory lnFeeRateRoots) public onlyOwner {
+        uint256 len = YTs.length;
+        require(len == lnFeeRateRoots.length, "LOP: length mismatch");
+
+        for (uint256 i = 0; i < len; i = _inc1(i)) {
+            require(lnFeeRateRoots[i] > 0, "LOP: zero fee not allowed");
+            __lnFeeRateRoot[YTs[i]] = lnFeeRateRoots[i];
+        }
     }
 }