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

package/contracts/router/ActionMiscV3.sol

@@ -79,18 +79,16 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         address[] calldata yts,
         address[] calldata markets
     ) external {
-        unchecked {
-            for (uint256 i = 0; i < sys.length; ++i) {
-                IStandardizedYield(sys[i]).claimRewards(user);
-            }
-
-            for (uint256 i = 0; i < yts.length; ++i) {
-                IPYieldToken(yts[i]).redeemDueInterestAndRewards(user, true, true);
-            }
-
-            for (uint256 i = 0; i < markets.length; ++i) {
-                IPMarket(markets[i]).redeemRewards(user);
-            }
+        for (uint256 i = 0; i < sys.length; ++i) {
+            IStandardizedYield(sys[i]).claimRewards(user);
+        }
+
+        for (uint256 i = 0; i < yts.length; ++i) {
+            IPYieldToken(yts[i]).redeemDueInterestAndRewards(user, true, true);
+        }
+
+        for (uint256 i = 0; i < markets.length; ++i) {
+            IPMarket(markets[i]).redeemRewards(user);
         }
     }
 
@@ -118,40 +116,222 @@ 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,
+        address receiver,
+        uint256 netLpToRemove,
+        uint256 netPtFromRemove, //
+        uint256 netSyFromRemove, //
+        uint256 netPtRedeem,
+        uint256 netSyFromRedeem, //
+        uint256 netTokenOut //
+    );
+
+    // TODO: need to allow exit to SY as well
+
+    struct ExitMultipleParams {
+        address receiver;
+        address market;
+        uint256 netPtIn;
+        uint256 netYtIn;
+        uint256 netLpIn;
+        TokenOutput output;
+        LimitOrderData limit;
+    }
+
+    function exitMultiplePreExpiry(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        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
+        )
+    {
+        (
+            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
+        );
+    }
+
+    function exitMultiplePreExpiryInner(
+        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);
+    }
+
+    // TODO: is netSyInterm necessary? can we return more?
+    // TODO: compare interface against existing functions, to see if it makes sense
+    function exitMultiplePostExpiry(
+        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;
+
+        if (netLpIn > 0) {
+            _transferFrom(IERC20(market), msg.sender, market, netLpIn);
+            (netSyFromRemove, netPtFromRemove) = IPMarket(market).burn(address(SY), 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
+        );
+    }
+
     // ----------------- MISC FUNCTIONS -----------------
 
     function boostMarkets(address[] memory markets) external {
-        for (uint256 i = 0; i < markets.length; ) {
+        for (uint256 i = 0; i < markets.length; i++) {
             IPMarket(markets[i]).transferFrom(msg.sender, markets[i], 0);
-            unchecked {
-                i++;
-            }
         }
     }
 
     function multicall(Call3[] calldata calls) external payable returns (Result[] memory res) {
         uint256 length = calls.length;
         res = new Result[](length);
-        Call3 calldata call;
-        for (uint256 i = 0; i < length; ) {
-            call = calls[i];
-
-            // delegatecall to itself, it turns allowing invoking functions from other actions
-            (bool success, bytes memory result) = address(this).delegatecall(call.callData);
-
-            if (!success && !call.allowFailure) {
-                assembly {
-                    // We use Yul's revert() to bubble up errors from the target contract.
-                    revert(add(32, result), mload(result))
-                }
-            }
-
-            res[i].success = success;
-            res[i].returnData = result;
-
-            unchecked {
-                ++i;
-            }
+        for (uint256 i = 0; i < length; i++) {
+            (bool success, bytes memory result) = _delegateToSelf(calls[i].callData, calls[i].allowFailure);
+            res[i] = Result(success, result);
         }
     }
 

package/contracts/router/ActionSwapYTV3.sol

@@ -52,51 +52,6 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
         emit SwapYtAndSy(msg.sender, market, receiver, netYtOut.Int(), exactSyIn.neg());
     }
 
-    function _entry_swapExactSyForYt(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
-        return !_isEmptyLimit(limit) ? address(this) : address(YT);
-    }
-
-    function _swapExactSyForYt(
-        address receiver,
-        address market,
-        IStandardizedYield SY,
-        IPYieldToken YT,
-        uint256 exactSyIn,
-        uint256 minYtOut,
-        ApproxParams calldata guessYtOut,
-        LimitOrderData calldata limit
-    ) internal returns (uint256 netYtOut, uint256 netSyFee) {
-        uint256 netSyLeft = exactSyIn;
-        bool doMarketOrder = true;
-
-        if (!_isEmptyLimit(limit)) {
-            (netSyLeft, netYtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, SY, netSyLeft, limit);
-            if (doMarketOrder) {
-                _transferOut(address(SY), address(YT), netSyLeft);
-            }
-        }
-
-        if (doMarketOrder) {
-            (uint256 netYtOutMarket, ) = _readMarket(market).approxSwapExactSyForYt(
-                YT.newIndex(),
-                netSyLeft,
-                block.timestamp,
-                guessYtOut
-            );
-
-            (, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
-                address(YT),
-                netYtOutMarket, // exactPtIn = netYtOut
-                _encodeSwapExactSyForYt(receiver, YT)
-            );
-
-            netYtOut += netYtOutMarket;
-            netSyFee += netSyFeeMarket;
-        }
-
-        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
-    }
-
     // ------------------ SWAP TOKEN FOR TOKEN ------------------
 
     function swapExactYtForToken(
@@ -138,46 +93,6 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
         emit SwapYtAndSy(msg.sender, market, receiver, exactYtIn.neg(), netSyOut.Int());
     }
 
-    function _entry_swapExactYtForSy(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
-        return !_isEmptyLimit(limit) ? address(this) : address(YT);
-    }
-
-    function _swapExactYtForSy(
-        address receiver,
-        address market,
-        IStandardizedYield SY,
-        IPYieldToken YT,
-        uint256 exactYtIn,
-        uint256 minSyOut,
-        LimitOrderData calldata limit
-    ) internal returns (uint256 netSyOut, uint256 netSyFee) {
-        uint256 netYtLeft = exactYtIn;
-        bool doMarketOrder = true;
-
-        if (!_isEmptyLimit(limit)) {
-            (netYtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, YT, netYtLeft, limit);
-            if (doMarketOrder) {
-                _transferOut(address(YT), address(YT), netYtLeft);
-            }
-        }
-
-        if (doMarketOrder) {
-            uint256 preSyBalance = SY.balanceOf(receiver);
-
-            (, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(
-                address(YT),
-                netYtLeft, // exactPtOut = netYtLeft
-                _encodeSwapYtForSy(receiver, YT)
-            );
-
-            // avoid stack issue
-            netSyFee += netSyFeeMarket;
-            netSyOut += SY.balanceOf(receiver) - preSyBalance;
-        }
-
-        if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
-    }
-
     // ------------------ SWAP PT FOR YT ------------------
 
     function swapExactPtForYt(

package/contracts/router/base/ActionBase.sol

@@ -10,8 +10,10 @@ import "../../router/base/MarketApproxLib.sol";
 
 import "../../core/libraries/Errors.sol";
 import "../swap-aggregator/IPSwapAggregator.sol";
+import "./CallbackHelper.sol";
 
-abstract contract ActionBase is TokenHelper, IPLimitOrderType {
+abstract contract ActionBase is TokenHelper, CallbackHelper, IPLimitOrderType {
+    using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;
     using PMath for uint256;
     using PYIndexLib for IPYieldToken;
@@ -236,6 +238,93 @@ abstract contract ActionBase is TokenHelper, IPLimitOrderType {
         if (netPtOut < minPtOut) revert("Slippage: INSUFFICIENT_PT_OUT");
     }
 
+    // ----------------- YT SWAP -----------------
+
+    function _entry_swapExactYtForSy(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
+        return !_isEmptyLimit(limit) ? address(this) : address(YT);
+    }
+
+    function _swapExactYtForSy(
+        address receiver,
+        address market,
+        IStandardizedYield SY,
+        IPYieldToken YT,
+        uint256 exactYtIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) internal returns (uint256 netSyOut, uint256 netSyFee) {
+        uint256 netYtLeft = exactYtIn;
+        bool doMarketOrder = true;
+
+        if (!_isEmptyLimit(limit)) {
+            (netYtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, YT, netYtLeft, limit);
+            if (doMarketOrder) {
+                _transferOut(address(YT), address(YT), netYtLeft);
+            }
+        }
+
+        if (doMarketOrder) {
+            uint256 preSyBalance = SY.balanceOf(receiver);
+
+            (, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(
+                address(YT),
+                netYtLeft, // exactPtOut = netYtLeft
+                _encodeSwapYtForSy(receiver, YT)
+            );
+
+            // avoid stack issue
+            netSyFee += netSyFeeMarket;
+            netSyOut += SY.balanceOf(receiver) - preSyBalance;
+        }
+
+        if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
+    }
+
+    function _entry_swapExactSyForYt(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
+        return !_isEmptyLimit(limit) ? address(this) : address(YT);
+    }
+
+    function _swapExactSyForYt(
+        address receiver,
+        address market,
+        IStandardizedYield SY,
+        IPYieldToken YT,
+        uint256 exactSyIn,
+        uint256 minYtOut,
+        ApproxParams calldata guessYtOut,
+        LimitOrderData calldata limit
+    ) internal returns (uint256 netYtOut, uint256 netSyFee) {
+        uint256 netSyLeft = exactSyIn;
+        bool doMarketOrder = true;
+
+        if (!_isEmptyLimit(limit)) {
+            (netSyLeft, netYtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, SY, netSyLeft, limit);
+            if (doMarketOrder) {
+                _transferOut(address(SY), address(YT), netSyLeft);
+            }
+        }
+
+        if (doMarketOrder) {
+            (uint256 netYtOutMarket, ) = _readMarket(market).approxSwapExactSyForYt(
+                YT.newIndex(),
+                netSyLeft,
+                block.timestamp,
+                guessYtOut
+            );
+
+            (, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
+                address(YT),
+                netYtOutMarket, // exactPtIn = netYtOut
+                _encodeSwapExactSyForYt(receiver, YT)
+            );
+
+            netYtOut += netYtOutMarket;
+            netSyFee += netSyFeeMarket;
+        }
+
+        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
+    }
+
     // ----------------- LIMIT ORDERS -----------------
     function _fillLimit(
         address receiver,
@@ -284,4 +373,20 @@ abstract contract ActionBase is TokenHelper, IPLimitOrderType {
     function _isEmptyLimit(LimitOrderData calldata a) internal pure returns (bool) {
         return a.normalFills.length == 0 && a.flashFills.length == 0;
     }
+
+    // ----------------- DELEGATE CALL -----------------
+
+    function _delegateToSelf(
+        bytes memory data,
+        bool allowFailure
+    ) internal returns (bool success, bytes memory result) {
+        (success, result) = address(this).delegatecall(data);
+
+        if (!success && !allowFailure) {
+            assembly {
+                // We use Yul's revert() to bubble up errors from the target contract.
+                revert(add(32, result), mload(result))
+            }
+        }
+    }
 }