@pendle/core-v2 4.5.1-beta-1 → 4.5.1-beta-2

package/contracts/interfaces/IPActionMiscV3.sol

@@ -26,6 +26,26 @@ interface IPActionMiscV3 {
         bytes returnData;
     }
 
+    struct ExitPreExpReturnParams {
+        uint256 netPtFromRemove;
+        uint256 netSyFromRemove;
+        uint256 netPyRedeem;
+        uint256 netSyFromRedeem;
+        uint256 netPtSwap;
+        uint256 netYtSwap;
+        uint256 netSyFromSwap;
+        uint256 netSyFee;
+        uint256 totalSyOut;
+    }
+
+    struct ExitPostExpReturnParams {
+        uint256 netPtFromRemove;
+        uint256 netSyFromRemove;
+        uint256 netPtRedeem;
+        uint256 netSyFromRedeem;
+        uint256 totalSyOut;
+    }
+
     event MintSyFromToken(
         address indexed caller,
         address indexed tokenIn,
@@ -80,6 +100,42 @@ interface IPActionMiscV3 {
         uint256 netSyInterm
     );
 
+    event ExitPreExpToToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netLpToRemove,
+        uint256 totalTokenOut,
+        ExitPreExpReturnParams params
+    );
+
+    event ExitPreExpToSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpToRemove,
+        ExitPreExpReturnParams params
+    );
+
+    event ExitPostExpToToken(
+        address indexed caller,
+        address indexed market,
+        address indexed token,
+        address receiver,
+        uint256 netLpIn,
+        uint256 totalTokenOut,
+        ExitPostExpReturnParams params
+    );
+
+    event ExitPostExpToSy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 netLpIn,
+        ExitPostExpReturnParams params
+    );
+
     function mintSyFromToken(
         address receiver,
         address SY,
@@ -143,7 +199,7 @@ interface IPActionMiscV3 {
         uint256 minTokenOut
     ) external payable returns (uint256 netTokenOut, uint256 netSyInterm);
 
-    function exitMultiplePreExpiry(
+    function exitPreExpToToken(
         address receiver,
         address market,
         uint256 netPtIn,
@@ -151,35 +207,33 @@ interface IPActionMiscV3 {
         uint256 netLpIn,
         TokenOutput calldata output,
         LimitOrderData calldata limit
-    )
-        external
-        returns (
-            uint256 netTokenOut,
-            uint256 netPtFromRemove,
-            uint256 netSyFromRemove,
-            uint256 netPyRedeem,
-            uint256 netSyFromRedeem,
-            uint256 netPtSwap,
-            uint256 netYtSwap,
-            uint256 netSyFromSwap,
-            uint256 netSyFee
-        );
-
-    function exitMultiplePostExpiry(
+    ) external returns (uint256 netTokenOut, ExitPreExpReturnParams memory params);
+
+    function exitPreExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) external returns (ExitPreExpReturnParams memory params);
+
+    function exitPostExpToToken(
         address receiver,
         address market,
         uint256 netPtIn,
         uint256 netLpIn,
         TokenOutput calldata output
-    )
-        external
-        returns (
-            uint256 netTokenOut,
-            uint256 netPtFromRemove,
-            uint256 netSyFromRemove,
-            uint256 netPtRedeem,
-            uint256 netSyFromRedeem
-        );
+    ) external returns (uint256 netTokenOut, ExitPostExpReturnParams memory params);
+
+    function exitPostExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn,
+        uint256 minSyOut
+    ) external returns (ExitPostExpReturnParams memory params);
 
     function boostMarkets(address[] memory markets) external;
 

package/contracts/router/ActionMiscV3.sol

@@ -116,206 +116,140 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         netTokenOut = IStandardizedYield(SY).redeem(receiver, netSyInterm, tokenRedeemSy, minTokenOut, true);
     }
 
-    event ExitMultiplePreExpiry(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
-        address receiver,
-        uint256 netLpToRemove,
-        uint256 netPtFromRemove,
-        uint256 netSyFromRemove,
-        uint256 netPyRedeem,
-        uint256 netSyFromRedeem,
-        uint256 netPtSwap,
-        uint256 netYtSwap,
-        uint256 netSyFromSwap,
-        uint256 netSyFee,
-        uint256 netTokenOut
-    );
-
-    event ExitMultiplePostExpiry(
-        address indexed caller,
-        address indexed market,
-        address indexed token,
+    // TODO: need to allow exit to SY as well
+    // TODO: check against minOut
+    // double check event orders
+
+    function exitPreExpToToken(
         address receiver,
-        uint256 netLpToRemove,
-        uint256 netPtFromRemove, //
-        uint256 netSyFromRemove, //
-        uint256 netPtRedeem,
-        uint256 netSyFromRedeem, //
-        uint256 netTokenOut //
-    );
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
+    ) external returns (uint256 totalTokenOut, ExitPreExpReturnParams memory params) {
+        IStandardizedYield SY;
 
-    // TODO: need to allow exit to SY as well
+        (SY, params) = _exitPreExpToSy(true, address(0), market, netPtIn, netYtIn, netLpIn, limit);
+        totalTokenOut = _redeemSyToToken(receiver, address(SY), params.totalSyOut, output, false);
 
-    struct ExitMultipleParams {
-        address receiver;
-        address market;
-        uint256 netPtIn;
-        uint256 netYtIn;
-        uint256 netLpIn;
-        TokenOutput output;
-        LimitOrderData limit;
+        emit ExitPreExpToToken(msg.sender, market, output.tokenOut, receiver, netLpIn, totalTokenOut, params);
     }
 
-    function exitMultiplePreExpiry(
+    function exitPreExpToSy(
         address receiver,
         address market,
         uint256 netPtIn,
         uint256 netYtIn,
         uint256 netLpIn,
-        TokenOutput calldata output,
+        uint256 minSyOut,
         LimitOrderData calldata limit
-    )
-        external
-        returns (
-            uint256 netTokenOut,
-            uint256 netPtFromRemove,
-            uint256 netSyFromRemove,
-            uint256 netPyRedeem,
-            uint256 netSyFromRedeem,
-            uint256 netPtSwap,
-            uint256 netYtSwap,
-            uint256 netSyFromSwap,
-            uint256 netSyFee
-        )
-    {
-        (
-            netTokenOut,
-            netPtFromRemove,
-            netSyFromRemove,
-            netPyRedeem,
-            netSyFromRedeem,
-            netPtSwap,
-            netYtSwap,
-            netSyFromSwap,
-            netSyFee
-        ) = exitMultiplePreExpiryInner(receiver, market, netPtIn, netYtIn, netLpIn, output, limit);
-
-        emit ExitMultiplePreExpiry(
-            msg.sender,
-            market,
-            output.tokenOut,
-            receiver,
-            netLpIn,
-            netPtFromRemove,
-            netSyFromRemove,
-            netPyRedeem,
-            netSyFromRedeem,
-            netPtSwap,
-            netYtSwap,
-            netSyFromSwap,
-            netSyFee,
-            netTokenOut
-        );
+    ) external returns (ExitPreExpReturnParams memory params) {
+        (, params) = _exitPreExpToSy(false, receiver, market, netPtIn, netYtIn, netLpIn, limit);
+        require(params.totalSyOut >= minSyOut, "Slippage: INSUFFICIENT_SY_OUT");
+
+        emit ExitPreExpToSy(msg.sender, market, receiver, netLpIn, params);
     }
 
-    function exitMultiplePreExpiryInner(
+    function _exitPreExpToSy(
+        bool setReceiverToSy,
         address receiver,
         address market,
         uint256 netPtIn,
         uint256 netYtIn,
         uint256 netLpIn,
-        TokenOutput calldata output,
         LimitOrderData calldata limit
-    )
-        internal
-        returns (
-            uint256 netTokenOut,
-            uint256 netPtFromRemove,
-            uint256 netSyFromRemove,
-            uint256 netPyRedeem,
-            uint256 netSyFromRedeem,
-            uint256 netPtSwap,
-            uint256 netYtSwap,
-            uint256 netSyFromSwap,
-            uint256 netSyFee
-        )
-    {
-        // (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
-        // if (netLpIn > 0) {
-        //     _transferFrom(IERC20(market), msg.sender, market, netLpIn);
-        //     (netSyFromRemove, netPtFromRemove) = IPMarket(market).burn(address(SY), address(this), netLpIn);
-        // }
-        // if (netPtIn > 0) {
-        //     _transferIn(address(PT), address(this), netPtIn);
-        // }
-        // netPyRedeem = PMath.min(netPtFromRemove + netPtIn, netYtIn);
-        // if (netPyRedeem > 0) {
-        //     _transferOut(address(PT), address(YT), netPyRedeem);
-        //     _transferFrom(YT, msg.sender, address(YT), netPyRedeem);
-        //     netSyFromRedeem = IPYieldToken(YT).redeemPY(address(SY));
-        // }
-        // netPtSwap = netPtFromRemove + netPtIn - netPyRedeem;
-        // netYtSwap = netYtIn - netPyRedeem;
-        // if (netPtSwap > 0) {
-        //     address ptEntry = _entry_swapExactPtForSy(market, limit);
-        //     if (ptEntry != address(this)) _transferOut(address(PT), ptEntry, netPtSwap);
-        //     (netSyFromSwap, netSyFee) = _swapExactPtForSy(address(SY), market, netPtSwap, 0, limit);
-        // } else if (netYtSwap > 0) {
-        //     _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), netYtSwap);
-        //     (netSyFromSwap, netSyFee) = _swapExactYtForSy(address(SY), market, SY, YT, netYtSwap, 0, limit);
-        // }
-        // uint256 netSyRedeem = netSyFromRemove + netSyFromRedeem + netSyFromSwap;
-        // netTokenOut = _redeemSyToToken(receiver, address(SY), netSyRedeem, output, false);
+    ) internal returns (IStandardizedYield SY, ExitPreExpReturnParams memory p) {
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+        (SY, PT, YT) = IPMarket(market).readTokens();
+
+        if (setReceiverToSy) receiver = address(SY);
+
+        if (netLpIn > 0) {
+            _transferFrom(IERC20(market), msg.sender, market, netLpIn);
+            (p.netSyFromRemove, p.netPtFromRemove) = IPMarket(market).burn(receiver, address(this), netLpIn);
+        }
+
+        if (netPtIn > 0) {
+            _transferIn(address(PT), address(this), netPtIn);
+        }
+
+        p.netPyRedeem = PMath.min(p.netPtFromRemove + netPtIn, netYtIn);
+
+        if (p.netPyRedeem > 0) {
+            _transferOut(address(PT), address(YT), p.netPyRedeem);
+            _transferFrom(YT, msg.sender, address(YT), p.netPyRedeem);
+            p.netSyFromRedeem = IPYieldToken(YT).redeemPY(receiver);
+        }
+
+        p.netPtSwap = p.netPtFromRemove + netPtIn - p.netPyRedeem;
+        p.netYtSwap = netYtIn - p.netPyRedeem;
+
+        if (p.netPtSwap > 0) {
+            address ptEntry = _entry_swapExactPtForSy(market, limit);
+            if (ptEntry != address(this)) _transferOut(address(PT), ptEntry, p.netPtSwap);
+            (p.netSyFromSwap, p.netSyFee) = _swapExactPtForSy(receiver, market, p.netPtSwap, 0, limit);
+        } else if (p.netYtSwap > 0) {
+            _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), p.netYtSwap);
+            (p.netSyFromSwap, p.netSyFee) = _swapExactYtForSy(receiver, market, SY, YT, p.netYtSwap, 0, limit);
+        }
+
+        p.totalSyOut = p.netSyFromRemove + p.netSyFromRedeem + p.netSyFromSwap;
     }
 
-    // TODO: is netSyInterm necessary? can we return more?
-    // TODO: compare interface against existing functions, to see if it makes sense
-    function exitMultiplePostExpiry(
+    function exitPostExpToToken(
         address receiver,
         address market,
         uint256 netPtIn,
         uint256 netLpIn,
         TokenOutput calldata output
-    )
-        external
-        returns (
-            uint256 netTokenOut,
-            uint256 netPtFromRemove,
-            uint256 netSyFromRemove,
-            uint256 netPtRedeem,
-            uint256 netSyFromRedeem
-        )
-    {
-        // * (done) maybe shouldn't reuse functions because of conflicting events
-        // * (KIV) expose all inner workings variables
-        // also: should match events with existing events
-        // events, no matter what is emitted, can be parsed dynamically on BE. Say if only PT is exited, it can be parsed
-        // as swapExact
-
-        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
-
-        // uint256 netPtFromRemove;
-        // uint256 netSyFromRemove;
+    ) external returns (uint256 totalTokenOut, ExitPostExpReturnParams memory params) {
+        IStandardizedYield SY;
+
+        (SY, params) = _exitPostExpToSy(receiver, market, netPtIn, netLpIn);
+        totalTokenOut = _redeemSyToToken(receiver, address(SY), params.totalSyOut, output, false);
+
+        emit ExitPostExpToToken(msg.sender, market, output.tokenOut, receiver, netLpIn, totalTokenOut, params);
+    }
+
+    function exitPostExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn,
+        uint256 minSyOut
+    ) external returns (ExitPostExpReturnParams memory params) {
+        (, params) = _exitPostExpToSy(receiver, market, netPtIn, netLpIn);
+        require(params.totalSyOut >= minSyOut, "Slippage: INSUFFICIENT_SY_OUT");
+
+        emit ExitPostExpToSy(msg.sender, market, receiver, netLpIn, params);
+    }
+
+    function _exitPostExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn
+    ) internal returns (IStandardizedYield SY, ExitPostExpReturnParams memory p) {
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+        (SY, PT, YT) = IPMarket(market).readTokens();
 
         if (netLpIn > 0) {
             _transferFrom(IERC20(market), msg.sender, market, netLpIn);
-            (netSyFromRemove, netPtFromRemove) = IPMarket(market).burn(address(SY), address(YT), netLpIn);
+            (p.netSyFromRemove, p.netPtFromRemove) = IPMarket(market).burn(receiver, address(YT), netLpIn);
         }
 
         if (netPtIn > 0) {
             _transferFrom(PT, msg.sender, address(YT), netPtIn);
         }
 
-        netPtRedeem = netPtFromRemove + netPtIn;
-        netSyFromRedeem = IPYieldToken(YT).redeemPY(address(SY));
-
-        uint256 netSyRedeem = netSyFromRemove + netSyFromRedeem;
-        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyRedeem, output, false);
-
-        emit ExitMultiplePostExpiry(
-            msg.sender,
-            market,
-            output.tokenOut,
-            receiver,
-            netLpIn,
-            netPtFromRemove,
-            netSyFromRemove,
-            netPtRedeem,
-            netSyFromRedeem,
-            netTokenOut
-        );
+        p.netPtRedeem = p.netPtFromRemove + netPtIn;
+        p.netSyFromRedeem = IPYieldToken(YT).redeemPY(receiver);
+
+        p.totalSyOut = p.netSyFromRemove + p.netSyFromRedeem;
     }
 
     // ----------------- MISC FUNCTIONS -----------------

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "4.5.1-beta-1",
+  "version": "4.5.1-beta-2",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",