@pendle/core-v2 0.7.1-beta-2 → 0.8.0-beta-2

package/contracts/core/actions/ActionCore.sol

@@ -32,7 +32,15 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
             uint256 ptUsed
         )
     {
-        return _addLiquidity(receiver, market, scyDesired, ptDesired, minLpOut, true);
+        (netLpOut, scyUsed, ptUsed) = _addLiquidity(
+            receiver,
+            market,
+            scyDesired,
+            ptDesired,
+            minLpOut,
+            true
+        );
+        emit AddLiquidity(msg.sender, market, receiver, scyUsed, ptUsed, netLpOut);
     }
 
     /// @dev refer to the internal function
@@ -43,7 +51,15 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         uint256 scyOutMin,
         uint256 ptOutMin
     ) external returns (uint256 netScyOut, uint256 netPtOut) {
-        return _removeLiquidity(receiver, market, lpToRemove, scyOutMin, ptOutMin, true);
+        (netScyOut, netPtOut) = _removeLiquidity(
+            receiver,
+            market,
+            lpToRemove,
+            scyOutMin,
+            ptOutMin,
+            true
+        );
+        emit RemoveLiquidity(msg.sender, market, receiver, lpToRemove, netPtOut, netScyOut);
     }
 
     /// @dev refer to the internal function
@@ -53,7 +69,8 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         uint256 exactPtIn,
         uint256 minScyOut
     ) external returns (uint256 netScyOut) {
-        return _swapExactPtForScy(receiver, market, exactPtIn, minScyOut, true);
+        netScyOut = _swapExactPtForScy(receiver, market, exactPtIn, minScyOut, true);
+        emit SwapPtAndScy(msg.sender, market, receiver, exactPtIn.neg(), netScyOut.Int());
     }
 
     /// @dev refer to the internal function
@@ -64,7 +81,8 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         uint256 maxPtIn,
         ApproxParams memory guessPtIn
     ) external returns (uint256 netPtIn) {
-        return _swapPtForExactScy(receiver, market, exactScyOut, maxPtIn, guessPtIn, true);
+        netPtIn = _swapPtForExactScy(receiver, market, exactScyOut, maxPtIn, guessPtIn, true);
+        emit SwapPtAndScy(msg.sender, market, receiver, netPtIn.neg(), exactScyOut.Int());
     }
 
     /// @dev refer to the internal function
@@ -74,7 +92,8 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         uint256 exactPtOut,
         uint256 maxScyIn
     ) external returns (uint256 netScyIn) {
-        return _swapScyForExactPt(receiver, market, exactPtOut, maxScyIn, true);
+        netScyIn = _swapScyForExactPt(receiver, market, exactPtOut, maxScyIn, true);
+        emit SwapPtAndScy(msg.sender, market, receiver, exactPtOut.Int(), netScyIn.neg());
     }
 
     /// @dev refer to the internal function
@@ -85,7 +104,8 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         uint256 minPtOut,
         ApproxParams memory guessPtOut
     ) external returns (uint256 netPtOut) {
-        return _swapExactScyForPt(receiver, market, exactScyIn, minPtOut, guessPtOut, true);
+        netPtOut = _swapExactScyForPt(receiver, market, exactScyIn, minPtOut, guessPtOut, true);
+        emit SwapPtAndScy(msg.sender, market, receiver, netPtOut.Int(), exactScyIn.neg());
     }
 
     /// @dev refer to the internal function
@@ -107,7 +127,15 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         uint256 minRawTokenOut,
         address[] memory path
     ) external returns (uint256 netRawTokenOut) {
-        return _redeemScyToRawToken(receiver, SCY, netScyIn, minRawTokenOut, path, true);
+        netRawTokenOut = _redeemScyToRawToken(receiver, SCY, netScyIn, minRawTokenOut, path, true);
+        emit RedeemScyToRawToken(
+            msg.sender,
+            receiver,
+            SCY,
+            netScyIn,
+            path[path.length - 1],
+            netRawTokenOut
+        );
     }
 
     /// @dev refer to the internal function
@@ -118,7 +146,8 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         uint256 minPyOut,
         address[] calldata path
     ) external returns (uint256 netPyOut) {
-        return _mintPyFromRawToken(receiver, YT, netRawTokenIn, minPyOut, path, true);
+        netPyOut = _mintPyFromRawToken(receiver, YT, netRawTokenIn, minPyOut, path, true);
+        emit MintPyFromRawToken(msg.sender, receiver, YT, path[0], netRawTokenIn, netPyOut);
     }
 
     /// @dev refer to the internal function
@@ -129,7 +158,15 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         uint256 minRawTokenOut,
         address[] memory path
     ) external returns (uint256 netRawTokenOut) {
-        return _redeemPyToRawToken(receiver, YT, netPyIn, minRawTokenOut, path, true);
+        netRawTokenOut = _redeemPyToRawToken(receiver, YT, netPyIn, minRawTokenOut, path, true);
+        emit RedeemPyToRawToken(
+            msg.sender,
+            receiver,
+            YT,
+            netPyIn,
+            path[path.length - 1],
+            netRawTokenOut
+        );
     }
 
     /// @dev refer to the internal function
@@ -141,16 +178,24 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address[] calldata path,
         ApproxParams memory guessPtOut
     ) external returns (uint256 netPtOut) {
-        return
-            _swapExactRawTokenForPt(
-                receiver,
-                market,
-                exactRawTokenIn,
-                minPtOut,
-                path,
-                guessPtOut,
-                true
-            );
+        netPtOut = _swapExactRawTokenForPt(
+            receiver,
+            market,
+            exactRawTokenIn,
+            minPtOut,
+            path,
+            guessPtOut,
+            true
+        );
+
+        emit SwapPtAndRawToken(
+            msg.sender,
+            market,
+            path[0],
+            receiver,
+            netPtOut.Int(),
+            exactRawTokenIn.neg()
+        );
     }
 
     /// @dev refer to the internal function
@@ -161,10 +206,25 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         uint256 minRawTokenOut,
         address[] calldata path
     ) external returns (uint256 netRawTokenOut) {
-        return _swapExactPtForRawToken(receiver, market, exactPtIn, minRawTokenOut, path, true);
+        netRawTokenOut = _swapExactPtForRawToken(
+            receiver,
+            market,
+            exactPtIn,
+            minRawTokenOut,
+            path,
+            true
+        );
+        emit SwapPtAndRawToken(
+            msg.sender,
+            market,
+            path[path.length - 1],
+            receiver,
+            exactPtIn.neg(),
+            netRawTokenOut.Int()
+        );
     }
 
-    function redeemDueIncome(
+    function redeemDueInterestAndRewards(
         address user,
         address[] calldata scys,
         address[] calldata yts,
@@ -187,7 +247,9 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         ytRewards = new uint256[][](yts.length);
         for (uint256 i = 0; i < yts.length; ++i) {
             (ytInterests[i], ytRewards[i]) = IPYieldToken(yts[i]).redeemDueInterestAndRewards(
-                user
+                user,
+                true,
+                true
             );
         }
 

package/contracts/core/actions/ActionYT.sol

@@ -26,7 +26,8 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
         uint256 exactYtIn,
         uint256 minScyOut
     ) external returns (uint256 netScyOut) {
-        return _swapExactYtForScy(receiver, market, exactYtIn, minScyOut, true);
+        netScyOut = _swapExactYtForScy(receiver, market, exactYtIn, minScyOut, true);
+        emit SwapYTAndSCY(receiver, market, exactYtIn.neg(), netScyOut.Int());
     }
 
     /// @dev refer to the internal function
@@ -36,7 +37,8 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
         uint256 exactYtOut,
         uint256 maxScyIn
     ) external returns (uint256 netScyIn) {
-        return _swapScyForExactYt(receiver, market, exactYtOut, maxScyIn);
+        netScyIn = _swapScyForExactYt(receiver, market, exactYtOut, maxScyIn);
+        emit SwapYTAndSCY(receiver, market, exactYtOut.Int(), netScyIn.neg());
     }
 
     /// @dev refer to the internal function
@@ -47,7 +49,8 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
         uint256 minYtOut,
         ApproxParams memory guessYtOut
     ) external returns (uint256 netYtOut) {
-        return _swapExactScyForYt(receiver, market, exactScyIn, minYtOut, guessYtOut, true);
+        netYtOut = _swapExactScyForYt(receiver, market, exactScyIn, minYtOut, guessYtOut, true);
+        emit SwapYTAndSCY(receiver, market, netYtOut.Int(), exactScyIn.neg());
     }
 
     /// @dev refer to the internal function
@@ -58,7 +61,8 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
         uint256 maxYtIn,
         ApproxParams memory guessYtIn
     ) external returns (uint256 netYtIn) {
-        return _swapYtForExactScy(receiver, market, exactScyOut, maxYtIn, guessYtIn, true);
+        netYtIn = _swapYtForExactScy(receiver, market, exactScyOut, maxYtIn, guessYtIn, true);
+        emit SwapYTAndSCY(receiver, market, netYtIn.neg(), exactScyOut.Int());
     }
 
     /// @dev refer to the internal function
@@ -70,16 +74,16 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
         address[] calldata path,
         ApproxParams memory guessYtOut
     ) external returns (uint256 netYtOut) {
-        return
-            _swapExactRawTokenForYt(
-                receiver,
-                market,
-                exactRawTokenIn,
-                minYtOut,
-                path,
-                guessYtOut,
-                true
-            );
+        netYtOut = _swapExactRawTokenForYt(
+            receiver,
+            market,
+            exactRawTokenIn,
+            minYtOut,
+            path,
+            guessYtOut,
+            true
+        );
+        emit SwapYTAndRawToken(receiver, market, path[0], netYtOut.Int(), exactRawTokenIn.neg());
     }
 
     /// @dev refer to the internal function
@@ -90,6 +94,20 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
         uint256 minRawTokenOut,
         address[] calldata path
     ) external returns (uint256 netRawTokenOut) {
-        return _swapExactYtForRawToken(receiver, market, exactYtIn, minRawTokenOut, path, true);
+        netRawTokenOut = _swapExactYtForRawToken(
+            receiver,
+            market,
+            exactYtIn,
+            minRawTokenOut,
+            path,
+            true
+        );
+        emit SwapYTAndRawToken(
+            receiver,
+            market,
+            path[path.length - 1],
+            exactYtIn.neg(),
+            netRawTokenOut.Int()
+        );
     }
 }

package/contracts/core/actions/base/ActionSCYAndPTBase.sol

@@ -3,7 +3,6 @@ pragma solidity 0.8.15;
 
 import "../../../interfaces/IPMarketFactory.sol";
 import "../../../interfaces/IPMarket.sol";
-import "../../../interfaces/IPMarketAddRemoveCallback.sol";
 import "../../../interfaces/IPMarketSwapCallback.sol";
 import "../../../libraries/math/MarketApproxLib.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
@@ -46,7 +45,7 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
             SCY.newIndex(),
             scyDesired,
             ptDesired,
-            false
+            block.timestamp
         );
 
         // early-check
@@ -57,12 +56,7 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
             IERC20(PT).safeTransferFrom(msg.sender, market, ptUsed);
         }
 
-        (netLpOut, , ) = IPMarket(market).addLiquidity(
-            receiver,
-            ptDesired,
-            scyDesired,
-            EMPTY_BYTES
-        );
+        netLpOut = IPMarket(market).mint(receiver);
 
         // fail-safe
         require(netLpOut >= minLpOut, "FS insufficient lp out");
@@ -78,7 +72,7 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
     ) internal returns (uint256 netScyOut, uint256 netPtOut) {
         MarketState memory state = IPMarket(market).readState(false);
 
-        (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove, false);
+        (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove);
 
         // early-check
         require(netScyOut >= scyOutMin, "insufficient SCY out");
@@ -88,12 +82,7 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
             IERC20(market).safeTransferFrom(msg.sender, market, lpToRemove);
         }
 
-        (netScyOut, netPtOut) = IPMarket(market).removeLiquidity(
-            receiver,
-            receiver,
-            lpToRemove,
-            EMPTY_BYTES
-        );
+        (netScyOut, netPtOut) = IPMarket(market).burn(receiver, receiver);
 
         // fail-safe
         require(netScyOut >= scyOutMin, "FS insufficient SCY out");
@@ -132,7 +121,7 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
         MarketState memory state = IPMarket(market).readState(false);
         (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
-        (netPtIn, ) = state.approxSwapPtForExactScy(
+        (netPtIn, , ) = state.approxSwapPtForExactScy(
             SCY.newIndex(),
             exactScyOut,
             block.timestamp,
@@ -188,7 +177,7 @@ abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
         MarketState memory state = IPMarket(market).readState(false);
         (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
-        (netPtOut, ) = state.approxSwapExactScyForPt(
+        (netPtOut, , ) = state.approxSwapExactScyForPt(
             SCY.newIndex(),
             exactScyIn,
             block.timestamp,

package/contracts/core/actions/base/ActionSCYAndPYBase.sol

@@ -4,45 +4,14 @@ pragma solidity 0.8.15;
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "../../../libraries/traderjoe/PendleJoeSwapHelperUpg.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 PendleJoeSwapHelperUpg {
+abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg, TokenHelper {
     using SafeERC20 for IERC20;
 
-    event MintScyFromRawToken(
-        address indexed user,
-        address indexed rawTokenIn,
-        uint256 netRawTokenIn,
-        address indexed SCY,
-        uint256 netScyOut
-    );
-
-    event RedeemScyToRawToken(
-        address indexed user,
-        address indexed SCY,
-        uint256 netScyIn,
-        address indexed rawTokenOut,
-        uint256 netRawTokenOut
-    );
-
-    event MintPyFromRawToken(
-        address indexed user,
-        address indexed rawTokenIn,
-        uint256 netRawTokenIn,
-        address indexed YT,
-        uint256 netPyOut
-    );
-
-    event RedeemPyToRawToken(
-        address indexed user,
-        address indexed YT,
-        uint256 netPyIn,
-        address indexed rawTokenOut,
-        uint256 netRawTokenOut
-    );
-
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
     constructor(address _joeFactory) PendleJoeSwapHelperUpg(_joeFactory) {}
 
@@ -60,18 +29,27 @@ abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg {
         address[] calldata path,
         bool doPull
     ) internal returns (uint256 netScyOut) {
-        if (doPull) {
-            if (path.length == 1) {
-                IERC20(path[0]).safeTransferFrom(msg.sender, SCY, netRawTokenIn);
-            } else {
+        uint256 amountBaseToken;
+        if (path.length == 1) {
+            if (doPull) {
+                IERC20(path[0]).safeTransferFrom(msg.sender, address(this), netRawTokenIn);
+            }
+            amountBaseToken = netRawTokenIn;
+        } else {
+            if (doPull) {
                 IERC20(path[0]).safeTransferFrom(msg.sender, _getFirstPair(path), netRawTokenIn);
-                _swapExactIn(path, netRawTokenIn, SCY);
             }
+            amountBaseToken = _swapExactIn(path, netRawTokenIn, address(this));
         }
 
         address baseToken = path[path.length - 1];
-        netScyOut = ISuperComposableYield(SCY).deposit(receiver, baseToken, 0, minScyOut);
-        emit MintScyFromRawToken(msg.sender, path[0], netRawTokenIn, SCY, netScyOut);
+        IERC20(baseToken).approve(SCY, amountBaseToken);
+        netScyOut = ISuperComposableYield(SCY).deposit(
+            receiver,
+            baseToken,
+            amountBaseToken,
+            minScyOut
+        );
     }
 
     /**
@@ -91,24 +69,20 @@ abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg {
 
         address baseToken = path[0];
         if (path.length == 1) {
-            netRawTokenOut = ISuperComposableYield(SCY).redeem(
+            netRawTokenOut = ISuperComposableYield(SCY).redeemAfterTransfer(
                 receiver,
-                0,
                 baseToken,
                 minRawTokenOut
             );
         } else {
-            uint256 netBaseTokenOut = ISuperComposableYield(SCY).redeem(
+            uint256 netBaseTokenOut = ISuperComposableYield(SCY).redeemAfterTransfer(
                 _getFirstPair(path),
-                0,
                 baseToken,
                 1
             );
             netRawTokenOut = _swapExactIn(path, netBaseTokenOut, receiver);
             require(netRawTokenOut >= minRawTokenOut, "insufficient out");
         }
-
-        emit RedeemScyToRawToken(msg.sender, SCY, netScyIn, path[path.length - 1], netRawTokenOut);
     }
 
     /**
@@ -128,8 +102,6 @@ abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg {
 
         netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
         require(netPyOut >= minPyOut, "insufficient PY out");
-
-        emit MintPyFromRawToken(msg.sender, path[0], netRawTokenIn, YT, netPyOut);
     }
 
     /**
@@ -156,7 +128,5 @@ abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg {
         IPYieldToken(YT).redeemPY(SCY); // ignore return
 
         netRawTokenOut = _redeemScyToRawToken(receiver, SCY, 0, minRawTokenOut, path, false);
-
-        emit RedeemPyToRawToken(msg.sender, YT, netPyIn, path[path.length - 1], netRawTokenOut);
     }
 }

package/contracts/core/actions/base/ActionSCYAndYTBase.sol

@@ -18,8 +18,6 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
     using SafeERC20 for IPYieldToken;
     using SCYIndexLib for ISuperComposableYield;
 
-    event SwapYTAndSCY(address indexed user, int256 ytToAccount, int256 scyToAccount);
-
     /**
     * @notice swap exact SCY to YT with the help of flashswaps & YT tokenization / redemption
     * @dev inner working of this function:
@@ -41,7 +39,7 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
         MarketState memory state = IPMarket(market).readState(false);
 
-        (netYtOut, ) = state.approxSwapExactScyForYt(
+        (netYtOut, , ) = state.approxSwapExactScyForYt(
             SCY.newIndex(),
             exactScyIn,
             block.timestamp,
@@ -60,8 +58,6 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
             netYtOut, // exactPtIn = netYtOut
             _encodeSwapExactScyForYt(receiver, minYtOut)
         );
-
-        emit SwapYTAndSCY(receiver, netYtOut.Int(), exactScyIn.neg());
     }
 
     /**
@@ -96,8 +92,6 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         ); // ignore return
 
         netScyOut = SCY.balanceOf(receiver) - preScyBalance;
-
-        emit SwapYTAndSCY(receiver, exactYtIn.neg(), netScyOut.Int());
     }
 
     /**
@@ -115,15 +109,16 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         uint256 exactYtOut,
         uint256 maxScyIn
     ) internal returns (uint256 netScyIn) {
-        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 preScyBalance = SCY.balanceOf(msg.sender);
 
         IPMarket(market).swapExactPtForScy(
             address(YT),
             exactYtOut, // exactPtIn = exactYtOut
             _encodeSwapScyForExactYt(msg.sender, receiver, maxScyIn)
         );
-
-        emit SwapYTAndSCY(receiver, exactYtOut.Int(), netScyIn.neg());
+        netScyIn = preScyBalance - SCY.balanceOf(msg.sender);
     }
 
     /**
@@ -147,7 +142,7 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
         MarketState memory state = IPMarket(market).readState(false);
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        (netYtIn, ) = state.approxSwapYtForExactScy(
+        (netYtIn, , ) = state.approxSwapYtForExactScy(
             SCY.newIndex(),
             exactScyOut,
             block.timestamp,
@@ -165,8 +160,6 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, CallbackHelper {
             netYtIn, // exactPtOut = netYtIn
             _encodeSwapYtForScy(receiver, exactScyOut)
         ); // ignore return
-
-        emit SwapYTAndSCY(receiver, netYtIn.neg(), exactScyOut.Int());
     }
 
     /**

package/contracts/interfaces/IPActionCore.sol

@@ -4,6 +4,77 @@ pragma solidity 0.8.15;
 import "../libraries/math/MarketApproxLib.sol";
 
 interface IPActionCore {
+    event AddLiquidity(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        uint256 scyUsed,
+        uint256 ptUsed,
+        uint256 lpOut
+    );
+
+    event RemoveLiquidity(
+        address indexed caller,
+        address indexed market,
+        address receiver,
+        uint256 lpIn,
+        uint256 amountPTOut,
+        uint256 amountSCYOut
+    );
+
+    event SwapPtAndScy(
+        address indexed caller,
+        address indexed market,
+        address indexed receiver,
+        int256 amountPtToAccount,
+        int256 amountScyToAccount
+    );
+
+    event SwapPtAndRawToken(
+        address indexed caller,
+        address indexed market,
+        address indexed rawToken,
+        address receiver,
+        int256 amountPtToAccount,
+        int256 amountRawTokenToAccount
+    );
+
+    event MintScyFromRawToken(
+        address indexed caller,
+        address indexed receiver,
+        address indexed SCY,
+        address rawTokenIn,
+        uint256 netRawTokenIn,
+        uint256 netScyOut
+    );
+
+    event RedeemScyToRawToken(
+        address indexed caller,
+        address indexed receiver,
+        address indexed SCY,
+        uint256 netScyIn,
+        address rawTokenOut,
+        uint256 netRawTokenOut
+    );
+
+    event MintPyFromRawToken(
+        address indexed caller,
+        address indexed receiver,
+        address indexed YT,
+        address rawTokenIn,
+        uint256 netRawTokenIn,
+        uint256 netPyOut
+    );
+
+    event RedeemPyToRawToken(
+        address indexed caller,
+        address indexed receiver,
+        address indexed YT,
+        uint256 netPyIn,
+        address rawTokenOut,
+        uint256 netRawTokenOut
+    );
+
     function addLiquidity(
         address receiver,
         address market,
@@ -105,7 +176,7 @@ interface IPActionCore {
         address[] calldata path
     ) external returns (uint256 netRawTokenOut);
 
-    function redeemDueIncome(
+    function redeemDueInterestAndRewards(
         address user,
         address[] calldata scys,
         address[] calldata yts,

package/contracts/interfaces/IPActionYT.sol

@@ -4,6 +4,21 @@ pragma solidity 0.8.15;
 import "../libraries/math/MarketApproxLib.sol";
 
 interface IPActionYT {
+    event SwapYTAndSCY(
+        address indexed user,
+        address indexed market,
+        int256 ytToAccount,
+        int256 scyToAccount
+    );
+
+    event SwapYTAndRawToken(
+        address indexed user,
+        address indexed market,
+        address indexed rawToken,
+        int256 ytToAccount,
+        int256 rawTokenToAccount
+    );
+
     function swapExactYtForScy(
         address receiver,
         address market,