@pendle/core-v2 3.0.0-beta-10 → 3.0.0-beta-12

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

@@ -3,44 +3,37 @@
 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
+abstract contract LimitRouterBase 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)"
-    );
+    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;
 
     address public feeRecipient;
-    uint96 public lnFeeRateRoot;
+
+    // YT => lnFeeRateRoot // not to be accessed directly
+    mapping(address => uint256) internal __lnFeeRateRoot;
 
     address private immutable WNATIVE;
 
@@ -55,60 +48,47 @@ 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);
-    }
-
-    function normalFill(FillOrderParams[] memory params, address receiver, uint256 maxTaking, bytes memory callback)
-        external
-        returns (uint256 actualMaking, uint256 actualTaking, uint256 totalFee)
-    {
-        _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));
-        } else {
-            return normalFillPYForToken(Args(orderType, params, receiver, maxTaking, callback));
-        }
+        setFeeRecipient(_feeRecipient);
     }
 
-    function flashFill(FillOrderParams[] memory params, address receiver, uint256 maxInput, bytes memory callback)
-        external
-        returns (uint256 netOutputToTaker, uint256 netInputFromTaker, uint256 totalFee)
-    {
+    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 flashFillTokenForPY(Args(orderType, params, receiver, maxInput, callback));
+            return fillTokenForPY(Args(orderType, params, receiver, maxTaking, callback));
         } else {
-            return flashFillPYForToken(Args(orderType, params, receiver, maxInput, callback));
+            return fillPYForToken(Args(orderType, params, receiver, maxTaking, callback));
         }
     }
 
     // ----------------- Core logic -----------------
 
-    // solhint-disable-next-line
     struct Args {
         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)
-    {
-        (address SY, address PT, address YT, bytes32[] memory orderHashes) =
-            _checkSig_doPermit_updMakingAndRemaining(a.params);
+    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, lnFeeRateRoot);
+        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");
@@ -118,7 +98,12 @@ 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).limitRouterCallback(
+                actualMaking,
+                actualTaking,
+                totalFee,
+                a.callback
+            );
         }
 
         // Taker => Makers
@@ -132,14 +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)
-    {
-        (address SY, address PT, address YT, bytes32[] memory orderHashes) =
-            _checkSig_doPermit_updMakingAndRemaining(a.params);
+    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, lnFeeRateRoot);
+        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");
@@ -150,105 +133,16 @@ abstract contract PendleOrderMixin is
 
         // callback to Taker
         if (a.callback.length > 0) {
-            ILimitOrderCallee(msg.sender).normalFillCall(a.orderType, actualMaking, actualTaking, totalFee, a.callback);
-        }
-
-        // Taker => This
-        _transferFrom(IERC20(SY), msg.sender, address(this), actualTaking);
-
-        // 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);
-    }
-
-    // ----------------- 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
+            callbackReturn = IPLimitRouterCallback(msg.sender).limitRouterCallback(
+                actualMaking,
+                actualTaking,
+                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);
+        _transferFrom(IERC20(SY), msg.sender, address(this), actualTaking);
 
         // This => Makers
         uint256[] memory toMakers = _redeemSy_transferToMakers(SY, a.params, out.netTakings);
@@ -270,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");
@@ -280,18 +174,19 @@ abstract contract PendleOrderMixin is
         }
     }
 
-    function _checkSig_doPermit_updMakingAndRemaining(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_doPermit(param.order, param.signature);
+            (bytes32 orderHash, uint256 remainingMakerAmount, uint256 filledMakerAmount) = _checkSig(
+                param.order,
+                param.signature
+            );
             uint256 netMaking = PMath.min(param.makingAmount, remainingMakerAmount);
 
             unchecked {
@@ -322,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],
@@ -341,8 +236,12 @@ 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 +254,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;
@@ -380,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;
@@ -399,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;
             }
         }
@@ -412,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;
@@ -428,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];
                 }
@@ -444,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) {
@@ -458,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;
@@ -484,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]);
         }
     }
 
@@ -525,9 +418,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++) {
+            require(lnFeeRateRoots[i] > 0, "LOP: zero fee not allowed");
+            __lnFeeRateRoot[YTs[i]] = lnFeeRateRoots[i];
+        }
     }
 }

package/contracts/limit/PendleLimitRouter.sol

@@ -1,16 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "./PendleOrderMixin.sol";
-import "./helpers/NonceManager.sol";
-import "../core/libraries/TokenHelper.sol";
-import "../interfaces/IAddressProvider.sol";
+import "./LimitRouterBase.sol";
+import "../core/libraries/Errors.sol";
 
-contract PendleLimitRouter is PendleOrderMixin, IPLimitRouter {
-    using ArgumentsDecoder for bytes;
+contract PendleLimitRouter is LimitRouterBase {
     using Address for address;
 
-    constructor(address _WNATIVE) PendleOrderMixin(_WNATIVE) {
+    constructor(address _WNATIVE) LimitRouterBase(_WNATIVE) {
         _disableInitializers();
     }
 
@@ -32,11 +29,9 @@ contract PendleLimitRouter is PendleOrderMixin, IPLimitRouter {
         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);
@@ -47,11 +42,9 @@ contract PendleLimitRouter is PendleOrderMixin, IPLimitRouter {
         }
     }
 
-    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");
@@ -64,4 +57,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);
+    }
 }