@pendle/core-v2 1.2.0-mainnet → 1.2.1-testnet

package/contracts/router/{ActionCallback.sol → base/ActionBaseCallback.sol}

@@ -1,24 +1,24 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 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 "./base/MarketApproxLib.sol";
-import "./base/ActionBaseMintRedeem.sol";
-import "./base/CallbackHelper.sol";
+import "./MarketApproxLib.sol";
+import "./ActionBaseMintRedeem.sol";
+import "./CallbackHelper.sol";
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-contract ActionCallback is IPMarketSwapCallback, CallbackHelper, TokenHelper {
+abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, TokenHelper {
     using Math for int256;
     using Math for uint256;
     using PYIndexLib for PYIndex;
     using PYIndexLib for IPYieldToken;
 
-    address public immutable marketFactory;
+    address internal immutable marketFactory;
 
     modifier onlyPendleMarket(address caller) {
         if (!IPMarketFactory(marketFactory).isValidMarket(caller))
@@ -38,19 +38,18 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper, TokenHelper {
         int256 ptToAccount,
         int256 syToAccount,
         bytes calldata data
-    ) external override onlyPendleMarket(msg.sender) {
-        address market = msg.sender;
+    ) external override {
         ActionType swapType = _getActionType(data);
         if (swapType == ActionType.SwapExactSyForYt) {
-            _callbackSwapExactSyForYt(market, ptToAccount, syToAccount, data);
+            _callbackSwapExactSyForYt(ptToAccount, syToAccount, data);
         } else if (swapType == ActionType.SwapSyForExactYt) {
-            _callbackSwapSyForExactYt(market, ptToAccount, syToAccount, data);
+            _callbackSwapSyForExactYt(ptToAccount, syToAccount, data);
         } else if (swapType == ActionType.SwapYtForSy) {
-            _callbackSwapYtForSy(market, ptToAccount, syToAccount, data);
+            _callbackSwapYtForSy(ptToAccount, syToAccount, data);
         } else if (swapType == ActionType.SwapExactYtForPt) {
-            _callbackSwapExactYtForPt(market, ptToAccount, syToAccount, data);
+            _callbackSwapExactYtForPt(ptToAccount, syToAccount, data);
         } else if (swapType == ActionType.SwapExactPtForYt) {
-            _callbackSwapExactPtForYt(market, ptToAccount, syToAccount, data);
+            _callbackSwapExactPtForYt(ptToAccount, syToAccount, data);
         } else {
             assert(false);
         }
@@ -58,37 +57,33 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper, TokenHelper {
 
     /// @dev refer to _swapExactSyForYt
     function _callbackSwapExactSyForYt(
-        address market,
         int256 ptToAccount,
         int256, /*syToAccount*/
         bytes calldata data
     ) internal {
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
-        (address receiver, uint256 minYtOut) = _decodeSwapExactSyForYt(data);
+        (address receiver, uint256 minYtOut, IPYieldToken YT) = _decodeSwapExactSyForYt(data);
 
         uint256 ptOwed = ptToAccount.abs();
-        uint256 netPyOut = YT.mintPY(market, receiver);
+        uint256 netPyOut = YT.mintPY(msg.sender, receiver);
 
         if (netPyOut < ptOwed) revert Errors.RouterInsufficientPtRepay(netPyOut, ptOwed);
         if (netPyOut < minYtOut) revert Errors.RouterInsufficientYtOut(netPyOut, minYtOut);
     }
 
-    struct VarsSwapSyForExactYt {
-        address payer;
-        address receiver;
-        uint256 maxSyToPull;
-    }
-
     /// @dev refer to _swapSyForExactYt
+    /// @dev we require msg.sender to be market here to make sure payer is the original msg.sender
     function _callbackSwapSyForExactYt(
-        address market,
         int256 ptToAccount,
         int256 syToAccount,
         bytes calldata data
-    ) internal {
-        VarsSwapSyForExactYt memory vars;
-        (vars.payer, vars.receiver, vars.maxSyToPull) = _decodeSwapSyForExactYt(data);
-        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+    ) internal onlyPendleMarket(msg.sender) {
+        (
+            address payer,
+            address receiver,
+            uint256 maxSyToPull,
+            IStandardizedYield SY,
+            IPYieldToken YT
+        ) = _decodeSwapSyForExactYt(data);
 
         /// ------------------------------------------------------------
         /// calc totalSyNeed
@@ -103,29 +98,27 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper, TokenHelper {
         uint256 syReceived = syToAccount.Uint();
         uint256 netSyToPull = totalSyNeed.subMax0(syReceived);
 
-        if (netSyToPull > vars.maxSyToPull)
-            revert Errors.RouterExceededLimitSyIn(netSyToPull, vars.maxSyToPull);
+        if (netSyToPull > maxSyToPull)
+            revert Errors.RouterExceededLimitSyIn(netSyToPull, maxSyToPull);
 
         /// ------------------------------------------------------------
         /// mint & transfer
         /// ------------------------------------------------------------
         if (netSyToPull > 0) {
-            _transferFrom(IERC20(SY), vars.payer, address(YT), netSyToPull);
+            _transferFrom(IERC20(SY), payer, address(YT), netSyToPull);
         }
 
-        uint256 netPyOut = YT.mintPY(market, vars.receiver);
+        uint256 netPyOut = YT.mintPY(msg.sender, receiver);
         if (netPyOut < ptOwed) revert Errors.RouterInsufficientPtRepay(netPyOut, ptOwed);
     }
 
     /// @dev refer to _swapExactYtForSy or _swapYtForExactSy
     function _callbackSwapYtForSy(
-        address market,
         int256 ptToAccount,
         int256 syToAccount,
         bytes calldata data
     ) internal {
-        (address receiver, uint256 minSyOut) = _decodeSwapYtForSy(data);
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (address receiver, uint256 minSyOut, IPYieldToken YT) = _decodeSwapYtForSy(data);
         PYIndex pyIndex = YT.newIndex();
 
         uint256 syOwed = syToAccount.neg().Uint();
@@ -133,7 +126,7 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper, TokenHelper {
         address[] memory receivers = new address[](2);
         uint256[] memory amountPYToRedeems = new uint256[](2);
 
-        (receivers[0], amountPYToRedeems[0]) = (market, pyIndex.syToAssetUp(syOwed));
+        (receivers[0], amountPYToRedeems[0]) = (msg.sender, pyIndex.syToAssetUp(syOwed));
         (receivers[1], amountPYToRedeems[1]) = (
             receiver,
             ptToAccount.Uint() - amountPYToRedeems[0]
@@ -145,34 +138,41 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper, TokenHelper {
     }
 
     function _callbackSwapExactPtForYt(
-        address market,
         int256 ptToAccount,
         int256, /*syToAccount*/
         bytes calldata data
     ) internal {
-        (address receiver, uint256 exactPtIn, uint256 minYtOut) = _decodeSwapExactPtForYt(data);
+        (
+            address receiver,
+            uint256 exactPtIn,
+            uint256 minYtOut,
+            IPYieldToken YT
+        ) = _decodeSwapExactPtForYt(data);
         uint256 netPtOwed = ptToAccount.abs();
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        uint256 netPyOut = YT.mintPY(market, receiver);
+        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);
     }
 
     function _callbackSwapExactYtForPt(
-        address market,
         int256 ptToAccount,
         int256 syToAccount,
         bytes calldata data
     ) internal {
-        (address receiver, uint256 exactYtIn, uint256 minPtOut) = _decodeSwapExactYtForPt(data);
-        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+        (
+            address receiver,
+            uint256 exactYtIn,
+            uint256 minPtOut,
+            IPPrincipalToken PT,
+            IPYieldToken YT
+        ) = _decodeSwapExactYtForPt(data);
 
         uint256 netSyOwed = syToAccount.abs();
 
         _transferOut(address(PT), address(YT), exactYtIn);
-        uint256 netSyToMarket = YT.redeemPY(market);
+        uint256 netSyToMarket = YT.redeemPY(msg.sender);
 
         if (netSyToMarket < netSyOwed)
             revert Errors.RouterInsufficientSyRepay(netSyToMarket, netSyOwed);

package/contracts/router/base/ActionBaseMintRedeem.sol

@@ -1,53 +1,92 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "../kyberswap/KyberSwapHelper.sol";
 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, KyberSwapHelper {
+abstract contract ActionBaseMintRedeem is TokenHelper {
     bytes internal constant EMPTY_BYTES = abi.encode();
 
-    /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberScalingLib) KyberSwapHelper(_kyberScalingLib) {}
-
     function _mintSyFromToken(
         address receiver,
         address SY,
         uint256 minSyOut,
-        TokenInput calldata input
+        TokenInput calldata inp
     ) internal returns (uint256 netSyOut) {
-        _transferIn(input.tokenIn, msg.sender, input.netTokenIn);
-
-        bool requireSwap = input.tokenIn != input.tokenMintSy;
+        SwapType swapType = inp.swapData.swapType;
 
         uint256 netTokenMintSy;
 
-        if (requireSwap) {
-            _kyberswap(input.tokenIn, input.netTokenIn, input.kyberRouter, input.kybercall);
-            netTokenMintSy = _selfBalance(input.tokenMintSy);
+        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 {
-            netTokenMintSy = input.netTokenIn;
+            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);
         }
 
-        uint256 netNative = input.tokenMintSy == NATIVE ? netTokenMintSy : 0;
+        // 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 (input.bulk != address(0)) {
-            _safeApproveInf(input.tokenMintSy, input.bulk);
-            netSyOut = IPBulkSeller(input.bulk).swapExactTokenForSy{ value: netNative }(
+        if (inp.bulk != address(0)) {
+            netSyOut = IPBulkSeller(inp.bulk).swapExactTokenForSy{ value: netNative }(
                 receiver,
                 netTokenMintSy,
                 minSyOut
             );
         } else {
-            _safeApproveInf(input.tokenMintSy, SY);
             netSyOut = IStandardizedYield(SY).deposit{ value: netNative }(
                 receiver,
-                input.tokenMintSy,
+                inp.tokenMintSy,
                 netTokenMintSy,
                 minSyOut
             );
@@ -58,63 +97,77 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         address receiver,
         address SY,
         uint256 netSyIn,
-        TokenOutput memory output,
+        TokenOutput calldata out,
         bool doPull
     ) internal returns (uint256 netTokenOut) {
-        if (doPull) {
-            _transferFrom(IERC20(SY), msg.sender, _syOrBulk(SY, output), netSyIn);
+        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);
         }
+    }
 
-        bool requireSwap = output.tokenRedeemSy != output.tokenOut;
-        address receiverRedeemSy = requireSwap ? address(this) : receiver;
-        uint256 netTokenRedeemed;
+    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 (output.bulk != address(0)) {
-            netTokenRedeemed = IPBulkSeller(output.bulk).swapExactSyForToken(
-                receiverRedeemSy,
+        if (out.bulk != address(0)) {
+            netTokenRedeemed = IPBulkSeller(out.bulk).swapExactSyForToken(
+                receiver,
                 netSyIn,
                 0,
                 true
             );
         } else {
             netTokenRedeemed = IStandardizedYield(SY).redeem(
-                receiverRedeemSy,
+                receiver,
                 netSyIn,
-                output.tokenRedeemSy,
+                out.tokenRedeemSy,
                 0,
                 true
             );
         }
-
-        if (requireSwap) {
-            _kyberswap(
-                output.tokenRedeemSy,
-                netTokenRedeemed,
-                output.kyberRouter,
-                output.kybercall
-            );
-
-            netTokenOut = _selfBalance(output.tokenOut);
-
-            _transferOut(output.tokenOut, receiver, netTokenOut);
-        } else {
-            netTokenOut = netTokenRedeemed;
-        }
-
-        if (netTokenOut < output.minTokenOut) {
-            revert Errors.RouterInsufficientTokenOut(netTokenOut, output.minTokenOut);
-        }
     }
 
     function _mintPyFromSy(
         address receiver,
+        address SY,
         address YT,
         uint256 netSyIn,
         uint256 minPyOut,
         bool doPull
     ) internal returns (uint256 netPyOut) {
-        address SY = IPYieldToken(YT).SY();
-
         if (doPull) {
             _transferFrom(IERC20(SY), msg.sender, YT, netSyIn);
         }
@@ -140,19 +193,11 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
     }
 
-    function _syOrBulk(address SY, TokenOutput memory output)
+    function _syOrBulk(address SY, TokenOutput calldata output)
         internal
         pure
         returns (address addr)
     {
         return output.bulk != address(0) ? output.bulk : SY;
     }
-
-    function _wrapTokenOutput(
-        address tokenOut,
-        uint256 minTokenOut,
-        address bulk
-    ) internal pure returns (TokenOutput memory) {
-        return TokenOutput(tokenOut, minTokenOut, tokenOut, bulk, address(0), EMPTY_BYTES);
-    }
 }