@pendle/core-v2 2.29.1 → 3.0.0-beta-1

package/contracts/interfaces/IPActionSwapYT.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "./IPAllActionType.sol";
 
 interface IPActionSwapYT {
     event SwapYtAndSy(
@@ -35,44 +35,33 @@ interface IPActionSwapYT {
         address market,
         uint256 exactSyIn,
         uint256 minYtOut,
-        ApproxParams calldata guessYtOut
+        ApproxParams calldata guessYtOut,
+        LimitOrderData calldata limit
     ) external returns (uint256 netYtOut, uint256 netSyFee);
 
     function swapExactYtForSy(
         address receiver,
         address market,
         uint256 exactYtIn,
-        uint256 minSyOut
+        uint256 minSyOut,
+        LimitOrderData calldata limit
     ) external returns (uint256 netSyOut, uint256 netSyFee);
 
-    function swapSyForExactYt(
-        address receiver,
-        address market,
-        uint256 exactYtOut,
-        uint256 maxSyIn
-    ) external returns (uint256 netSyIn, uint256 netSyFee);
-
-    function swapYtForExactSy(
-        address receiver,
-        address market,
-        uint256 exactSyOut,
-        uint256 maxYtIn,
-        ApproxParams calldata guessYtIn
-    ) external returns (uint256 netYtIn, uint256 netSyFee);
-
     function swapExactTokenForYt(
         address receiver,
         address market,
         uint256 minYtOut,
         ApproxParams calldata guessYtOut,
-        TokenInput calldata input
+        TokenInput calldata input,
+        LimitOrderData calldata limit
     ) external payable returns (uint256 netYtOut, uint256 netSyFee);
 
     function swapExactYtForToken(
         address receiver,
         address market,
-        uint256 netYtIn,
-        TokenOutput calldata output
+        uint256 exactYtIn,
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
     ) external returns (uint256 netTokenOut, uint256 netSyFee);
 
     function swapExactPtForYt(

package/contracts/interfaces/IPAllAction.sol

@@ -5,7 +5,6 @@ pragma solidity ^0.8.0;
 import "./IPActionAddRemoveLiq.sol";
 import "./IPActionSwapPT.sol";
 import "./IPActionSwapYT.sol";
-import "./IPActionMintRedeem.sol";
 import "./IPActionMisc.sol";
 import "./IPMarketSwapCallback.sol";
 import "./IDiamondLoupe.sol";
@@ -14,7 +13,6 @@ interface IPAllAction is
     IPActionAddRemoveLiq,
     IPActionSwapPT,
     IPActionSwapYT,
-    IPActionMintRedeem,
     IPActionMisc,
     IPMarketSwapCallback,
     IDiamondLoupe

package/contracts/interfaces/IPAllActionType.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import "../router/swap-aggregator/IPSwapAggregator.sol";
+import "./IPLimitRouter.sol";
+
+struct TokenInput {
+    // Token/Sy data
+    address tokenIn;
+    uint256 netTokenIn;
+    address tokenMintSy;
+    // aggregator data
+    address pendleSwap;
+    SwapData swapData;
+}
+
+struct TokenOutput {
+    // Token/Sy data
+    address tokenOut;
+    uint256 minTokenOut;
+    address tokenRedeemSy;
+    // aggregator data
+    address pendleSwap;
+    SwapData swapData;
+}
+
+struct LimitOrderData {
+    address limitRouter;
+    uint256 epsSkipMarket; // only used for swap operations, will be ignored otherwise
+    FillOrderParams[] normalFills;
+    FillOrderParams[] flashFills;
+}

package/contracts/interfaces/IPLimitRouter.sol

@@ -0,0 +1,162 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../core/StandardizedYield/PYIndex.sol";
+
+interface IPOrderMixinType {
+    enum OrderType {
+        SY_FOR_PT,
+        PT_FOR_SY,
+        SY_FOR_YT,
+        YT_FOR_SY
+    }
+
+    // Fixed-size order part with core information
+    struct StaticOrder {
+        uint256 salt;
+        uint256 expiry;
+        uint256 nonce;
+        OrderType orderType;
+        address token;
+        address YT;
+        address maker;
+        address receiver;
+        uint256 makingAmount;
+        uint256 lnImpliedRate;
+    }
+
+    struct NormalResults {
+        uint256 totalMaking;
+        uint256 totalTaking;
+        uint256 totalFee;
+        uint256[] netMakings;
+        uint256[] netTakings;
+        uint256[] netFees;
+    }
+
+    struct OnchainParams {
+        uint256 timeToExpiry;
+        uint256 pyIndex;
+        address feeRecipient;
+        uint256 lnFeeRateRoot;
+    }
+}
+
+struct Order {
+    uint256 salt;
+    uint256 expiry;
+    uint256 nonce;
+    IPOrderMixinType.OrderType orderType;
+    address token;
+    address YT;
+    address maker;
+    address receiver;
+    uint256 makingAmount;
+    uint256 lnImpliedRate;
+    bytes permit; // On first fill: permit.1.call(abi.encodePacked(permit.selector, permit.2))
+}
+
+struct FillOrderParams {
+    Order order;
+    bytes signature;
+    uint256 makingAmount;
+}
+
+interface IPOrderMixin is IPOrderMixinType {
+    event OrderCanceled(address indexed maker, bytes32 indexed orderHash, uint256 remaining);
+
+    event OrderRemainingUpdated(bytes32 indexed orderHash, uint256 remaining);
+
+    event NormalFill(
+        OrderType indexed orderType,
+        address indexed YT,
+        address indexed taker,
+        uint256 actualMaking,
+        uint256 actualTaking,
+        uint256 totalFee,
+        uint256 rawTotalMaking,
+        uint256 rawTotalTaking
+    );
+
+    event FlashFill(
+        OrderType indexed orderType,
+        address indexed YT,
+        address indexed taker,
+        uint256 netOutputToTaker,
+        uint256 netInputFromTaker,
+        uint256 totalFee,
+        uint256 rawTotalMaking,
+        uint256 rawTotalTaking
+    );
+
+    /**
+     * (making, taking)
+     * SY_FOR_PT: (SY, PT)
+     * PT_FOR_SY: (PT, SY)
+     * SY_FOR_YT: (SY, YT)
+     * YT_FOR_SY: (YT, SY)
+     */
+    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)
+     */
+    function flashFill(FillOrderParams[] memory params, address receiver, uint256 maxInput, bytes calldata callback)
+        external
+        returns (uint256 netOutputToTaker, uint256 netInputFromTaker, uint256 totalFee);
+
+    function feeRecipient() external view returns (address);
+
+    function lnFeeRateRoot() external view returns (uint96);
+
+    function hashOrder(Order memory order) external view returns (bytes32);
+
+    function getOnchainParams(address YT) external returns (OnchainParams memory);
+}
+
+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 {
+    struct MultiApproval {
+        address[] tokens;
+        address spender;
+    }
+
+    function cancelSingle(Order calldata order) external;
+
+    function cancelBatch(Order[] calldata orders) external;
+
+    function approveInf(MultiApproval[] calldata arr) external;
+
+    function remaining(bytes32 orderHash) external view returns (uint256);
+
+    function remainingRaw(bytes32 orderHash) external view returns (uint256);
+
+    function remainingsRaw(bytes32[] memory orderHashes) external view returns (uint256[] memory);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+}

package/contracts/interfaces/IPMarketFactory.sol

@@ -29,4 +29,6 @@ interface IPMarketFactory {
     function getMarketConfig(
         address router
     ) external view returns (address treasury, uint80 lnFeeRateRoot, uint8 reserveFeePercent);
+
+
 }

package/contracts/interfaces/IPRouterHelper.sol

@@ -2,13 +2,13 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../router/base/ActionBaseMintRedeem.sol";
+import "../interfaces/IPAllActionType.sol";
 
 interface IPRouterHelper {
     /**
      * @param output This output struct should be filled the same way as the normal removeLiquiditySingleToken
-     operation (This means all BulkSeller, PendleSwap still works the same way). Note that the
-     output.tokenOut will also be used as the input token for the addLiquidity
+     *  operation (This means PendleSwap still works the same way). Note that the
+     *  output.tokenOut will also be used as the input token for the addLiquidity
      */
     struct RemoveLiquiditySingleTokenStruct {
         address market;
@@ -19,10 +19,10 @@ interface IPRouterHelper {
 
     /**
      * @param guessNetTokenIn the predicted amount of tokenIn that will be used to add liquidity. This
-     should be the same amount that was used to generate guessPtReceivedFromSy (if any).
+     *  should be the same amount that was used to generate guessPtReceivedFromSy (if any).
      * @param guessPtReceivedFromSy the same guess struct in the normal addLiquiditySingleToken operation.
-     Again, note that this struct, if not empty (i.e. if guessOffchain == 0), should be generated
-     using `guessNetTokenIn` amount of tokenIn
+     *  Again, note that this struct, if not empty (i.e. if guessOffchain == 0), should be generated
+     *  using `guessNetTokenIn` amount of tokenIn
      * @dev tokenIn is the output.tokenOut of the removeLiquiditySingleTokenStruct
      */
     struct AddLiquiditySingleTokenStruct {
@@ -30,7 +30,6 @@ interface IPRouterHelper {
         uint256 minLpOut;
         uint256 guessNetTokenIn;
         ApproxParams guessPtReceivedFromSy;
-        address bulk;
     }
 
     /**
@@ -40,7 +39,6 @@ interface IPRouterHelper {
         address market;
         uint256 minLpOut;
         uint256 minYtOut;
-        address bulk;
     }
 
     struct RemoveLiquiditySingleSyStruct {
@@ -92,11 +90,7 @@ interface IPRouterHelper {
     );
 
     event AddLiquiditySingleSy(
-        address indexed caller,
-        address indexed market,
-        address indexed receiver,
-        uint256 netSyIn,
-        uint256 netLpOut
+        address indexed caller, address indexed market, address indexed receiver, uint256 netSyIn, uint256 netLpOut
     );
 
     event AddLiquiditySingleTokenKeepYt(
@@ -121,50 +115,22 @@ interface IPRouterHelper {
     function transferLiquidityDifferentSyNormal(
         RemoveLiquiditySingleTokenStruct calldata fromMarket,
         AddLiquiditySingleTokenStruct calldata toMarket
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netTokenZapIn,
-            uint256 netSyFeeOfRemove,
-            uint256 netSyFeeOfAdd
-        );
+    ) external returns (uint256 netLpOut, uint256 netTokenZapIn, uint256 netSyFeeOfRemove, uint256 netSyFeeOfAdd);
 
     function transferLiquidityDifferentSyKeepYt(
         RemoveLiquiditySingleTokenStruct calldata fromMarket,
         AddLiquiditySingleTokenKeepYtStruct calldata toMarket
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netYtOut,
-            uint256 netTokenZapIn,
-            uint256 netSyFeeOfRemove
-        );
+    ) external returns (uint256 netLpOut, uint256 netYtOut, uint256 netTokenZapIn, uint256 netSyFeeOfRemove);
 
     function transferLiquiditySameSyNormal(
         RemoveLiquiditySingleSyStruct calldata fromMarket,
         AddLiquiditySingleSyStruct calldata toMarket
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netSyZapIn,
-            uint256 netSyFeeOfRemove,
-            uint256 netSyFeeOfAdd
-        );
+    ) external returns (uint256 netLpOut, uint256 netSyZapIn, uint256 netSyFeeOfRemove, uint256 netSyFeeOfAdd);
 
     function transferLiquiditySameSyKeepYt(
         RemoveLiquiditySingleSyStruct calldata fromMarket,
         AddLiquiditySingleSyKeepYtStruct calldata toMarket
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netYtOut,
-            uint256 netSyZapIn,
-            uint256 netSyFeeOfRemove
-        );
+    ) external returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyZapIn, uint256 netSyFeeOfRemove);
 
     function removeLiquiditySingleToken(RemoveLiquiditySingleTokenStruct calldata fromMarket)
         external

package/contracts/limit/LimitMathCore.sol

@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "../interfaces/IPLimitRouter.sol";
+import "../core/Market/MarketMathCore.sol";
+import "../interfaces/IPMarketFactory.sol";
+
+library LimitMathCore {
+    using PYIndexLib for PYIndex;
+    using PYIndexLib for IPYieldToken;
+    using PMath for uint256;
+    using PMath for int256;
+
+    function calcNormalBatch(FillOrderParams[] memory params, IPOrderMixinType.OnchainParams memory on)
+        internal
+        pure
+        returns (IPOrderMixinType.NormalResults memory out)
+    {
+        uint256 len = params.length;
+        out.netMakings = new uint256[](len);
+        out.netTakings = new uint256[](len);
+        out.netFees = new uint256[](len);
+
+        (function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256) calcNormal,) =
+            getCalcFunctions(params[0].order.orderType);
+
+        uint256 feeRate = impliedRateToExchangeRate(on.lnFeeRateRoot, on.timeToExpiry);
+
+        for (uint256 i = 0; i < len; i = inc1(i)) {
+            FillOrderParams memory param = params[i];
+            if (param.makingAmount == 0) continue; // nothing changes
+
+            uint256 exchangeRate = impliedRateToExchangeRate(param.order.lnImpliedRate, on.timeToExpiry);
+
+            out.netMakings[i] = param.makingAmount;
+            (out.netTakings[i], out.netFees[i]) =
+                calcNormal(out.netMakings[i], exchangeRate, PYIndex.wrap(on.pyIndex), feeRate);
+
+            require(out.netTakings[i] > 0, "LOP: can't swap 0 amount");
+
+            out.totalMaking += out.netMakings[i];
+            out.totalTaking += out.netTakings[i];
+            out.totalFee += out.netFees[i];
+        }
+    }
+
+    function calcFlashBatch(FillOrderParams[] memory params, IPOrderMixinType.OnchainParams memory onchain)
+        internal
+        pure
+        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);
+
+        out = calcNormalBatch(params, onchain);
+        (netInputFromTaker, netOutputToTaker) =
+            calcFlash(out.totalMaking, out.totalTaking, out.totalFee, PYIndex.wrap(onchain.pyIndex));
+        netFee = out.totalFee;
+    }
+
+    function calcSyForPtNormal(uint256 makeSy, uint256 r, PYIndex index, uint256 f)
+        internal
+        pure
+        returns (uint256 takePt, uint256 fee)
+    {
+        // takePt = makeSy * index * r
+        // fee = makeSy * (f - 1)
+
+        takePt = index.syToAsset(makeSy).mulDown(r);
+        fee = makeSy.mulDown(f - PMath.ONE);
+    }
+
+    function calcPtForSyNormal(uint256 makePt, uint256 r, PYIndex index, uint256 f)
+        internal
+        pure
+        returns (uint256 takeSy, uint256 fee)
+    {
+        // takeAsset = make / r
+        // takeSy = takeAsset / index
+        // fee = takeSy * (f-1)/f
+
+        takeSy = index.assetToSyUp(makePt.divDown(r));
+        fee = takeSy * (f - PMath.ONE) / f;
+    }
+
+    function calcSyForYtNormal(uint256 makeSy, uint256 r, PYIndex index, uint256 f)
+        internal
+        pure
+        returns (uint256 takeYt, uint256 fee)
+    {
+        // pt = makeSy * index * r
+        // yt = pt / (r-1)
+        // fee = makeSy * ((f-1) / f) / (r-1)
+
+        takeYt = index.syToAssetUp(makeSy) * r / (r - PMath.ONE);
+        fee = (makeSy * (f - PMath.ONE) / f).divDown(r - PMath.ONE);
+    }
+
+    function calcYtForSyNormal(uint256 makeYt, uint256 r, PYIndex index, uint256 f)
+        internal
+        pure
+        returns (uint256 takeSy, uint256 fee)
+    {
+        // pt = yt * (r-1)
+        // takeSy = pt / r / index
+        // feeSy = takeSy * (f-1) / (r-1)
+
+        takeSy = index.assetToSyUp(makeYt * (r - PMath.ONE) / r);
+        fee = takeSy * (f - PMath.ONE) / (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;
+    }
+
+    function impliedRateToExchangeRate(uint256 lnRate, uint256 timeToExpiry) internal pure returns (uint256) {
+        return MarketMathCore._getExchangeRateFromImpliedRate(lnRate, timeToExpiry).Uint();
+    }
+
+    function inc1(uint256 i) internal pure returns (uint256) {
+        unchecked {
+            return i + 1;
+        }
+    }
+
+    /// @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) calcNormal,
+            function (uint256, uint256, uint256, PYIndex) internal pure returns (uint256, uint256) calcFlash
+        )
+    {
+        if (t == IPOrderMixinType.OrderType.SY_FOR_PT) {
+            return (calcSyForPtNormal, calcSyForPtFlash);
+        } else if (t == IPOrderMixinType.OrderType.PT_FOR_SY) {
+            return (calcPtForSyNormal, calcPtForSyFlash);
+        } else if (t == IPOrderMixinType.OrderType.SY_FOR_YT) {
+            return (calcSyForYtNormal, calcSyForYtFlash);
+        } else {
+            return (calcYtForSyNormal, calcYtForSyFlash);
+        }
+    }
+}
+
+/*
+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

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.21;
+
+import "./PendleOrderMixin.sol";
+import "./helpers/NonceManager.sol";
+import "../core/libraries/TokenHelper.sol";
+import "../interfaces/IAddressProvider.sol";
+
+contract PendleLimitRouter is PendleOrderMixin, IPLimitRouter {
+    using ArgumentsDecoder for bytes;
+    using Address for address;
+
+    constructor(address _WNATIVE) initializer PendleOrderMixin(_WNATIVE) {}
+
+    /// @notice Cancels multiple orders by setting remaining amount to zero
+    function cancelBatch(Order[] calldata orders) external {
+        for (uint256 i = 0; i < orders.length; ++i) {
+            cancelSingle(orders[i]);
+        }
+    }
+
+    function approveInf(MultiApproval[] calldata arr) external {
+        for (uint256 i = 0; i < arr.length;) {
+            MultiApproval calldata ele = arr[i];
+            for (uint256 j = 0; j < ele.tokens.length;) {
+                _safeApproveInf(ele.tokens[j], ele.spender);
+                unchecked {
+                    j++;
+                }
+            }
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    /// @notice Cancels order by setting remaining amount to zero
+    function cancelSingle(Order calldata order) public {
+        require(order.maker == msg.sender, "LOP: Access denied");
+
+        bytes32 orderHash = hashOrder(order);
+        uint256 orderRemaining = _remaining[orderHash];
+        require(orderRemaining != _ORDER_FILLED, "LOP: already filled");
+        emit OrderCanceled(msg.sender, orderHash, orderRemaining);
+        _remaining[orderHash] = _ORDER_FILLED;
+    }
+
+    function remaining(bytes32 orderHash) external view returns (uint256) {
+        uint256 amount = _remaining[orderHash];
+        require(amount != _ORDER_DOES_NOT_EXIST, "LOP: Unknown order");
+        unchecked {
+            amount -= 1;
+        }
+        return amount;
+    }
+
+    function remainingRaw(bytes32 orderHash) external view returns (uint256) {
+        return _remaining[orderHash];
+    }
+
+    function remainingsRaw(bytes32[] memory orderHashes) external view returns (uint256[] memory) {
+        uint256[] memory results = new uint256[](orderHashes.length);
+        for (uint256 i = 0; i < orderHashes.length; i++) {
+            results[i] = _remaining[orderHashes[i]];
+        }
+        return results;
+    }
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32) {
+        return _domainSeparatorV4();
+    }
+}