@pendle/core-v2 3.0.0-beta-10 → 3.0.0

package/contracts/router/base/ActionBaseCallback.sol

@@ -1,14 +1,15 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
+pragma solidity ^0.8.17;
 
-import "../../interfaces/IPMarketFactory.sol";
-import "../../interfaces/IPMarket.sol";
-import "../../interfaces/IPMarketSwapCallback.sol";
-import "../../core/libraries/Errors.sol";
+import "../..//interfaces/IPMarketFactory.sol";
+import "../..//interfaces/IPMarket.sol";
+import "../..//interfaces/IPMarketSwapCallback.sol";
+import "../..//core/libraries/Errors.sol";
 
 import "./MarketApproxLib.sol";
+import "./ActionBaseMintRedeem.sol";
 import "./CallbackHelper.sol";
-import "../../core/libraries/TokenHelper.sol";
+
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, TokenHelper {
@@ -17,10 +18,27 @@ abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, To
     using PYIndexLib for PYIndex;
     using PYIndexLib for IPYieldToken;
 
+    address internal immutable marketFactory;
+
+    modifier onlyPendleMarket(address caller) {
+        if (!IPMarketFactory(marketFactory).isValidMarket(caller)) revert Errors.RouterCallbackNotPendleMarket(caller);
+        _;
+    }
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variables
+    constructor(address _marketFactory) {
+        marketFactory = _marketFactory;
+    }
+
+    /**
+     * @dev The callback is only callable by a Pendle Market created by the factory
+     */
     function swapCallback(int256 ptToAccount, int256 syToAccount, bytes calldata data) external override {
         ActionType swapType = _getActionType(data);
         if (swapType == ActionType.SwapExactSyForYt) {
             _callbackSwapExactSyForYt(ptToAccount, syToAccount, data);
+        } else if (swapType == ActionType.SwapSyForExactYt) {
+            _callbackSwapSyForExactYt(ptToAccount, syToAccount, data);
         } else if (swapType == ActionType.SwapYtForSy) {
             _callbackSwapYtForSy(ptToAccount, syToAccount, data);
         } else if (swapType == ActionType.SwapExactYtForPt) {
@@ -32,17 +50,61 @@ abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, To
         }
     }
 
-    function _callbackSwapExactSyForYt(int256 ptToAccount, int256, /*syToAccount*/ bytes calldata data) internal {
-        (address receiver, IPYieldToken YT) = _decodeSwapExactSyForYt(data);
+    /// @dev refer to _swapExactSyForYt
+    function _callbackSwapExactSyForYt(int256 ptToAccount, int256 /*syToAccount*/, bytes calldata data) internal {
+        (address receiver, uint256 minYtOut, IPYieldToken YT) = _decodeSwapExactSyForYt(data);
 
         uint256 ptOwed = ptToAccount.abs();
         uint256 netPyOut = YT.mintPY(msg.sender, receiver);
 
         if (netPyOut < ptOwed) revert Errors.RouterInsufficientPtRepay(netPyOut, ptOwed);
+        if (netPyOut < minYtOut) revert Errors.RouterInsufficientYtOut(netPyOut, minYtOut);
+    }
+
+    /// @dev refer to _swapSyForExactYt
+    /// @dev we require msg.sender to be market here to make sure payer is the original msg.sender
+    function _callbackSwapSyForExactYt(
+        int256 ptToAccount,
+        int256 syToAccount,
+        bytes calldata data
+    ) internal onlyPendleMarket(msg.sender) {
+        (
+            address payer,
+            address receiver,
+            uint256 maxSyToPull,
+            IStandardizedYield SY,
+            IPYieldToken YT
+        ) = _decodeSwapSyForExactYt(data);
+
+        /// ------------------------------------------------------------
+        /// calc totalSyNeed
+        /// ------------------------------------------------------------
+        PYIndex pyIndex = YT.newIndex();
+        uint256 ptOwed = ptToAccount.abs();
+        uint256 totalSyNeed = pyIndex.assetToSyUp(ptOwed);
+
+        /// ------------------------------------------------------------
+        /// calc netSyToPull
+        /// ------------------------------------------------------------
+        uint256 syReceived = syToAccount.Uint();
+        uint256 netSyToPull = totalSyNeed.subMax0(syReceived);
+
+        if (netSyToPull > maxSyToPull) revert Errors.RouterExceededLimitSyIn(netSyToPull, maxSyToPull);
+
+        /// ------------------------------------------------------------
+        /// mint & transfer
+        /// ------------------------------------------------------------
+        if (netSyToPull > 0) {
+            _transferFrom(IERC20(SY), payer, address(YT), netSyToPull);
+        }
+
+        uint256 netPyOut = YT.mintPY(msg.sender, receiver);
+        if (netPyOut < ptOwed) revert Errors.RouterInsufficientPtRepay(netPyOut, ptOwed);
     }
 
+    /// @dev refer to _swapExactYtForSy or _swapYtForExactSy
     function _callbackSwapYtForSy(int256 ptToAccount, int256 syToAccount, bytes calldata data) internal {
-        (address receiver, IPYieldToken YT) = _decodeSwapYtForSy(data);
+        (address receiver, uint256 minSyOut, IPYieldToken YT) = _decodeSwapYtForSy(data);
         PYIndex pyIndex = YT.newIndex();
 
         uint256 syOwed = syToAccount.neg().Uint();
@@ -53,33 +115,37 @@ abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, To
         (receivers[0], amountPYToRedeems[0]) = (msg.sender, pyIndex.syToAssetUp(syOwed));
         (receivers[1], amountPYToRedeems[1]) = (receiver, ptToAccount.Uint() - amountPYToRedeems[0]);
 
-        YT.redeemPYMulti(receivers, amountPYToRedeems);
+        uint256[] memory amountSyOuts = YT.redeemPYMulti(receivers, amountPYToRedeems);
+        if (amountSyOuts[1] < minSyOut) revert Errors.RouterInsufficientSyOut(amountSyOuts[1], minSyOut);
     }
 
-    function _callbackSwapExactPtForYt(int256 ptToAccount, int256, /*syToAccount*/ bytes calldata data) internal {
+    function _callbackSwapExactPtForYt(int256 ptToAccount, int256 /*syToAccount*/, bytes calldata data) internal {
         (address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT) = _decodeSwapExactPtForYt(data);
         uint256 netPtOwed = ptToAccount.abs();
 
         uint256 netPyOut = YT.mintPY(msg.sender, receiver);
         if (netPyOut < minYtOut) revert Errors.RouterInsufficientYtOut(netPyOut, minYtOut);
-        if (exactPtIn + netPyOut < netPtOwed) {
-            revert Errors.RouterInsufficientPtRepay(exactPtIn + netPyOut, netPtOwed);
-        }
+        if (exactPtIn + netPyOut < netPtOwed) revert Errors.RouterInsufficientPtRepay(exactPtIn + netPyOut, netPtOwed);
     }
 
     function _callbackSwapExactYtForPt(int256 ptToAccount, int256 syToAccount, bytes calldata data) internal {
-        (address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT) = _decodeSwapExactYtForPt(data);
+        (
+            address receiver,
+            uint256 exactYtIn,
+            uint256 minPtOut,
+            IPPrincipalToken PT,
+            IPYieldToken YT
+        ) = _decodeSwapExactYtForPt(data);
 
         uint256 netSyOwed = syToAccount.abs();
 
-        uint256 netPtRedeemSy = ptToAccount.Uint() - netPtOut;
-        _transferOut(address(PT), address(YT), netPtRedeemSy);
-
+        _transferOut(address(PT), address(YT), exactYtIn);
         uint256 netSyToMarket = YT.redeemPY(msg.sender);
 
-        if (netSyToMarket < netSyOwed) {
-            revert Errors.RouterInsufficientSyRepay(netSyToMarket, netSyOwed);
-        }
+        if (netSyToMarket < netSyOwed) revert Errors.RouterInsufficientSyRepay(netSyToMarket, netSyOwed);
+
+        uint256 netPtOut = ptToAccount.Uint() - exactYtIn;
+        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
 
         _transferOut(address(PT), receiver, netPtOut);
     }

package/contracts/router/base/ActionBaseMintRedeem.sol

@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../core/libraries/TokenHelper.sol";
+import "../../interfaces/IStandardizedYield.sol";
+import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IPBulkSeller.sol";
+
+import "../../core/libraries/Errors.sol";
+import "../swap-aggregator/IPSwapAggregator.sol";
+
+struct TokenInput {
+    // Token/Sy data
+    address tokenIn;
+    uint256 netTokenIn;
+    address tokenMintSy;
+    address bulk;
+    // aggregator data
+    address pendleSwap;
+    SwapData swapData;
+}
+
+struct TokenOutput {
+    // Token/Sy data
+    address tokenOut;
+    uint256 minTokenOut;
+    address tokenRedeemSy;
+    address bulk;
+    // aggregator data
+    address pendleSwap;
+    SwapData swapData;
+}
+
+// solhint-disable no-empty-blocks
+abstract contract ActionBaseMintRedeem is TokenHelper {
+    bytes internal constant EMPTY_BYTES = abi.encode();
+
+    function _mintSyFromToken(
+        address receiver,
+        address SY,
+        uint256 minSyOut,
+        TokenInput calldata inp
+    ) internal returns (uint256 netSyOut) {
+        SwapType swapType = inp.swapData.swapType;
+
+        uint256 netTokenMintSy;
+
+        if (swapType == SwapType.NONE) {
+            _transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);
+            netTokenMintSy = inp.netTokenIn;
+        } else if (swapType == SwapType.ETH_WETH) {
+            _transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);
+            _wrap_unwrap_ETH(inp.tokenIn, inp.tokenMintSy, inp.netTokenIn);
+            netTokenMintSy = inp.netTokenIn;
+        } else {
+            if (inp.tokenIn == NATIVE) _transferIn(NATIVE, msg.sender, inp.netTokenIn);
+            else _transferFrom(IERC20(inp.tokenIn), msg.sender, inp.pendleSwap, inp.netTokenIn);
+
+            IPSwapAggregator(inp.pendleSwap).swap{value: inp.tokenIn == NATIVE ? inp.netTokenIn : 0}(
+                inp.tokenIn,
+                inp.netTokenIn,
+                inp.swapData
+            );
+            netTokenMintSy = _selfBalance(inp.tokenMintSy);
+        }
+
+        // outcome of all branches: satisfy pre-condition of __mintSy
+
+        netSyOut = __mintSy(receiver, SY, netTokenMintSy, minSyOut, inp);
+    }
+
+    /// @dev pre-condition: having netTokenMintSy of tokens in this contract
+    function __mintSy(
+        address receiver,
+        address SY,
+        uint256 netTokenMintSy,
+        uint256 minSyOut,
+        TokenInput calldata inp
+    ) private returns (uint256 netSyOut) {
+        uint256 netNative = inp.tokenMintSy == NATIVE ? netTokenMintSy : 0;
+
+        if (inp.bulk != address(0)) {
+            netSyOut = IPBulkSeller(inp.bulk).swapExactTokenForSy{value: netNative}(receiver, netTokenMintSy, minSyOut);
+        } else {
+            netSyOut = IStandardizedYield(SY).deposit{value: netNative}(
+                receiver,
+                inp.tokenMintSy,
+                netTokenMintSy,
+                minSyOut
+            );
+        }
+    }
+
+    function _redeemSyToToken(
+        address receiver,
+        address SY,
+        uint256 netSyIn,
+        TokenOutput calldata out,
+        bool doPull
+    ) internal returns (uint256 netTokenOut) {
+        SwapType swapType = out.swapData.swapType;
+
+        if (swapType == SwapType.NONE) {
+            netTokenOut = __redeemSy(receiver, SY, netSyIn, out, doPull);
+        } else if (swapType == SwapType.ETH_WETH) {
+            netTokenOut = __redeemSy(address(this), SY, netSyIn, out, doPull); // ETH:WETH is 1:1
+
+            _wrap_unwrap_ETH(out.tokenRedeemSy, out.tokenOut, netTokenOut);
+
+            _transferOut(out.tokenOut, receiver, netTokenOut);
+        } else {
+            uint256 netTokenRedeemed = __redeemSy(out.pendleSwap, SY, netSyIn, out, doPull);
+
+            IPSwapAggregator(out.pendleSwap).swap(out.tokenRedeemSy, netTokenRedeemed, out.swapData);
+
+            netTokenOut = _selfBalance(out.tokenOut);
+
+            _transferOut(out.tokenOut, receiver, netTokenOut);
+        }
+
+        // outcome of all branches: netTokenOut of tokens goes back to receiver
+
+        if (netTokenOut < out.minTokenOut) {
+            revert Errors.RouterInsufficientTokenOut(netTokenOut, out.minTokenOut);
+        }
+    }
+
+    function __redeemSy(
+        address receiver,
+        address SY,
+        uint256 netSyIn,
+        TokenOutput calldata out,
+        bool doPull
+    ) private returns (uint256 netTokenRedeemed) {
+        if (doPull) {
+            _transferFrom(IERC20(SY), msg.sender, _syOrBulk(SY, out), netSyIn);
+        }
+
+        if (out.bulk != address(0)) {
+            netTokenRedeemed = IPBulkSeller(out.bulk).swapExactSyForToken(receiver, netSyIn, 0, true);
+        } else {
+            netTokenRedeemed = IStandardizedYield(SY).redeem(receiver, netSyIn, out.tokenRedeemSy, 0, true);
+        }
+    }
+
+    function _mintPyFromSy(
+        address receiver,
+        address SY,
+        address YT,
+        uint256 netSyIn,
+        uint256 minPyOut,
+        bool doPull
+    ) internal returns (uint256 netPyOut) {
+        if (doPull) {
+            _transferFrom(IERC20(SY), msg.sender, YT, netSyIn);
+        }
+
+        netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
+        if (netPyOut < minPyOut) revert Errors.RouterInsufficientPYOut(netPyOut, minPyOut);
+    }
+
+    function _redeemPyToSy(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        uint256 minSyOut
+    ) internal returns (uint256 netSyOut) {
+        address PT = IPYieldToken(YT).PT();
+
+        _transferFrom(IERC20(PT), msg.sender, YT, netPyIn);
+
+        bool needToBurnYt = (!IPYieldToken(YT).isExpired());
+        if (needToBurnYt) _transferFrom(IERC20(YT), msg.sender, YT, netPyIn);
+
+        netSyOut = IPYieldToken(YT).redeemPY(receiver);
+        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
+    }
+
+    function _syOrBulk(address SY, TokenOutput calldata output) internal pure returns (address addr) {
+        return output.bulk != address(0) ? output.bulk : SY;
+    }
+}

package/contracts/router/base/CallbackHelper.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.0;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPPrincipalToken.sol";
@@ -7,6 +7,7 @@ import "../../interfaces/IStandardizedYield.sol";
 
 abstract contract CallbackHelper {
     enum ActionType {
+        SwapSyForExactYt,
         SwapExactSyForYt,
         SwapYtForSy,
         SwapExactYtForPt,
@@ -17,22 +18,67 @@ abstract contract CallbackHelper {
     /// SwapExactSyForYt
     /// ------------------------------------------------------------
 
-    function _encodeSwapExactSyForYt(address receiver, IPYieldToken YT) internal pure returns (bytes memory res) {
-        res = new bytes(96);
+    function _encodeSwapExactSyForYt(
+        address receiver,
+        uint256 minYtOut,
+        IPYieldToken YT
+    ) internal pure returns (bytes memory res) {
+        res = new bytes(128);
         uint256 actionType = uint256(ActionType.SwapExactSyForYt);
 
         assembly {
             mstore(add(res, 32), actionType)
             mstore(add(res, 64), receiver)
-            mstore(add(res, 96), YT)
+            mstore(add(res, 96), minYtOut)
+            mstore(add(res, 128), YT)
         }
     }
 
-    function _decodeSwapExactSyForYt(bytes calldata data) internal pure returns (address receiver, IPYieldToken YT) {
+    function _decodeSwapExactSyForYt(
+        bytes calldata data
+    ) internal pure returns (address receiver, uint256 minYtOut, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))
-            YT := calldataload(add(data.offset, 64))
+            minYtOut := calldataload(add(data.offset, 64))
+            YT := calldataload(add(data.offset, 96))
+        }
+    }
+
+    /// ------------------------------------------------------------
+    /// SwapSyForExactYt
+    /// ------------------------------------------------------------
+
+    function _encodeSwapSyForExactYt(
+        address payer,
+        address receiver,
+        uint256 maxSyIn,
+        IStandardizedYield SY,
+        IPYieldToken YT
+    ) internal pure returns (bytes memory res) {
+        res = new bytes(192);
+        uint256 actionType = uint256(ActionType.SwapSyForExactYt);
+
+        assembly {
+            mstore(add(res, 32), actionType)
+            mstore(add(res, 64), payer)
+            mstore(add(res, 96), receiver)
+            mstore(add(res, 128), maxSyIn)
+            mstore(add(res, 160), SY)
+            mstore(add(res, 192), YT)
+        }
+    }
+
+    function _decodeSwapSyForExactYt(
+        bytes calldata data
+    ) internal pure returns (address payer, address receiver, uint256 maxSyIn, IStandardizedYield SY, IPYieldToken YT) {
+        assembly {
+            // first 32 bytes is ActionType
+            payer := calldataload(add(data.offset, 32))
+            receiver := calldataload(add(data.offset, 64))
+            maxSyIn := calldataload(add(data.offset, 96))
+            SY := calldataload(add(data.offset, 128))
+            YT := calldataload(add(data.offset, 160))
         }
     }
 
@@ -40,61 +86,76 @@ abstract contract CallbackHelper {
     /// SwapYtForSy (common encode & decode)
     /// ------------------------------------------------------------
 
-    function _encodeSwapYtForSy(address receiver, IPYieldToken YT) internal pure returns (bytes memory res) {
-        res = new bytes(96);
+    function _encodeSwapYtForSy(
+        address receiver,
+        uint256 minSyOut,
+        IPYieldToken YT
+    ) internal pure returns (bytes memory res) {
+        res = new bytes(128);
         uint256 actionType = uint256(ActionType.SwapYtForSy);
 
         assembly {
             mstore(add(res, 32), actionType)
             mstore(add(res, 64), receiver)
-            mstore(add(res, 96), YT)
+            mstore(add(res, 96), minSyOut)
+            mstore(add(res, 128), YT)
         }
     }
 
-    function _decodeSwapYtForSy(bytes calldata data) internal pure returns (address receiver, IPYieldToken YT) {
+    function _decodeSwapYtForSy(
+        bytes calldata data
+    ) internal pure returns (address receiver, uint256 minSyOut, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))
-            YT := calldataload(add(data.offset, 64))
+            minSyOut := calldataload(add(data.offset, 64))
+            YT := calldataload(add(data.offset, 96))
         }
     }
 
-    function _encodeSwapExactYtForPt(address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT)
-        internal
-        pure
-        returns (bytes memory res)
-    {
-        res = new bytes(160);
+    function _encodeSwapExactYtForPt(
+        address receiver,
+        uint256 exactYtIn,
+        uint256 minPtOut,
+        IPPrincipalToken PT,
+        IPYieldToken YT
+    ) internal pure returns (bytes memory res) {
+        res = new bytes(192);
         uint256 actionType = uint256(ActionType.SwapExactYtForPt);
 
         assembly {
             mstore(add(res, 32), actionType)
             mstore(add(res, 64), receiver)
-            mstore(add(res, 96), netPtOut)
-            mstore(add(res, 128), PT)
-            mstore(add(res, 160), YT)
+            mstore(add(res, 96), exactYtIn)
+            mstore(add(res, 128), minPtOut)
+            mstore(add(res, 160), PT)
+            mstore(add(res, 192), YT)
         }
     }
 
-    function _decodeSwapExactYtForPt(bytes calldata data)
+    function _decodeSwapExactYtForPt(
+        bytes calldata data
+    )
         internal
         pure
-        returns (address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT)
+        returns (address receiver, uint256 exactYtIn, uint256 minPtOut, IPPrincipalToken PT, IPYieldToken YT)
     {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))
-            netPtOut := calldataload(add(data.offset, 64))
-            PT := calldataload(add(data.offset, 96))
-            YT := calldataload(add(data.offset, 128))
+            exactYtIn := calldataload(add(data.offset, 64))
+            minPtOut := calldataload(add(data.offset, 96))
+            PT := calldataload(add(data.offset, 128))
+            YT := calldataload(add(data.offset, 160))
         }
     }
 
-    function _encodeSwapExactPtForYt(address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT)
-        internal
-        pure
-        returns (bytes memory res)
-    {
+    function _encodeSwapExactPtForYt(
+        address receiver,
+        uint256 exactPtIn,
+        uint256 minYtOut,
+        IPYieldToken YT
+    ) internal pure returns (bytes memory res) {
         res = new bytes(160);
         uint256 actionType = uint256(ActionType.SwapExactPtForYt);
 
@@ -107,11 +168,9 @@ abstract contract CallbackHelper {
         }
     }
 
-    function _decodeSwapExactPtForYt(bytes calldata data)
-        internal
-        pure
-        returns (address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT)
-    {
+    function _decodeSwapExactPtForYt(
+        bytes calldata data
+    ) internal pure returns (address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT) {
         assembly {
             // first 32 bytes is ActionType
             receiver := calldataload(add(data.offset, 32))