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

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,156 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         netTokenOut = IStandardizedYield(SY).redeem(receiver, netSyInterm, tokenRedeemSy, minTokenOut, true);
     }
 
+    // TODO: need to allow exit to SY as well
+    // TODO: check against minOut
+    // double check event orders
+
+    function exitPreExpToToken(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
+    ) external returns (uint256 totalTokenOut, ExitPreExpReturnParams memory params) {
+        IStandardizedYield SY;
+
+        (SY, params) = _exitPreExpToSy(true, address(0), market, netPtIn, netYtIn, netLpIn, limit);
+        totalTokenOut = _redeemSyToToken(receiver, address(SY), params.totalSyOut, output, false);
+
+        emit ExitPreExpToToken(msg.sender, market, output.tokenOut, receiver, netLpIn, totalTokenOut, params);
+    }
+
+    function exitPreExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) 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 _exitPreExpToSy(
+        bool setReceiverToSy,
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        LimitOrderData calldata limit
+    ) 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;
+    }
+
+    function exitPostExpToToken(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn,
+        TokenOutput calldata output
+    ) 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);
+            (p.netSyFromRemove, p.netPtFromRemove) = IPMarket(market).burn(receiver, address(YT), netLpIn);
+        }
+
+        if (netPtIn > 0) {
+            _transferFrom(PT, msg.sender, address(YT), netPtIn);
+        }
+
+        p.netPtRedeem = p.netPtFromRemove + netPtIn;
+        p.netSyFromRedeem = IPYieldToken(YT).redeemPY(receiver);
+
+        p.totalSyOut = p.netSyFromRemove + p.netSyFromRedeem;
+    }
+
     // ----------------- 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))
+            }
+        }
+    }
 }