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

package/contracts/interfaces/{IPActionSwapPT.sol → IPActionSwapPTV3.sol}

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "./IPAllActionType.sol";
+import "./IPAllActionTypeV3.sol";
 
-interface IPActionSwapPT {
+interface IPActionSwapPTV3 {
     event SwapPtAndSy(
         address indexed caller,
         address indexed market,
@@ -19,16 +19,18 @@ interface IPActionSwapPT {
         address indexed token,
         address receiver,
         int256 netPtToAccount,
-        int256 netTokenToAccount
+        int256 netTokenToAccount,
+        uint256 netSyInterm
     );
 
-    function swapExactPtForSy(
+    function swapExactTokenForPt(
         address receiver,
         address market,
-        uint256 exactPtIn,
-        uint256 minSyOut,
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut,
+        TokenInput calldata input,
         LimitOrderData calldata limit
-    ) external returns (uint256 netSyOut, uint256 netSyFee);
+    ) external payable returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm);
 
     function swapExactSyForPt(
         address receiver,
@@ -39,20 +41,19 @@ interface IPActionSwapPT {
         LimitOrderData calldata limit
     ) external returns (uint256 netPtOut, uint256 netSyFee);
 
-    function swapExactTokenForPt(
+    function swapExactPtForToken(
         address receiver,
         address market,
-        uint256 minPtOut,
-        ApproxParams calldata guessPtOut,
-        TokenInput calldata input,
+        uint256 exactPtIn,
+        TokenOutput calldata output,
         LimitOrderData calldata limit
-    ) external payable returns (uint256 netPtOut, uint256 netSyFee);
+    ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm);
 
-    function swapExactPtForToken(
+    function swapExactPtForSy(
         address receiver,
         address market,
         uint256 exactPtIn,
-        TokenOutput calldata output,
+        uint256 minSyOut,
         LimitOrderData calldata limit
-    ) external returns (uint256 netTokenOut, uint256 netSyFee);
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
 }

package/contracts/interfaces/{IPActionSwapYT.sol → IPActionSwapYTV3.sol}

@@ -2,9 +2,9 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "./IPAllActionType.sol";
+import "./IPAllActionTypeV3.sol";
 
-interface IPActionSwapYT {
+interface IPActionSwapYTV3 {
     event SwapYtAndSy(
         address indexed caller,
         address indexed market,
@@ -19,7 +19,8 @@ interface IPActionSwapYT {
         address indexed token,
         address receiver,
         int256 netYtToAccount,
-        int256 netTokenToAccount
+        int256 netTokenToAccount,
+        uint256 netSyInterm
     );
 
     event SwapPtAndYt(
@@ -30,31 +31,23 @@ interface IPActionSwapYT {
         int256 netYtToAccount
     );
 
-    function swapExactSyForYt(
+    function swapExactTokenForYt(
         address receiver,
         address market,
-        uint256 exactSyIn,
         uint256 minYtOut,
         ApproxParams calldata guessYtOut,
+        TokenInput calldata input,
         LimitOrderData calldata limit
-    ) external returns (uint256 netYtOut, uint256 netSyFee);
-
-    function swapExactYtForSy(
-        address receiver,
-        address market,
-        uint256 exactYtIn,
-        uint256 minSyOut,
-        LimitOrderData calldata limit
-    ) external returns (uint256 netSyOut, uint256 netSyFee);
+    ) external payable returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm);
 
-    function swapExactTokenForYt(
+    function swapExactSyForYt(
         address receiver,
         address market,
+        uint256 exactSyIn,
         uint256 minYtOut,
         ApproxParams calldata guessYtOut,
-        TokenInput calldata input,
         LimitOrderData calldata limit
-    ) external payable returns (uint256 netYtOut, uint256 netSyFee);
+    ) external returns (uint256 netYtOut, uint256 netSyFee);
 
     function swapExactYtForToken(
         address receiver,
@@ -62,7 +55,15 @@ interface IPActionSwapYT {
         uint256 exactYtIn,
         TokenOutput calldata output,
         LimitOrderData calldata limit
-    ) external returns (uint256 netTokenOut, uint256 netSyFee);
+    ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm);
+
+    function swapExactYtForSy(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
 
     function swapExactPtForYt(
         address receiver,
@@ -77,6 +78,6 @@ interface IPActionSwapYT {
         address market,
         uint256 exactYtIn,
         uint256 minPtOut,
-        ApproxParams calldata guessTotalPtSwapped
+        ApproxParams calldata guessTotalPtFromSwap
     ) external returns (uint256 netPtOut, uint256 netSyFee);
 }

package/contracts/interfaces/IPAllActionV3.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity ^0.8.0;
+
+import "./IPActionAddRemoveLiqV3.sol";
+import "./IPActionSwapPTV3.sol";
+import "./IPActionSwapYTV3.sol";
+import "./IPActionMiscV3.sol";
+import "./IPMarketSwapCallback.sol";
+import "./IDiamondLoupe.sol";
+
+interface IPAllActionV3 is
+    IPActionAddRemoveLiqV3,
+    IPActionSwapPTV3,
+    IPActionSwapYTV3,
+    IPActionMiscV3,
+    IPMarketSwapCallback,
+    IDiamondLoupe
+{}

package/contracts/interfaces/IPLimitRouter.sol

@@ -23,22 +23,18 @@ interface IPOrderMixinType {
         address receiver;
         uint256 makingAmount;
         uint256 lnImpliedRate;
+        uint256 failSafeRate;
     }
 
     struct NormalResults {
         uint256 totalMaking;
         uint256 totalTaking;
         uint256 totalFee;
+        uint256 totalNotionalVolume;
         uint256[] netMakings;
         uint256[] netTakings;
         uint256[] netFees;
-    }
-
-    struct OnchainParams {
-        uint256 timeToExpiry;
-        uint256 pyIndex;
-        address feeRecipient;
-        uint256 lnFeeRateRoot;
+        uint256[] notionalVolumes;
     }
 }
 
@@ -53,6 +49,7 @@ struct Order {
     address receiver;
     uint256 makingAmount;
     uint256 lnImpliedRate;
+    uint256 failSafeRate;
     bytes permit; // On first fill: permit.1.call(abi.encodePacked(permit.selector, permit.2))
 }
 
@@ -63,30 +60,22 @@ struct FillOrderParams {
 }
 
 interface IPOrderMixin is IPOrderMixinType {
-    event OrderCanceled(address indexed maker, bytes32 indexed orderHash, uint256 remaining);
+    struct OrderStatus {
+        uint128 filledAmount;
+        uint128 remaining;
+    }
 
-    event OrderRemainingUpdated(bytes32 indexed orderHash, uint256 remaining);
+    event OrderCanceled(address indexed maker, bytes32 indexed orderHash);
 
-    event NormalFill(
+    event OrderFilled(
+        bytes32 indexed orderHash,
         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
+        address token,
+        uint256 netInputFromMaker,
+        uint256 netOutputToMaker,
+        uint256 feeAmount,
+        uint256 notionalVolume
     );
 
     /**
@@ -96,6 +85,7 @@ interface IPOrderMixin is IPOrderMixinType {
      * 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);
@@ -107,6 +97,8 @@ interface IPOrderMixin is IPOrderMixinType {
      * 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);
@@ -116,8 +108,6 @@ interface IPOrderMixin is IPOrderMixinType {
     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 {
@@ -141,22 +131,19 @@ interface ILimitOrderCallee is IPOrderMixinType {
 }
 
 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 orderStatusesRaw(bytes32[] memory orderHashes)
+        external
+        view
+        returns (uint256[] memory remainingsRaw, uint256[] memory filledAmounts);
 
-    function remainingsRaw(bytes32[] memory orderHashes) external view returns (uint256[] memory);
+    function orderStatuses(bytes32[] memory orderHashes)
+        external
+        view
+        returns (uint256[] memory remainings, uint256[] memory filledAmounts);
 
     function DOMAIN_SEPARATOR() external view returns (bytes32);
 }

package/contracts/interfaces/IPRouterHelper.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.0;
 
 import "../router/base/MarketApproxLib.sol";
-import "../interfaces/IPAllActionType.sol";
+import "../interfaces/IPAllActionTypeV3.sol";
 
 interface IPRouterHelper {
     /**

package/contracts/limit/LimitMathCore.sol

@@ -12,107 +12,130 @@ library LimitMathCore {
     using PMath for uint256;
     using PMath for int256;
 
-    function calcNormalBatch(FillOrderParams[] memory params, IPOrderMixinType.OnchainParams memory on)
+    function calcNormalBatch(FillOrderParams[] memory params, address YT, uint256 lnFeeRateRoot)
         internal
-        pure
         returns (IPOrderMixinType.NormalResults memory out)
     {
+        return calcNormalBatch(
+            params, IPYieldToken(YT).expiry() - block.timestamp, IPYieldToken(YT).pyIndexCurrent(), lnFeeRateRoot
+        );
+    }
+
+    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,
+        uint256 timeToExpiry,
+        uint256 pyIndex,
+        uint256 lnFeeRateRoot
+    ) 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);
+        out.notionalVolumes = new uint256[](len);
 
-        (function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256) calcNormal,) =
+        (function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calcNormal,) =
             getCalcFunctions(params[0].order.orderType);
 
-        uint256 feeRate = impliedRateToExchangeRate(on.lnFeeRateRoot, on.timeToExpiry);
+        uint256 feeRate = impliedRateToExchangeRate(lnFeeRateRoot, 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);
+            uint256 exchangeRate = impliedRateToExchangeRate(param.order.lnImpliedRate, timeToExpiry);
 
             out.netMakings[i] = param.makingAmount;
-            (out.netTakings[i], out.netFees[i]) =
-                calcNormal(out.netMakings[i], exchangeRate, PYIndex.wrap(on.pyIndex), feeRate);
+            (out.netTakings[i], out.netFees[i], out.notionalVolumes[i]) =
+                calcNormal(out.netMakings[i], exchangeRate, PYIndex.wrap(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];
+            out.totalNotionalVolume += out.notionalVolumes[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)
+        returns (uint256 takePt, uint256 fee, uint256 notionalVolume)
     {
         // takePt = makeSy * index * r
         // fee = makeSy * (f - 1)
+        // notionalVolume = makeSy
 
         takePt = index.syToAsset(makeSy).mulDown(r);
         fee = makeSy.mulDown(f - PMath.ONE);
+        notionalVolume = makeSy;
     }
 
     function calcPtForSyNormal(uint256 makePt, uint256 r, PYIndex index, uint256 f)
         internal
         pure
-        returns (uint256 takeSy, uint256 fee)
+        returns (uint256 takeSy, uint256 fee, uint256 notionalVolume)
     {
         // takeAsset = make / r
         // takeSy = takeAsset / index
         // fee = takeSy * (f-1)/f
+        // notionalVolume = takeSy
 
         takeSy = index.assetToSyUp(makePt.divDown(r));
         fee = takeSy * (f - PMath.ONE) / f;
+        notionalVolume = takeSy;
     }
 
     function calcSyForYtNormal(uint256 makeSy, uint256 r, PYIndex index, uint256 f)
         internal
         pure
-        returns (uint256 takeYt, uint256 fee)
+        returns (uint256 takeYt, uint256 fee, uint256 notionalVolume)
     {
         // pt = makeSy * index * r
         // yt = pt / (r-1)
         // fee = makeSy * ((f-1) / f) / (r-1)
+        // notionalVolume = makeSy / (r-1)
 
         takeYt = index.syToAssetUp(makeSy) * r / (r - PMath.ONE);
         fee = (makeSy * (f - PMath.ONE) / f).divDown(r - PMath.ONE);
+        notionalVolume = makeSy.divDown(r - PMath.ONE);
     }
 
     function calcYtForSyNormal(uint256 makeYt, uint256 r, PYIndex index, uint256 f)
         internal
         pure
-        returns (uint256 takeSy, uint256 fee)
+        returns (uint256 takeSy, uint256 fee, uint256 notionalVolume)
     {
         // pt = yt * (r-1)
         // takeSy = pt / r / index
         // feeSy = takeSy * (f-1) / (r-1)
+        // notionalVolume = takeSy / (r-1)
 
         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
@@ -175,7 +198,7 @@ library LimitMathCore {
         internal
         pure
         returns (
-            function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256) calcNormal,
+            function (uint256, uint256, PYIndex, uint256) internal pure returns (uint256, uint256, uint256) calcNormal,
             function (uint256, uint256, uint256, PYIndex) internal pure returns (uint256, uint256) calcFlash
         )
     {

package/contracts/limit/PendleLimitRouter.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.21;
+pragma solidity ^0.8.17;
 
 import "./PendleOrderMixin.sol";
 import "./helpers/NonceManager.sol";
@@ -10,7 +10,9 @@ contract PendleLimitRouter is PendleOrderMixin, IPLimitRouter {
     using ArgumentsDecoder for bytes;
     using Address for address;
 
-    constructor(address _WNATIVE) initializer PendleOrderMixin(_WNATIVE) {}
+    constructor(address _WNATIVE) PendleOrderMixin(_WNATIVE) {
+        _disableInitializers();
+    }
 
     /// @notice Cancels multiple orders by setting remaining amount to zero
     function cancelBatch(Order[] calldata orders) external {
@@ -19,51 +21,44 @@ contract PendleLimitRouter is PendleOrderMixin, IPLimitRouter {
         }
     }
 
-    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;
-    }
+        require(_status[orderHash].remaining != _ORDER_FILLED, "LOP: already filled");
+        _status[orderHash].remaining = _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;
+        emit OrderCanceled(msg.sender, orderHash);
     }
 
-    function remainingRaw(bytes32 orderHash) external view returns (uint256) {
-        return _remaining[orderHash];
+    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);
+
+        for (uint256 i = 0; i < len; i++) {
+            OrderStatus memory status = _status[orderHashes[i]];
+            (remainingsRaw[i], filledAmounts[i]) = (status.remaining, status.filledAmount);
+        }
     }
 
-    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]];
+    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");
+            unchecked {
+                remainings[i] -= 1;
+            }
         }
-        return results;
     }
 
     function DOMAIN_SEPARATOR() external view returns (bytes32) {