@pendle/core-v2 2.29.1 → 3.0.0-beta-2

package/contracts/router/base/ActionBaseCallback.sol

@@ -1,15 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.0;
 
-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 {
@@ -18,32 +17,10 @@ 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 {
+    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) {
@@ -55,70 +32,17 @@ abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, To
         }
     }
 
-    /// @dev refer to _swapExactSyForYt
-    function _callbackSwapExactSyForYt(
-        int256 ptToAccount,
-        int256 /*syToAccount*/,
-        bytes calldata data
-    ) internal {
-        (address receiver, uint256 minYtOut, IPYieldToken YT) = _decodeSwapExactSyForYt(data);
+    function _callbackSwapExactSyForYt(int256 ptToAccount, int256, /*syToAccount*/ bytes calldata data) internal {
+        (address receiver, 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, uint256 minSyOut, IPYieldToken YT) = _decodeSwapYtForSy(data);
+    function _callbackSwapYtForSy(int256 ptToAccount, int256 syToAccount, bytes calldata data) internal {
+        (address receiver, IPYieldToken YT) = _decodeSwapYtForSy(data);
         PYIndex pyIndex = YT.newIndex();
 
         uint256 syOwed = syToAccount.neg().Uint();
@@ -127,58 +51,35 @@ abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, To
         uint256[] memory amountPYToRedeems = new uint256[](2);
 
         (receivers[0], amountPYToRedeems[0]) = (msg.sender, pyIndex.syToAssetUp(syOwed));
-        (receivers[1], amountPYToRedeems[1]) = (
-            receiver,
-            ptToAccount.Uint() - amountPYToRedeems[0]
-        );
-
-        uint256[] memory amountSyOuts = YT.redeemPYMulti(receivers, amountPYToRedeems);
-        if (amountSyOuts[1] < minSyOut)
-            revert Errors.RouterInsufficientSyOut(amountSyOuts[1], minSyOut);
+        (receivers[1], amountPYToRedeems[1]) = (receiver, ptToAccount.Uint() - amountPYToRedeems[0]);
+
+        YT.redeemPYMulti(receivers, amountPYToRedeems);
     }
 
-    function _callbackSwapExactPtForYt(
-        int256 ptToAccount,
-        int256 /*syToAccount*/,
-        bytes calldata data
-    ) internal {
-        (
-            address receiver,
-            uint256 exactPtIn,
-            uint256 minYtOut,
-            IPYieldToken YT
-        ) = _decodeSwapExactPtForYt(data);
+    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)
+        if (exactPtIn + netPyOut < netPtOwed) {
             revert Errors.RouterInsufficientPtRepay(exactPtIn + netPyOut, netPtOwed);
+        }
     }
 
-    function _callbackSwapExactYtForPt(
-        int256 ptToAccount,
-        int256 syToAccount,
-        bytes calldata data
-    ) internal {
-        (
-            address receiver,
-            uint256 exactYtIn,
-            uint256 minPtOut,
-            IPPrincipalToken PT,
-            IPYieldToken YT
-        ) = _decodeSwapExactYtForPt(data);
+    function _callbackSwapExactYtForPt(int256 ptToAccount, int256 syToAccount, bytes calldata data) internal {
+        (address receiver, uint256 netPtOut, IPPrincipalToken PT, IPYieldToken YT) = _decodeSwapExactYtForPt(data);
 
         uint256 netSyOwed = syToAccount.abs();
 
-        _transferOut(address(PT), address(YT), exactYtIn);
+        uint256 netPtRedeemSy = ptToAccount.Uint() - netPtOut;
+        _transferOut(address(PT), address(YT), netPtRedeemSy);
+
         uint256 netSyToMarket = YT.redeemPY(msg.sender);
 
-        if (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/CallbackHelper.sol

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