@pendle/core-v2 0.9.4-beta → 0.10.2-testnet

package/contracts/core/actions/ActionMintRedeem.sol

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "./base/ActionBaseMintRedeem.sol";
+import "../../interfaces/IPMarket.sol";
+import "../../interfaces/IPActionMintRedeem.sol";
+
+contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
+    using MarketMathCore for MarketState;
+    using Math for uint256;
+    using Math for int256;
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variables
+    constructor(address _kyberSwapRouter)
+        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    {}
+
+    /// @dev refer to the internal function
+    function mintScyFromToken(
+        address receiver,
+        address SCY,
+        uint256 minScyOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netScyOut) {
+        netScyOut = _mintScyFromToken(receiver, SCY, minScyOut, input);
+
+        emit MintScyFromToken(
+            msg.sender,
+            receiver,
+            SCY,
+            input.tokenIn,
+            input.netTokenIn,
+            netScyOut
+        );
+    }
+
+    /// @dev refer to the internal function
+    function redeemScyToToken(
+        address receiver,
+        address SCY,
+        uint256 netScyIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        netTokenOut = _redeemScyToToken(receiver, SCY, netScyIn, output, true);
+        emit RedeemScyToToken(msg.sender, receiver, SCY, netScyIn, output.tokenOut, netTokenOut);
+    }
+
+    /// @dev refer to the internal function
+    function mintPyFromToken(
+        address receiver,
+        address YT,
+        uint256 minPyOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPyOut) {
+        netPyOut = _mintPyFromToken(receiver, YT, minPyOut, input);
+        emit MintPyFromToken(msg.sender, receiver, YT, input.tokenIn, input.netTokenIn, netPyOut);
+    }
+
+    /// @dev refer to the internal function
+    function redeemPyToToken(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        netTokenOut = _redeemPyToToken(receiver, YT, netPyIn, output, true);
+        emit RedeemPyToToken(msg.sender, receiver, YT, netPyIn, output.tokenOut, netTokenOut);
+    }
+
+    function mintPyFromScy(
+        address receiver,
+        address YT,
+        uint256 netScyIn,
+        uint256 minPyOut
+    ) external returns (uint256 netPyOut) {
+        netPyOut = _mintPyFromScy(receiver, YT, netScyIn, minPyOut, true);
+        emit MintPyFromScy(msg.sender, receiver, YT, netScyIn, netPyOut);
+    }
+
+    function redeemPyToScy(
+        address receiver,
+        address YT,
+        uint256 netPyIn,
+        uint256 minScyOut
+    ) external returns (uint256 netScyOut) {
+        netScyOut = _redeemPyToScy(receiver, YT, netPyIn, minScyOut, true);
+        emit RedeemPyToScy(msg.sender, receiver, YT, netPyIn, netScyOut);
+    }
+
+    function redeemDueInterestAndRewards(
+        address user,
+        address[] calldata scys,
+        address[] calldata yts,
+        address[] calldata markets
+    )
+        external
+        returns (
+            uint256[][] memory scyRewards,
+            uint256[] memory ytInterests,
+            uint256[][] memory ytRewards,
+            uint256[][] memory marketRewards
+        )
+    {
+        scyRewards = new uint256[][](scys.length);
+        for (uint256 i = 0; i < scys.length; ++i) {
+            scyRewards[i] = ISuperComposableYield(scys[i]).claimRewards(user);
+        }
+
+        ytInterests = new uint256[](yts.length);
+        ytRewards = new uint256[][](yts.length);
+        for (uint256 i = 0; i < yts.length; ++i) {
+            (ytInterests[i], ytRewards[i]) = IPYieldToken(yts[i]).redeemDueInterestAndRewards(
+                user,
+                true,
+                true
+            );
+        }
+
+        marketRewards = new uint256[][](markets.length);
+        for (uint256 i = 0; i < markets.length; ++i) {
+            marketRewards[i] = IPMarket(markets[i]).redeemRewards(user);
+        }
+    }
+}

package/contracts/core/actions/ActionMisc.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../../interfaces/IPMarket.sol";
+import "../../interfaces/IPActionMisc.sol";
+
+contract ActionMisc is IPActionMisc {
+    using Math for uint256;
+
+    function consult(address market, uint32 secondsAgo)
+        external
+        view
+        returns (uint96 lnImpliedRateMean)
+    {
+        require(secondsAgo != 0, "time range is zero");
+        uint32[] memory secondsAgos = new uint32[](2);
+        secondsAgos[0] = secondsAgo;
+        secondsAgos[1] = 0;
+        uint216[] memory lnImpliedRateCumulatives = IPMarket(market).observe(secondsAgos);
+        return
+            (uint256(lnImpliedRateCumulatives[1] - lnImpliedRateCumulatives[0]) / secondsAgo)
+                .Uint96();
+    }
+}

package/contracts/core/actions/ActionSwapPT.sol

@@ -0,0 +1,199 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "./base/ActionBaseMintRedeem.sol";
+import "../../interfaces/IPActionSwapPT.sol";
+import "../../interfaces/IPMarket.sol";
+
+contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
+    using MarketMathCore for MarketState;
+    using MarketApproxLib for MarketState;
+    using Math for uint256;
+    using Math for int256;
+    using SafeERC20 for IERC20;
+    using PYIndexLib for IPYieldToken;
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variables
+    constructor(address _kyberSwapRouter)
+        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    {}
+
+    function swapExactPtForScy(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        uint256 minScyOut
+    ) external returns (uint256 netScyOut) {
+        (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+        IERC20(address(PT)).safeTransferFrom(msg.sender, market, exactPtIn);
+
+        (netScyOut, ) = IPMarket(market).swapExactPtForScy(receiver, exactPtIn, EMPTY_BYTES);
+
+        require(netScyOut >= minScyOut, "insufficient SCY out");
+
+        emit SwapPtAndScy(msg.sender, market, receiver, exactPtIn.neg(), netScyOut.Int());
+    }
+
+    /**
+     * @notice Note that the amount of SCY out will be a bit more than `exactScyOut`, since an approximation is used. It's
+        guaranteed that the `netScyOut` is at least `exactScyOut`
+     */
+    function swapPtForExactScy(
+        address receiver,
+        address market,
+        uint256 exactScyOut,
+        uint256 maxPtIn,
+        ApproxParams calldata guessPtIn
+    ) external returns (uint256 netPtIn) {
+        MarketState memory state = IPMarket(market).readState();
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+
+        (netPtIn, , ) = state.approxSwapPtForExactScy(
+            YT.newIndex(),
+            exactScyOut,
+            block.timestamp,
+            guessPtIn
+        );
+        require(netPtIn <= maxPtIn, "exceed limit PT in");
+
+        IERC20(PT).safeTransferFrom(msg.sender, market, netPtIn);
+
+        (uint256 netScyOut, ) = IPMarket(market).swapExactPtForScy(receiver, netPtIn, EMPTY_BYTES);
+
+        // fail-safe
+        require(netScyOut >= exactScyOut, "FS insufficient SCY out");
+
+        emit SwapPtAndScy(msg.sender, market, receiver, netPtIn.neg(), exactScyOut.Int());
+    }
+
+    function swapScyForExactPt(
+        address receiver,
+        address market,
+        uint256 exactPtOut,
+        uint256 maxScyIn
+    ) external returns (uint256 netScyIn) {
+        MarketState memory state = IPMarket(market).readState();
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        (netScyIn, ) = state.swapScyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
+
+        require(netScyIn <= maxScyIn, "exceed limit SCY in");
+
+        IERC20(SCY).safeTransferFrom(msg.sender, market, netScyIn);
+
+        IPMarket(market).swapScyForExactPt(receiver, exactPtOut, EMPTY_BYTES); // ignore return
+
+        // no fail-safe since exactly netScyIn will go into the market
+        emit SwapPtAndScy(msg.sender, market, receiver, exactPtOut.Int(), netScyIn.neg());
+    }
+
+    function swapExactScyForPt(
+        address receiver,
+        address market,
+        uint256 exactScyIn,
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut
+    ) external returns (uint256 netPtOut) {
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        IERC20(SCY).safeTransferFrom(msg.sender, market, exactScyIn);
+
+        netPtOut = _swapExactScyForPt(receiver, market, YT, exactScyIn, minPtOut, guessPtOut);
+
+        emit SwapPtAndScy(msg.sender, market, receiver, netPtOut.Int(), exactScyIn.neg());
+    }
+
+    /**
+     * @notice swap from any ERC20 tokens, through Uniswap's forks, to get baseTokens to make SCY, then swap
+        from SCY to PT
+     * @dev simply a combination of _mintScyFromToken & _swapExactScyForPt
+     */
+    function swapExactTokenForPt(
+        address receiver,
+        address market,
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netPtOut) {
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        // all output SCY is transferred directly to the market
+        uint256 netScyUseToBuyPt = _mintScyFromToken(address(market), address(SCY), 1, input);
+
+        // SCY is already in the market, hence doPull = false
+        netPtOut = _swapExactScyForPt(
+            receiver,
+            market,
+            YT,
+            netScyUseToBuyPt,
+            minPtOut,
+            guessPtOut
+        );
+
+        emit SwapPtAndToken(
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            netPtOut.Int(),
+            input.netTokenIn.neg()
+        );
+    }
+
+    /**
+     * @notice swap from PT to SCY, then redeem SCY to baseToken & swap through Uniswap's forks to get tokenOut
+     * @dev simply a combination of _swapExactPtForScy & _redeemScyToToken
+     */
+    function swapExactPtForToken(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+
+        IERC20(address(PT)).safeTransferFrom(msg.sender, market, exactPtIn);
+
+        // all output SCY is directly transferred to the SCY contract
+        (uint256 netScyReceived, ) = IPMarket(market).swapExactPtForScy(
+            address(SCY),
+            exactPtIn,
+            EMPTY_BYTES
+        );
+
+        // since all SCY is already at the SCY contract, doPull = false
+        netTokenOut = _redeemScyToToken(receiver, address(SCY), netScyReceived, output, false);
+
+        emit SwapPtAndToken(
+            msg.sender,
+            market,
+            output.tokenOut,
+            receiver,
+            exactPtIn.neg(),
+            netTokenOut.Int()
+        );
+    }
+
+    function _swapExactScyForPt(
+        address receiver,
+        address market,
+        IPYieldToken YT,
+        uint256 exactScyIn,
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut
+    ) internal returns (uint256 netPtOut) {
+        MarketState memory state = IPMarket(market).readState();
+
+        (netPtOut, , ) = state.approxSwapExactScyForPt(
+            YT.newIndex(),
+            exactScyIn,
+            block.timestamp,
+            guessPtOut
+        );
+
+        require(netPtOut >= minPtOut, "insufficient PT out");
+
+        IPMarket(market).swapScyForExactPt(receiver, netPtOut, EMPTY_BYTES); // ignore return
+        // no fail-safe since exactly netPtOut >= minPtOut will be out
+    }
+}

package/contracts/core/actions/{base/ActionSCYAndYTBase.sol → ActionSwapYT.sol}

@@ -1,15 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 
-import "../../../interfaces/IPMarketFactory.sol";
-import "../../../interfaces/IPMarket.sol";
-import "../../../libraries/SCY/SCYUtils.sol";
-import "../../../libraries/math/MarketApproxLib.sol";
-import "./ActionSCYAndPYBase.sol";
-import "./CallbackHelper.sol";
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
+import "./base/ActionBaseMintRedeem.sol";
+import "./base/CallbackHelper.sol";
+import "../../interfaces/IPActionSwapYT.sol";
+import "../../interfaces/IPMarket.sol";
+
+contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     using Math for uint256;
     using Math for int256;
     using MarketMathCore for MarketState;
@@ -18,6 +15,11 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
     using SafeERC20 for IPYieldToken;
     using PYIndexLib for IPYieldToken;
 
+    /// @dev since this contract will be proxied, it must not contains non-immutable variables
+    constructor(address _kyberSwapRouter)
+        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    {}
+
     /**
     * @notice swap exact SCY to YT with the help of flashswaps & YT tokenization / redemption
     * @dev inner working of this function:
@@ -28,36 +30,20 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         transferred to the receiver
     * @dev this function works in conjunction with ActionCallback
      */
-    function _swapExactScyForYt(
+    function swapExactScyForYt(
         address receiver,
         address market,
         uint256 exactScyIn,
         uint256 minYtOut,
-        ApproxParams memory guessYtOut,
-        bool doPull
-    ) internal returns (uint256 netYtOut) {
+        ApproxParams memory guessYtOut
+    ) external returns (uint256 netYtOut) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
-        MarketState memory state = IPMarket(market).readState(false);
-
-        (netYtOut, , ) = state.approxSwapExactScyForYt(
-            YT.newIndex(),
-            exactScyIn,
-            block.timestamp,
-            guessYtOut
-        );
 
-        // early-check
-        require(netYtOut >= minYtOut, "insufficient YT out");
+        SCY.safeTransferFrom(msg.sender, address(YT), exactScyIn);
 
-        if (doPull) {
-            SCY.safeTransferFrom(msg.sender, address(YT), exactScyIn);
-        }
+        _swapExactScyForYt(receiver, market, YT, exactScyIn, minYtOut, guessYtOut);
 
-        IPMarket(market).swapExactPtForScy(
-            address(YT),
-            netYtOut, // exactPtIn = netYtOut
-            _encodeSwapExactScyForYt(receiver, minYtOut)
-        );
+        emit SwapYtAndScy(msg.sender, market, receiver, netYtOut.Int(), exactScyIn.neg());
     }
 
     /**
@@ -70,28 +56,19 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         the rest is transferred to the `receiver`
     * @dev this function works in conjunction with ActionCallback
      */
-    function _swapExactYtForScy(
+    function swapExactYtForScy(
         address receiver,
         address market,
         uint256 exactYtIn,
-        uint256 minScyOut,
-        bool doPull
-    ) internal returns (uint256 netScyOut) {
+        uint256 minScyOut
+    ) external returns (uint256 netScyOut) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        if (doPull) {
-            YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
-        }
-
-        uint256 preScyBalance = SCY.balanceOf(receiver);
+        YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
 
-        IPMarket(market).swapScyForExactPt(
-            address(YT),
-            exactYtIn, // exactPtOut = exactYtIn
-            _encodeSwapYtForScy(receiver, minScyOut)
-        ); // ignore return
+        netScyOut = _swapExactYtForScy(receiver, market, SCY, YT, exactYtIn, minScyOut);
 
-        netScyOut = SCY.balanceOf(receiver) - preScyBalance;
+        emit SwapYtAndScy(msg.sender, market, receiver, exactYtIn.neg(), netScyOut.Int());
     }
 
     /**
@@ -103,12 +80,12 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         while YT is transferred to the user
     * @dev this function works in conjunction with ActionCallback
      */
-    function _swapScyForExactYt(
+    function swapScyForExactYt(
         address receiver,
         address market,
         uint256 exactYtOut,
         uint256 maxScyIn
-    ) internal returns (uint256 netScyIn) {
+    ) external returns (uint256 netScyIn) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         uint256 preScyBalance = SCY.balanceOf(msg.sender);
@@ -120,6 +97,8 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         );
 
         netScyIn = preScyBalance - SCY.balanceOf(msg.sender);
+
+        emit SwapYtAndScy(msg.sender, market, receiver, exactYtOut.Int(), netScyIn.neg());
     }
 
     /**
@@ -132,15 +111,14 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         transferred to `receiver`
     * @dev this function works in conjunction with ActionCallback
      */
-    function _swapYtForExactScy(
+    function swapYtForExactScy(
         address receiver,
         address market,
         uint256 exactScyOut,
         uint256 maxYtIn,
-        ApproxParams memory guessYtIn,
-        bool doPull
-    ) internal returns (uint256 netYtIn) {
-        MarketState memory state = IPMarket(market).readState(false);
+        ApproxParams memory guessYtIn
+    ) external returns (uint256 netYtIn) {
+        MarketState memory state = IPMarket(market).readState();
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         (netYtIn, , ) = state.approxSwapYtForExactScy(
@@ -152,28 +130,24 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
 
         require(netYtIn <= maxYtIn, "exceed YT in limit");
 
-        if (doPull) {
-            YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
-        }
+        YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
 
         IPMarket(market).swapScyForExactPt(
             address(YT),
             netYtIn, // exactPtOut = netYtIn
             _encodeSwapYtForScy(receiver, exactScyOut)
         ); // ignore return
+
+        emit SwapYtAndScy(msg.sender, market, receiver, netYtIn.neg(), exactScyOut.Int());
     }
 
-    /**
-     * @notice swap any ERC20 tokens, through Uniswap's forks, to baseToken of the corresponding SCY of YT. These SCY is then
-        used to swap to YT. Please refer to swapExactScyForYt for more details.
-     */
-    function _swapExactTokenForYt(
+    function swapExactTokenForYt(
         address receiver,
         address market,
         uint256 minYtOut,
         ApproxParams memory guessYtOut,
         TokenInput calldata input
-    ) internal returns (uint256 netYtOut) {
+    ) external payable returns (uint256 netYtOut) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         uint256 netScyUsedToBuyYT = _mintScyFromToken(address(YT), address(SCY), 1, input);
@@ -181,28 +155,89 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         netYtOut = _swapExactScyForYt(
             receiver,
             market,
+            YT,
             netScyUsedToBuyYT,
             minYtOut,
-            guessYtOut,
-            false
+            guessYtOut
+        );
+
+        emit SwapYtAndToken(
+            msg.sender,
+            market,
+            receiver,
+            input.tokenIn,
+            netYtOut.Int(),
+            input.netTokenIn.neg()
         );
     }
 
-    /**
-     * @notice swap YT to SCY (using `swapExactYtForScy` logic), then redeem SCY to baseToken & swap baseToken to token
-        through Uniswap's forks
-     */
-    function _swapExactYtForToken(
+    function swapExactYtForToken(
         address receiver,
         address market,
         uint256 netYtIn,
-        TokenOutput calldata output,
-        bool doPull
-    ) internal returns (uint256 netTokenOut) {
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        uint256 netScyOut = _swapExactYtForScy(address(SCY), market, netYtIn, 1, doPull);
+        YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
+
+        uint256 netScyOut = _swapExactYtForScy(address(SCY), market, SCY, YT, netYtIn, 1);
 
         netTokenOut = _redeemScyToToken(receiver, address(SCY), netScyOut, output, false);
+
+        emit SwapYtAndToken(
+            msg.sender,
+            market,
+            receiver,
+            output.tokenOut,
+            netYtIn.neg(),
+            netTokenOut.Int()
+        );
+    }
+
+    function _swapExactScyForYt(
+        address receiver,
+        address market,
+        IPYieldToken YT,
+        uint256 exactScyIn,
+        uint256 minYtOut,
+        ApproxParams memory guessYtOut
+    ) internal returns (uint256 netYtOut) {
+        MarketState memory state = IPMarket(market).readState();
+
+        (netYtOut, , ) = state.approxSwapExactScyForYt(
+            YT.newIndex(),
+            exactScyIn,
+            block.timestamp,
+            guessYtOut
+        );
+
+        // early-check
+        require(netYtOut >= minYtOut, "insufficient YT out");
+
+        IPMarket(market).swapExactPtForScy(
+            address(YT),
+            netYtOut, // exactPtIn = netYtOut
+            _encodeSwapExactScyForYt(receiver, minYtOut)
+        );
+    }
+
+    function _swapExactYtForScy(
+        address receiver,
+        address market,
+        ISuperComposableYield SCY,
+        IPYieldToken YT,
+        uint256 exactYtIn,
+        uint256 minScyOut
+    ) internal returns (uint256 netScyOut) {
+        uint256 preScyBalance = SCY.balanceOf(receiver);
+
+        IPMarket(market).swapScyForExactPt(
+            address(YT),
+            exactYtIn, // exactPtOut = exactYtIn
+            _encodeSwapYtForScy(receiver, minScyOut)
+        ); // ignore return
+
+        netScyOut = SCY.balanceOf(receiver) - preScyBalance;
     }
 }

package/contracts/core/actions/base/{ActionSCYAndPYBase.sol → ActionBaseMintRedeem.sol}

@@ -1,23 +1,20 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "../../../libraries/kyberswap/KyberSwapHelper.sol";
-import "../../../libraries/helpers/MiniHelpers.sol";
 import "../../../libraries/helpers/TokenHelper.sol";
 import "../../../interfaces/ISuperComposableYield.sol";
 import "../../../interfaces/IPYieldToken.sol";
 
 // solhint-disable no-empty-blocks
-abstract contract ActionSCYAndPYBase is TokenHelper, KyberSwapHelper {
+abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
     using SafeERC20 for IERC20;
 
+    bytes internal constant EMPTY_BYTES = abi.encode();
+
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
     constructor(address _kyberSwapRouter) KyberSwapHelper(_kyberSwapRouter) {}
 
-    /// @dev for Path. If no swap is needed, path = [token]
-    /// else, path = [inputToken, token0, token1, ...., outputToken]
-
     /**
      * @notice swap token to baseToken through Uniswap's forks & use it to mint SCY
      */
@@ -33,10 +30,14 @@ abstract contract ActionSCYAndPYBase is TokenHelper, KyberSwapHelper {
         }
 
         _safeApproveInf(input.tokenMintScy, SCY);
-        netScyOut = ISuperComposableYield(SCY).deposit(
+
+        uint256 tokenMintScyBal = _selfBalance(input.tokenMintScy);
+        uint256 nativeAmountToAttach = input.tokenMintScy == NATIVE ? tokenMintScyBal : 0;
+
+        netScyOut = ISuperComposableYield(SCY).deposit{ value: nativeAmountToAttach }(
             receiver,
             input.tokenMintScy,
-            _selfBalance(input.tokenMintScy),
+            tokenMintScyBal,
             minScyOut
         );
     }

package/contracts/interfaces/IBenQiComptroller.sol

@@ -32,4 +32,6 @@ interface IBenQiComptroller {
     ) external;
 
     function qiAddress() external view returns (address);
+
+    function rewardAccrued(uint8 rewardType, address user) external view returns (uint256);
 }