@pendle/core-v2 1.3.0-mainnet → 2.0.0-mainnet

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);
-    }
 }

package/contracts/router/base/CallbackHelper.sol

@@ -1,6 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
+import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IPPrincipalToken.sol";
+import "../../interfaces/IStandardizedYield.sol";
+
 abstract contract CallbackHelper {
     enum ActionType {
         SwapSyForExactYt,
@@ -14,20 +18,37 @@ abstract contract CallbackHelper {
     /// SwapExactSyForYt
     /// ------------------------------------------------------------
 
-    function _encodeSwapExactSyForYt(address receiver, uint256 minYtOut)
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encode(ActionType.SwapExactSyForYt, receiver, minYtOut);
+    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), minYtOut)
+            mstore(add(res, 128), YT)
+        }
     }
 
-    function _decodeSwapExactSyForYt(bytes memory data)
+    function _decodeSwapExactSyForYt(bytes calldata data)
         internal
         pure
-        returns (address receiver, uint256 minYtOut)
+        returns (
+            address receiver,
+            uint256 minYtOut,
+            IPYieldToken YT
+        )
     {
-        (, receiver, minYtOut) = abi.decode(data, (ActionType, address, uint256));
+        assembly {
+            // first 32 bytes is ActionType
+            receiver := calldataload(add(data.offset, 32))
+            minYtOut := calldataload(add(data.offset, 64))
+            YT := calldataload(add(data.offset, 96))
+        }
     }
 
     /// ------------------------------------------------------------
@@ -37,93 +58,165 @@ abstract contract CallbackHelper {
     function _encodeSwapSyForExactYt(
         address payer,
         address receiver,
-        uint256 maxSyIn
-    ) internal pure returns (bytes memory) {
-        return abi.encode(ActionType.SwapSyForExactYt, payer, receiver, maxSyIn);
+        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 memory data)
+    function _decodeSwapSyForExactYt(bytes calldata data)
         internal
         pure
         returns (
             address payer,
             address receiver,
-            uint256 maxSyIn
+            uint256 maxSyIn,
+            IStandardizedYield SY,
+            IPYieldToken YT
         )
     {
-        (, payer, receiver, maxSyIn) = abi.decode(data, (ActionType, address, address, uint256));
+        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))
+        }
     }
 
     /// ------------------------------------------------------------
     /// SwapYtForSy (common encode & decode)
     /// ------------------------------------------------------------
 
-    function _encodeSwapYtForSy(address receiver, uint256 minSyOut)
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encode(ActionType.SwapYtForSy, receiver, minSyOut);
+    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), minSyOut)
+            mstore(add(res, 128), YT)
+        }
     }
 
-    function _decodeSwapYtForSy(bytes memory data)
+    function _decodeSwapYtForSy(bytes calldata data)
         internal
         pure
-        returns (address receiver, uint256 minSyOut)
+        returns (
+            address receiver,
+            uint256 minSyOut,
+            IPYieldToken YT
+        )
     {
-        (, receiver, minSyOut) = abi.decode(data, (ActionType, address, uint256));
+        assembly {
+            // first 32 bytes is ActionType
+            receiver := calldataload(add(data.offset, 32))
+            minSyOut := calldataload(add(data.offset, 64))
+            YT := calldataload(add(data.offset, 96))
+        }
     }
 
     function _encodeSwapExactYtForPt(
         address receiver,
         uint256 exactYtIn,
-        uint256 minPtOut
-    ) internal pure returns (bytes memory) {
-        return abi.encode(ActionType.SwapExactYtForPt, receiver, exactYtIn, minPtOut);
+        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), exactYtIn)
+            mstore(add(res, 128), minPtOut)
+            mstore(add(res, 160), PT)
+            mstore(add(res, 192), YT)
+        }
     }
 
-    function _decodeSwapExactYtForPt(bytes memory data)
+    function _decodeSwapExactYtForPt(bytes calldata data)
         internal
         pure
         returns (
             address receiver,
             uint256 exactYtIn,
-            uint256 minPtOut
+            uint256 minPtOut,
+            IPPrincipalToken PT,
+            IPYieldToken YT
         )
     {
-        (, receiver, exactYtIn, minPtOut) = abi.decode(
-            data,
-            (ActionType, address, uint256, uint256)
-        );
+        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))
+        }
     }
 
     function _encodeSwapExactPtForYt(
         address receiver,
         uint256 exactPtIn,
-        uint256 minYtOut
-    ) internal pure returns (bytes memory) {
-        return abi.encode(ActionType.SwapExactPtForYt, receiver, exactPtIn, minYtOut);
+        uint256 minYtOut,
+        IPYieldToken YT
+    ) internal pure returns (bytes memory res) {
+        res = new bytes(160);
+        uint256 actionType = uint256(ActionType.SwapExactPtForYt);
+
+        assembly {
+            mstore(add(res, 32), actionType)
+            mstore(add(res, 64), receiver)
+            mstore(add(res, 96), exactPtIn)
+            mstore(add(res, 128), minYtOut)
+            mstore(add(res, 160), YT)
+        }
     }
 
-    function _decodeSwapExactPtForYt(bytes memory data)
+    function _decodeSwapExactPtForYt(bytes calldata data)
         internal
         pure
         returns (
             address receiver,
             uint256 exactPtIn,
-            uint256 minYtOut
+            uint256 minYtOut,
+            IPYieldToken YT
         )
     {
-        (, receiver, exactPtIn, minYtOut) = abi.decode(
-            data,
-            (ActionType, address, uint256, uint256)
-        );
+        assembly {
+            // first 32 bytes is ActionType
+            receiver := calldataload(add(data.offset, 32))
+            exactPtIn := calldataload(add(data.offset, 64))
+            minYtOut := calldataload(add(data.offset, 96))
+            YT := calldataload(add(data.offset, 128))
+        }
     }
 
     /// ------------------------------------------------------------
     /// Misc functions
     /// ------------------------------------------------------------
-    function _getActionType(bytes memory data) internal pure returns (ActionType actionType) {
-        actionType = abi.decode(data, (ActionType));
+    function _getActionType(bytes calldata data) internal pure returns (ActionType actionType) {
+        assembly {
+            actionType := calldataload(data.offset)
+        }
     }
 }