@pendle/core-v2 3.0.0 → 4.0.0

package/contracts/router/ActionMiscV3.sol

@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./base/ActionBase.sol";
+import "../interfaces/IPActionMiscV3.sol";
+
+contract ActionMiscV3 is IPActionMiscV3, ActionBase {
+    function mintSyFromToken(
+        address receiver,
+        address SY,
+        uint256 minSyOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netSyOut) {
+        netSyOut = _mintSyFromToken(receiver, SY, minSyOut, input);
+        emit MintSyFromToken(msg.sender, input.tokenIn, SY, receiver, input.netTokenIn, netSyOut);
+    }
+
+    function redeemSyToToken(
+        address receiver,
+        address SY,
+        uint256 netSyIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        netTokenOut = _redeemSyToToken(receiver, SY, netSyIn, output, true);
+        emit RedeemSyToToken(msg.sender, output.tokenOut, SY, receiver, netSyIn, netTokenOut);
+    }
+
+    function mintPyFromToken(
+        address receiver,
+        address YT,
+        uint256 minPyOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPyOut, uint256 netSyInterm) {
+        address SY = IPYieldToken(YT).SY();
+
+        netSyInterm = _mintSyFromToken(YT, SY, 0, input);
+        netPyOut = _mintPyFromSy(receiver, SY, YT, netSyInterm, minPyOut, false);
+
+        emit MintPyFromToken(msg.sender, input.tokenIn, YT, receiver, input.netTokenIn, netPyOut, netSyInterm);
+    }
+
+    function redeemPyToToken(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut, uint256 netSyInterm) {
+        address SY = IPYieldToken(YT).SY();
+
+        netSyInterm = _redeemPyToSy(SY, YT, netPyIn, 1);
+        netTokenOut = _redeemSyToToken(receiver, SY, netSyInterm, output, false);
+
+        emit RedeemPyToToken(msg.sender, output.tokenOut, YT, receiver, netPyIn, netTokenOut, netSyInterm);
+    }
+
+    function mintPyFromSy(
+        address receiver,
+        address YT,
+        uint256 netSyIn,
+        uint256 minPyOut
+    ) external returns (uint256 netPyOut) {
+        netPyOut = _mintPyFromSy(receiver, IPYieldToken(YT).SY(), YT, netSyIn, minPyOut, true);
+        emit MintPyFromSy(msg.sender, receiver, YT, netSyIn, netPyOut);
+    }
+
+    function redeemPyToSy(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        uint256 minSyOut
+    ) external returns (uint256 netSyOut) {
+        netSyOut = _redeemPyToSy(receiver, YT, netPyIn, minSyOut);
+        emit RedeemPyToSy(msg.sender, receiver, YT, netPyIn, netSyOut);
+    }
+
+    function redeemDueInterestAndRewards(
+        address user,
+        address[] calldata sys,
+        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);
+            }
+        }
+    }
+
+    function swapTokenToToken(
+        address receiver,
+        uint256 minTokenOut,
+        TokenInput calldata inp
+    ) external payable returns (uint256 netTokenOut) {
+        _swapTokenInput(inp);
+
+        netTokenOut = _selfBalance(inp.tokenMintSy);
+        if (netTokenOut < minTokenOut) {
+            revert Errors.RouterInsufficientTokenOut(netTokenOut, minTokenOut);
+        }
+
+        _transferOut(inp.tokenMintSy, receiver, netTokenOut);
+    }
+
+    function swapTokenToTokenViaSy(
+        address receiver,
+        address SY,
+        TokenInput calldata input,
+        address tokenRedeemSy,
+        uint256 minTokenOut
+    ) external payable returns (uint256 netTokenOut, uint256 netSyInterm) {
+        netSyInterm = _mintSyFromToken(SY, SY, 0, input);
+        netTokenOut = IStandardizedYield(SY).redeem(receiver, netSyInterm, tokenRedeemSy, minTokenOut, true);
+    }
+
+    // ----------------- MISC FUNCTIONS -----------------
+
+    function boostMarkets(address[] memory markets) external {
+        for (uint256 i = 0; i < markets.length; ) {
+            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;
+            }
+        }
+    }
+
+    function simulate(address target, bytes calldata data) external payable {
+        (bool success, bytes memory result) = target.delegatecall(data);
+        revert Errors.SimulationResults(success, result);
+    }
+}

package/contracts/router/ActionSwapPTV3.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./base/ActionBase.sol";
+import "../interfaces/IPActionSwapPTV3.sol";
+
+contract ActionSwapPTV3 is IPActionSwapPTV3, ActionBase {
+    using PMath for uint256;
+
+    // ------------------ SWAP TOKEN FOR PT ------------------
+    function swapExactTokenForPt(
+        address receiver,
+        address market,
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut,
+        TokenInput calldata input,
+        LimitOrderData calldata limit
+    ) external payable returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm) {
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+        netSyInterm = _mintSyFromToken(_entry_swapExactSyForPt(market, limit), address(SY), 1, input);
+
+        (netPtOut, netSyFee) = _swapExactSyForPt(receiver, market, netSyInterm, minPtOut, guessPtOut, limit);
+        emit SwapPtAndToken(
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            netPtOut.Int(),
+            input.netTokenIn.neg(),
+            netSyInterm
+        );
+    }
+
+    function swapExactSyForPt(
+        address receiver,
+        address market,
+        uint256 exactSyIn,
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netPtOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+        _transferFrom(SY, msg.sender, _entry_swapExactSyForPt(market, limit), exactSyIn);
+
+        (netPtOut, netSyFee) = _swapExactSyForPt(receiver, market, exactSyIn, minPtOut, guessPtOut, limit);
+        emit SwapPtAndSy(msg.sender, market, receiver, netPtOut.Int(), exactSyIn.neg());
+    }
+
+    function swapExactPtForToken(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
+        (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+        _transferFrom(PT, msg.sender, _entry_swapExactPtForSy(market, limit), exactPtIn);
+
+        (netSyInterm, netSyFee) = _swapExactPtForSy(address(SY), market, exactPtIn, 0, limit);
+
+        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyInterm, output, false);
+
+        emit SwapPtAndToken(
+            msg.sender,
+            market,
+            output.tokenOut,
+            receiver,
+            exactPtIn.neg(),
+            netTokenOut.Int(),
+            netSyInterm
+        );
+    }
+
+    function swapExactPtForSy(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netSyOut, uint256 netSyFee) {
+        (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+        _transferFrom(PT, msg.sender, _entry_swapExactPtForSy(market, limit), exactPtIn);
+
+        (netSyOut, netSyFee) = _swapExactPtForSy(receiver, market, exactPtIn, minSyOut, limit);
+        emit SwapPtAndSy(msg.sender, market, receiver, exactPtIn.neg(), netSyOut.Int());
+    }
+}

package/contracts/router/ActionSwapYTV3.sol

@@ -0,0 +1,240 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./base/ActionBase.sol";
+import "./base/CallbackHelper.sol";
+import "../interfaces/IPActionSwapYTV3.sol";
+
+contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
+    using PMath for uint256;
+    using MarketApproxPtInLib for MarketState;
+    using MarketApproxPtOutLib for MarketState;
+    using PYIndexLib for IPYieldToken;
+
+    // ------------------ SWAP TOKEN FOR YT ------------------
+
+    function swapExactTokenForYt(
+        address receiver,
+        address market,
+        uint256 minYtOut,
+        ApproxParams calldata guessYtOut,
+        TokenInput calldata input,
+        LimitOrderData calldata limit
+    ) external payable returns (uint256 netYtOut, uint256 netSyFee, uint256 netSyInterm) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        netSyInterm = _mintSyFromToken(_entry_swapExactSyForYt(YT, limit), address(SY), 1, input);
+        (netYtOut, netSyFee) = _swapExactSyForYt(receiver, market, SY, YT, netSyInterm, minYtOut, guessYtOut, limit);
+
+        emit SwapYtAndToken(
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            netYtOut.Int(),
+            input.netTokenIn.neg(),
+            netSyInterm
+        );
+    }
+
+    function swapExactSyForYt(
+        address receiver,
+        address market,
+        uint256 exactSyIn,
+        uint256 minYtOut,
+        ApproxParams calldata guessYtOut,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netYtOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        _transferFrom(SY, msg.sender, _entry_swapExactSyForYt(YT, limit), exactSyIn);
+
+        (netYtOut, netSyFee) = _swapExactSyForYt(receiver, market, SY, YT, exactSyIn, minYtOut, guessYtOut, limit);
+        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 Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
+    }
+
+    // ------------------ SWAP TOKEN FOR TOKEN ------------------
+
+    function swapExactYtForToken(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), exactYtIn);
+
+        (netSyInterm, netSyFee) = _swapExactYtForSy(address(SY), market, SY, YT, exactYtIn, 0, limit);
+
+        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyInterm, output, false);
+
+        emit SwapYtAndToken(
+            msg.sender,
+            market,
+            output.tokenOut,
+            receiver,
+            exactYtIn.neg(),
+            netTokenOut.Int(),
+            netSyInterm
+        );
+    }
+
+    function swapExactYtForSy(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) external returns (uint256 netSyOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+        _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), exactYtIn);
+
+        (netSyOut, netSyFee) = _swapExactYtForSy(receiver, market, SY, YT, exactYtIn, minSyOut, limit);
+        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 Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
+    }
+
+    // ------------------ SWAP PT FOR YT ------------------
+
+    function swapExactPtForYt(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        uint256 minYtOut,
+        ApproxParams calldata guessTotalPtToSwap
+    ) external returns (uint256 netYtOut, uint256 netSyFee) {
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 totalPtToSwap;
+        (netYtOut, totalPtToSwap, netSyFee) = _readMarket(market).approxSwapExactPtForYt(
+            YT.newIndex(),
+            exactPtIn,
+            block.timestamp,
+            guessTotalPtToSwap
+        );
+
+        _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
+
+        IPMarket(market).swapExactPtForSy(
+            address(YT),
+            totalPtToSwap,
+            _encodeSwapExactPtForYt(receiver, exactPtIn, minYtOut, YT)
+        );
+
+        emit SwapPtAndYt(msg.sender, market, receiver, exactPtIn.neg(), netYtOut.Int());
+    }
+
+    // ------------------ SWAP YT FOR PT ------------------
+    function swapExactYtForPt(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        uint256 minPtOut,
+        ApproxParams calldata guessTotalPtFromSwap
+    ) external returns (uint256 netPtOut, uint256 netSyFee) {
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 totalPtFromSwap;
+        (netPtOut, totalPtFromSwap, netSyFee) = _readMarket(market).approxSwapExactYtForPt(
+            YT.newIndex(),
+            exactYtIn,
+            block.timestamp,
+            guessTotalPtFromSwap
+        );
+
+        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
+
+        _transferFrom(IERC20(YT), msg.sender, address(YT), exactYtIn);
+        IPMarket(market).swapSyForExactPt(
+            address(this),
+            totalPtFromSwap,
+            _encodeSwapExactYtForPt(receiver, netPtOut, PT, YT)
+        );
+
+        emit SwapPtAndYt(msg.sender, market, receiver, netPtOut.Int(), exactYtIn.neg());
+    }
+}

package/contracts/router/PendleRouterHelper.sol

@@ -1,19 +1,18 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../interfaces/IPAllAction.sol";
 import "../interfaces/IPMarket.sol";
 import "../interfaces/IPRouterHelper.sol";
-import "./base/ActionBaseMintRedeem.sol";
 import "./base/MarketApproxLib.sol";
 import "../interfaces/IAddressProvider.sol";
+import "../core/libraries/TokenHelper.sol";
 
 contract PendleRouterHelper is TokenHelper, IPRouterHelper {
-    IPAllAction public immutable ROUTER;
+    RouterV2InterfaceForRouterHelper public immutable ROUTER;
     address public immutable WETH;
 
     constructor(address _ROUTER, IAddressProvider provider) {
-        ROUTER = IPAllAction(_ROUTER);
+        ROUTER = RouterV2InterfaceForRouterHelper(_ROUTER);
         WETH = _getWETHAddress(provider, 1);
         _safeApproveInf(WETH, address(ROUTER));
     }
@@ -26,8 +25,8 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
 
     /**
      * @dev all the parameters for this function should be generated in the same way as they are
-     generated for the main Router, except that input.tokenIn & swapData should be generated
-     for tokenIn == WETH instead of ETH
+     *  generated for the main Router, except that input.tokenIn & swapData should be generated
+     *  for tokenIn == WETH instead of ETH
      */
     function addLiquiditySingleTokenKeepYtWithEth(
         address receiver,
@@ -152,7 +151,7 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
             toMarket.market,
             toMarket.minLpOut,
             _scaleApproxParams(toMarket.guessPtReceivedFromSy, toMarket.guessNetTokenIn, actualNetTokenIn),
-            _newTokenInputStruct(tokenToZapIn, actualNetTokenIn, toMarket.bulk)
+            _newTokenInputStruct(tokenToZapIn, actualNetTokenIn)
         );
 
         emit AddLiquiditySingleToken(msg.sender, toMarket.market, tokenToZapIn, msg.sender, actualNetTokenIn, netLpOut);
@@ -194,7 +193,7 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
             toMarket.market,
             toMarket.minLpOut,
             toMarket.minYtOut,
-            _newTokenInputStruct(tokenToZapIn, actualNetTokenIn, toMarket.bulk)
+            _newTokenInputStruct(tokenToZapIn, actualNetTokenIn)
         );
 
         emit AddLiquiditySingleTokenKeepYt(
@@ -229,14 +228,9 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
 
     // ============ struct helpers ============
 
-    function _newTokenInputStruct(
-        address tokenIn,
-        uint256 netTokenIn,
-        address bulk
-    ) internal pure returns (TokenInput memory res) {
+    function _newTokenInputStruct(address tokenIn, uint256 netTokenIn) internal pure returns (TokenInput memory res) {
         res.tokenIn = res.tokenMintSy = tokenIn;
         res.netTokenIn = netTokenIn;
-        res.bulk = bulk;
         return res;
     }
 
@@ -261,3 +255,51 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
             });
     }
 }
+
+interface RouterV2InterfaceForRouterHelper {
+    function addLiquiditySingleSy(
+        address receiver,
+        address market,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        ApproxParams calldata guessPtReceivedFromSy
+    ) external returns (uint256 netLpOut, uint256 netSyFee);
+
+    function addLiquiditySingleToken(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        ApproxParams calldata guessPtReceivedFromSy,
+        TokenInput calldata input
+    ) external payable returns (uint256 netLpOut, uint256 netSyFee);
+
+    function addLiquiditySingleSyKeepYt(
+        address receiver,
+        address market,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) external returns (uint256 netLpOut, uint256 netYtOut);
+
+    function addLiquiditySingleTokenKeepYt(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input
+    ) external returns (uint256 netLpOut, uint256 netYtOut);
+
+    function removeLiquiditySingleSy(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        uint256 minSyOut
+    ) external returns (uint256 netSyOut, uint256 netSyFee);
+
+    function removeLiquiditySingleToken(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut, uint256 netSyFee);
+}