@pendle/core-v2 0.5.1-beta-4 → 0.6.0

package/contracts/core/actions/base/{ActionSCYAndOTBase.sol → ActionSCYAndPTBase.sol}

@@ -9,7 +9,7 @@ import "../../../libraries/math/MarketApproxLib.sol";
 import "../../../libraries/math/MarketMathAux.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-abstract contract ActionSCYAndOTBase {
+abstract contract ActionSCYAndPTBase {
     using Math for uint256;
     using Math for int256;
     using MarketMathCore for MarketState;
@@ -20,18 +20,18 @@ abstract contract ActionSCYAndOTBase {
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
 
     /**
-     * @notice addLiquidity to the market, using both SCY & OT, the receiver will receive LP before
-     msg.sender is required to pay SCY & OT
+     * @notice addLiquidity to the market, using both SCY & PT, the receiver will receive LP before
+     msg.sender is required to pay SCY & PT
      * @dev inner working of this function:
      - market.addLiquidity is called
      - LP is minted to the receiver, and this router's addLiquidityCallback is invoked
-     - the router will transfer the necessary scy & ot from msg.sender to the market, and finish the callback
+     - the router will transfer the necessary scy & pt from msg.sender to the market, and finish the callback
      */
     function _addLiquidity(
         address receiver,
         address market,
         uint256 scyDesired,
-        uint256 otDesired,
+        uint256 ptDesired,
         uint256 minLpOut,
         bool doPull
     )
@@ -39,16 +39,16 @@ abstract contract ActionSCYAndOTBase {
         returns (
             uint256 netLpOut,
             uint256 scyUsed,
-            uint256 otUsed
+            uint256 ptUsed
         )
     {
-        (ISuperComposableYield SCY, IPOwnershipToken OT, ) = IPMarket(market).readTokens();
+        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         MarketState memory state = IPMarket(market).readState(false);
-        (, netLpOut, scyUsed, otUsed) = state.addLiquidity(
+        (, netLpOut, scyUsed, ptUsed) = state.addLiquidity(
             SCYIndexLib.newIndex(SCY),
             scyDesired,
-            otDesired,
+            ptDesired,
             false
         );
 
@@ -56,18 +56,18 @@ abstract contract ActionSCYAndOTBase {
 
         if (doPull) {
             IERC20(SCY).safeTransferFrom(msg.sender, market, scyUsed);
-            IERC20(OT).safeTransferFrom(msg.sender, market, otUsed);
+            IERC20(PT).safeTransferFrom(msg.sender, market, ptUsed);
         }
 
-        IPMarket(market).addLiquidity(receiver, otDesired, scyDesired, abi.encode());
+        IPMarket(market).addLiquidity(receiver, ptDesired, scyDesired, abi.encode()); // ignore return
     }
 
     /**
-     * @notice removeLiquidity from the market to receive both SCY & OT. The receiver will receive
-     SCY & OT before msg.sender is required to transfer in the necessary LP
+     * @notice removeLiquidity from the market to receive both SCY & PT. The receiver will receive
+     SCY & PT before msg.sender is required to transfer in the necessary LP
      * @dev inner working of this function:
      - market.removeLiquidity is called
-     - SCY & OT is transferred to the receiver, and the router's callback is invoked
+     - SCY & PT is transferred to the receiver, and the router's callback is invoked
      - the router will transfer the necessary LP from msg.sender to the market, and finish the callback
      */
     function _removeLiquidity(
@@ -75,45 +75,45 @@ abstract contract ActionSCYAndOTBase {
         address market,
         uint256 lpToRemove,
         uint256 scyOutMin,
-        uint256 otOutMin,
+        uint256 ptOutMin,
         bool doPull
-    ) internal returns (uint256 netScyOut, uint256 netOtOut) {
+    ) internal returns (uint256 netScyOut, uint256 netPtOut) {
         MarketState memory state = IPMarket(market).readState(false);
 
-        (netScyOut, netOtOut) = state.removeLiquidity(lpToRemove, false);
+        (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove, false);
         require(netScyOut >= scyOutMin, "insufficient scy out");
-        require(netOtOut >= otOutMin, "insufficient ot out");
+        require(netPtOut >= ptOutMin, "insufficient pt out");
 
         if (doPull) {
             IERC20(market).safeTransferFrom(msg.sender, market, lpToRemove);
         }
 
-        IPMarket(market).removeLiquidity(receiver, lpToRemove, abi.encode());
+        IPMarket(market).removeLiquidity(receiver, lpToRemove, abi.encode()); // ignore return
     }
 
     /**
-     * @notice swap exact OT for SCY, with receiver receiving SCY before msg.sender is required to
-     transfer the owed OT
+     * @notice swap exact PT for SCY, with receiver receiving SCY before msg.sender is required to
+     transfer the owed PT
      * @dev inner working of this function:
      - market.swap is called
      - SCY is transferred to the receiver, and the router's callback is invoked
-     - the router will transfer the necessary OT from msg.sender to the market, and finish the callback
+     - the router will transfer the necessary PT from msg.sender to the market, and finish the callback
      */
-    function _swapExactOtForScy(
+    function _swapExactPtForScy(
         address receiver,
         address market,
-        uint256 exactOtIn,
+        uint256 exactPtIn,
         uint256 minScyOut,
         bool doPull
     ) internal returns (uint256 netScyOut) {
         if (doPull) {
-            address OT = IPMarket(market).OT();
-            IERC20(OT).safeTransferFrom(msg.sender, market, exactOtIn);
+            address PT = IPMarket(market).PT();
+            IERC20(PT).safeTransferFrom(msg.sender, market, exactPtIn);
         }
 
-        (netScyOut, ) = IPMarket(market).swapExactOtForScy(
+        (netScyOut, ) = IPMarket(market).swapExactPtForScy(
             receiver,
-            exactOtIn,
+            exactPtIn,
             minScyOut,
             abi.encode()
         );
@@ -121,17 +121,23 @@ abstract contract ActionSCYAndOTBase {
         require(netScyOut >= minScyOut, "insufficient scy out");
     }
 
-    function _swapOtForExactScy(
+    /**
+     * @notice swap PT for exact SCY, with receiver receiving SCY before msg.sender is required to
+     transfer the owed PT
+     * @dev inner working of this function is similar to swapExactPtForScy
+     * @param approx params to approx. Guess params will be the min, max & offchain guess for netPtIn
+     */
+    function _swapPtForExactScy(
         address receiver,
         address market,
         uint256 exactScyOut,
         ApproxParams memory approx,
         bool doPull
-    ) internal returns (uint256 netOtIn) {
+    ) internal returns (uint256 netPtIn) {
         MarketState memory state = IPMarket(market).readState(false);
-        (ISuperComposableYield SCY, IPOwnershipToken OT, ) = IPMarket(market).readTokens();
+        (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
-        (netOtIn, ) = state.approxSwapOtForExactScy(
+        (netPtIn, ) = state.approxSwapPtForExactScy(
             SCYIndexLib.newIndex(SCY),
             exactScyOut,
             block.timestamp,
@@ -139,33 +145,33 @@ abstract contract ActionSCYAndOTBase {
         );
 
         if (doPull) {
-            IERC20(OT).safeTransferFrom(msg.sender, market, netOtIn);
+            IERC20(PT).safeTransferFrom(msg.sender, market, netPtIn);
         }
 
-        IPMarket(market).swapExactOtForScy(receiver, netOtIn, exactScyOut, abi.encode());
+        IPMarket(market).swapExactPtForScy(receiver, netPtIn, exactScyOut, abi.encode()); // ignore return
     }
 
     /**
-     * @notice swap SCY for exact OT, with receiver receiving OT before msg.sender is required to
+     * @notice swap SCY for exact PT, with receiver receiving PT before msg.sender is required to
      transfer the owed SCY
      * @dev inner working of this function:
      - market.swap is called
-     - OT is transferred to the receiver, and the router's callback is invoked
+     - PT is transferred to the receiver, and the router's callback is invoked
      - the router will transfer the necessary SCY from msg.sender to the market, and finish the callback
      */
-    function _swapScyForExactOt(
+    function _swapScyForExactPt(
         address receiver,
         address market,
-        uint256 exactOtOut,
+        uint256 exactPtOut,
         uint256 maxScyIn,
         bool doPull
     ) internal returns (uint256 netScyIn) {
         MarketState memory state = IPMarket(market).readState(false);
         address SCY = IPMarket(market).SCY();
 
-        (netScyIn, ) = state.swapScyForExactOt(
+        (netScyIn, ) = state.swapScyForExactPt(
             SCYIndexLib.newIndex(SCY),
-            exactOtOut,
+            exactPtOut,
             block.timestamp,
             false
         );
@@ -175,20 +181,28 @@ abstract contract ActionSCYAndOTBase {
             IERC20(SCY).safeTransferFrom(msg.sender, market, netScyIn);
         }
 
-        IPMarket(market).swapScyForExactOt(receiver, exactOtOut, maxScyIn, abi.encode());
+        IPMarket(market).swapScyForExactPt(receiver, exactPtOut, maxScyIn, abi.encode()); // ignore return
     }
 
-    function _swapExactScyForOt(
+    /**
+     * @dev swap exact amount of Scy to PT
+     * @dev inner working steps:
+       - The outcome amount of PT in is approximated
+       - market.swapExactPtToScy() is called, user will receive their PT
+       - The approximated amount of PT is transferred from msg.sender to market via router
+     * @param approx params to approx. Guess params will be the min, max & offchain guess for netPtOut
+     */
+    function _swapExactScyForPt(
         address receiver,
         address market,
         uint256 exactScyIn,
         ApproxParams memory approx,
         bool doPull
-    ) internal returns (uint256 netOtOut) {
+    ) internal returns (uint256 netPtOut) {
         MarketState memory state = IPMarket(market).readState(false);
         address SCY = IPMarket(market).SCY();
 
-        (netOtOut, ) = state.approxSwapExactScyForOt(
+        (netPtOut, ) = state.approxSwapExactScyForPt(
             SCYIndexLib.newIndex(SCY),
             exactScyIn,
             block.timestamp,
@@ -199,6 +213,6 @@ abstract contract ActionSCYAndOTBase {
             IERC20(SCY).safeTransferFrom(msg.sender, market, exactScyIn);
         }
 
-        IPMarket(market).swapScyForExactOt(receiver, netOtOut, exactScyIn, abi.encode());
+        IPMarket(market).swapScyForExactPt(receiver, netPtOut, exactScyIn, abi.encode()); // ignore return
     }
 }

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

@@ -7,9 +7,41 @@ import "../../../SuperComposableYield/ISuperComposableYield.sol";
 import "../../../interfaces/IPYieldToken.sol";
 
 // solhint-disable no-empty-blocks
-abstract contract ActionSCYAndYOBase is PendleJoeSwapHelperUpg {
+abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg {
     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 _joeRouter, address _joeFactory)
         PendleJoeSwapHelperUpg(_joeRouter, _joeFactory)
@@ -43,6 +75,7 @@ abstract contract ActionSCYAndYOBase is PendleJoeSwapHelperUpg {
 
         address baseToken = path[path.length - 1];
         netScyOut = ISuperComposableYield(SCY).mintNoPull(receiver, baseToken, minScyOut);
+        emit MintScyFromRawToken(msg.sender, path[0], netRawTokenIn, SCY, netScyOut);
     }
 
     /**
@@ -84,56 +117,61 @@ abstract contract ActionSCYAndYOBase is PendleJoeSwapHelperUpg {
             netRawTokenOut = _swapExactIn(path, netBaseTokenOut, receiver);
             require(netRawTokenOut >= minRawTokenOut, "insufficient out");
         }
+
+        emit RedeemScyToRawToken(msg.sender, SCY, netScyIn, path[path.length - 1], netRawTokenOut);
     }
 
     /**
-     * @notice swap rawToken to baseToken -> convert to SCY -> convert to OT + YT
+     * @notice swap rawToken to baseToken -> convert to SCY -> convert to PT + YT
      * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
      * @dev inner working of this function:
-     - same as mintScyFromRawToken, except the receiver of SCY will be the YT contract, then mintYO
-     will be called, minting OT + YT directly to receiver
+     - same as mintScyFromRawToken, except the receiver of SCY will be the YT contract, then mintPY
+     will be called, minting PT + YT directly to receiver
      */
-    function _mintYoFromRawToken(
+    function _mintPyFromRawToken(
         uint256 netRawTokenIn,
         address YT,
-        uint256 minYoOut,
+        uint256 minPyOut,
         address receiver,
         address[] calldata path,
         bool doPull
-    ) internal returns (uint256 netYoOut) {
+    ) internal returns (uint256 netPyOut) {
         address SCY = IPYieldToken(YT).SCY();
         _mintScyFromRawToken(netRawTokenIn, SCY, 1, YT, path, doPull);
-        netYoOut = IPYieldToken(YT).mintYO(receiver, receiver);
-        require(netYoOut >= minYoOut, "insufficient YO out");
+        netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
+        require(netPyOut >= minPyOut, "insufficient PY out");
+        emit MintPyFromRawToken(msg.sender, path[0], netRawTokenIn, YT, netPyOut);
     }
 
     /**
-     * @notice redeem OT + YT to SCY -> redeem SCY to baseToken -> swap baseToken to rawToken
+     * @notice redeem PT + YT to SCY -> redeem SCY to baseToken -> swap baseToken to rawToken
      * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
      * @dev inner working of this function:
-     - OT (+ YT if not expired) is transferred to the YT contract
-     - redeemYO is called, redeem all outcome SCY to the SCY contract
+     - PT (+ YT if not expired) is transferred to the YT contract
+     - redeemPY is called, redeem all outcome SCY to the SCY contract
      - The rest is the same as redeemScyToRawToken (except the first SCY transfer is skipped)
      */
-    function _redeemYoToRawToken(
+    function _redeemPyToRawToken(
         address YT,
-        uint256 netYoIn,
+        uint256 netPyIn,
         uint256 minRawTokenOut,
         address receiver,
         address[] memory path,
         bool doPull
     ) internal returns (uint256 netRawTokenOut) {
-        address OT = IPYieldToken(YT).OT();
+        address PT = IPYieldToken(YT).PT();
         address SCY = IPYieldToken(YT).SCY();
 
         if (doPull) {
-            bool isNeedToBurnYt = (IPBaseToken(YT).isExpired() == false);
-            IERC20(OT).safeTransferFrom(msg.sender, YT, netYoIn);
-            if (isNeedToBurnYt) IERC20(YT).safeTransferFrom(msg.sender, YT, netYoIn);
+            bool isNeedToBurnYt = (!IPBaseToken(YT).isExpired());
+            IERC20(PT).safeTransferFrom(msg.sender, YT, netPyIn);
+            if (isNeedToBurnYt) IERC20(YT).safeTransferFrom(msg.sender, YT, netPyIn);
         }
 
-        IPYieldToken(YT).redeemYO(SCY);
+        IPYieldToken(YT).redeemPY(SCY); // ignore return
 
         netRawTokenOut = _redeemScyToRawToken(SCY, 0, minRawTokenOut, receiver, path, false);
+
+        emit RedeemPyToRawToken(msg.sender, YT, netPyIn, path[path.length - 1], netRawTokenOut);
     }
 }

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

@@ -6,11 +6,11 @@ import "../../../interfaces/IPMarket.sol";
 import "../../../SuperComposableYield/SCYUtils.sol";
 import "../../../libraries/math/MarketApproxLib.sol";
 import "../../../libraries/math/MarketMathAux.sol";
-import "./ActionSCYAndYOBase.sol";
+import "./ActionSCYAndPYBase.sol";
 import "./ActionType.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-abstract contract ActionSCYAndYTBase is ActionSCYAndYOBase, ActionType {
+abstract contract ActionSCYAndYTBase is ActionSCYAndPYBase, ActionType {
     using Math for uint256;
     using Math for int256;
     using MarketMathCore for MarketState;
@@ -19,6 +19,8 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndYOBase, ActionType {
     using SafeERC20 for ISuperComposableYield;
     using SafeERC20 for IPYieldToken;
 
+    event SwapYT(address indexed user, int256 ytToAccount, int256 scyToAccount);
+
     function _swapExactScyForYt(
         address receiver,
         address market,
@@ -40,19 +42,21 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndYOBase, ActionType {
             SCY.safeTransferFrom(msg.sender, address(YT), exactScyIn);
         }
 
-        IPMarket(market).swapExactOtForScy(
-            receiver,
-            netYtOut, // exactOtIn = netYtOut
+        IPMarket(market).swapExactPtForScy(
+            address(YT),
+            netYtOut, // exactPtIn = netYtOut
             1,
             abi.encode(ACTION_TYPE.SwapExactScyForYt, receiver)
-        );
+        ); // ignore-return
+
+        emit SwapYT(receiver, netYtOut.Int(), exactScyIn.neg());
     }
 
     /**
     * @dev inner working of this function:
      - YT is transferred to the YT contract
-     - market.swap is called, which will transfer OT directly to the YT contract, and callback is invoked
-     - callback will call YT's redeemYO, which will redeem the outcome SCY to this router, then
+     - market.swap is called, which will transfer PT directly to the YT contract, and callback is invoked
+     - callback will call YT's redeemPY, which will redeem the outcome SCY to this router, then
         all SCY owed to the market will be paid, the rest is transferred to the receiver
      */
     function _swapExactYtForScy(
@@ -70,21 +74,23 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndYOBase, ActionType {
             YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
         }
 
-        IPMarket(market).swapScyForExactOt(
-            receiver,
-            exactYtIn, // exactOtOut = exactYtIn
+        IPMarket(market).swapScyForExactPt(
+            address(YT),
+            exactYtIn, // exactPtOut = exactYtIn
             type(uint256).max,
             abi.encode(ACTION_TYPE.SwapExactYtForScy, receiver)
-        );
+        ); // ignore return
 
         netScyOut = SCY.balanceOf(receiver) - preBalanceScy;
         require(netScyOut >= minScyOut, "INSUFFICIENT_SCY_OUT");
+
+        emit SwapYT(receiver, exactYtIn.neg(), netScyOut.Int());
     }
 
     /**
      * @dev inner working of this function:
      - market.swap is called, which will transfer SCY directly to the YT contract, and callback is invoked
-     - callback will pull more SCY if necessary, do call YT's mintYO, which will mint OT to the market & YT to the receiver
+     - callback will pull more SCY if necessary, do call YT's mintPY, which will mint PT to the market & YT to the receiver
      */
     function _swapScyForExactYt(
         address receiver,
@@ -92,20 +98,22 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndYOBase, ActionType {
         uint256 exactYtOut,
         uint256 maxScyIn
     ) internal returns (uint256 netScyIn) {
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         uint256 preBalanceScy = SCY.balanceOf(receiver);
 
-        IPMarket(market).swapExactOtForScy(
-            receiver,
-            exactYtOut, // exactOtIn = exactYtOut
+        IPMarket(market).swapExactPtForScy(
+            address(YT),
+            exactYtOut, // exactPtIn = exactYtOut
             1,
             abi.encode(ACTION_TYPE.SwapSCYForExactYt, msg.sender, receiver)
-        );
+        ); // ignore return
 
         netScyIn = preBalanceScy - SCY.balanceOf(receiver);
 
         require(netScyIn <= maxScyIn, "exceed out limit");
+
+        emit SwapYT(receiver, exactYtOut.Int(), netScyIn.neg());
     }
 
     function _swapYtForExactScy(
@@ -129,11 +137,13 @@ abstract contract ActionSCYAndYTBase is ActionSCYAndYOBase, ActionType {
             YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
         }
 
-        IPMarket(market).swapScyForExactOt(
+        IPMarket(market).swapScyForExactPt(
             address(YT),
-            netYtIn, // exactOtOut = netYtIn
+            netYtIn, // exactPtOut = netYtIn
             type(uint256).max,
             abi.encode(ACTION_TYPE.SwapYtForExactScy, receiver)
-        );
+        ); // ignore return
+
+        emit SwapYT(receiver, netYtIn.neg(), exactScyOut.Int());
     }
 }

package/contracts/interfaces/IPActionCore.sol

@@ -1,12 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 
+import "../libraries/math/MarketApproxLib.sol";
+
 interface IPActionCore {
     function addLiquidity(
         address receiver,
         address market,
         uint256 scyDesired,
-        uint256 otDesired,
+        uint256 ptDesired,
         uint256 minLpOut
     )
         external
@@ -21,41 +23,35 @@ interface IPActionCore {
         address market,
         uint256 lpToRemove,
         uint256 scyOutMin,
-        uint256 otOutMin
+        uint256 ptOutMin
     ) external returns (uint256, uint256);
 
-    function swapExactOtForScy(
+    function swapExactPtForScy(
         address receiver,
         address market,
-        uint256 exactOtIn,
+        uint256 exactPtIn,
         uint256 minScyOut
     ) external returns (uint256);
 
-    function swapOtForExactScy(
+    function swapPtForExactScy(
         address receiver,
         address market,
         uint256 exactScyOut,
-        uint256 otInGuessMin,
-        uint256 otInGuessMax,
-        uint256 maxIteration,
-        uint256 eps
+        ApproxParams memory approx
     ) external returns (uint256);
 
-    function swapScyForExactOt(
+    function swapScyForExactPt(
         address receiver,
         address market,
-        uint256 exactOtOut,
+        uint256 exactPtOut,
         uint256 maxScyIn
     ) external returns (uint256);
 
-    function swapExactScyForOt(
+    function swapExactScyForPt(
         address receiver,
         address market,
         uint256 exactScyIn,
-        uint256 otOutguessMin,
-        uint256 otOutguessMax,
-        uint256 maxIteration,
-        uint256 eps
+        ApproxParams memory approx
     ) external returns (uint256);
 
     function mintScyFromRawToken(
@@ -74,35 +70,32 @@ interface IPActionCore {
         address[] memory path
     ) external returns (uint256);
 
-    function mintYoFromRawToken(
+    function mintPyFromRawToken(
         uint256 netRawTokenIn,
         address YT,
-        uint256 minYoOut,
+        uint256 minPyOut,
         address receiver,
         address[] calldata path
     ) external returns (uint256);
 
-    function redeemYoToRawToken(
+    function redeemPyToRawToken(
         address YT,
-        uint256 netYoIn,
+        uint256 netPyIn,
         uint256 minRawTokenOut,
         address receiver,
         address[] memory path
     ) external returns (uint256);
 
-    function swapExactRawTokenForOt(
+    function swapExactRawTokenForPt(
         uint256 exactRawTokenIn,
         address receiver,
         address[] calldata path,
         address market,
-        uint256 otOutguessMin,
-        uint256 otOutguessMax,
-        uint256 maxIteration,
-        uint256 eps
-    ) external returns (uint256 netOtOut);
+        ApproxParams memory approx
+    ) external returns (uint256 netPtOut);
 
-    function swapExactOtForRawToken(
-        uint256 exactOtIn,
+    function swapExactPtForRawToken(
+        uint256 exactPtIn,
         address receiver,
         address[] calldata path,
         address market,

package/contracts/interfaces/IPActionRedeem.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+interface IPActionRedeem {
+    function redeemDueIncome(
+        address user,
+        address[] calldata scys,
+        address[] calldata yieldTokens,
+        address[] calldata /*gauges*/
+    )
+        external
+        returns (
+            uint256[][] memory scyRewards,
+            uint256[] memory ytInterests,
+            uint256[][] memory ytRewards
+        );
+}

package/contracts/interfaces/IPActionYT.sol

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.9;
 
+import "../libraries/math/MarketApproxLib.sol";
+
 interface IPActionYT {
     function swapExactYtForScy(
         address receiver,
@@ -20,20 +22,14 @@ interface IPActionYT {
         address receiver,
         address market,
         uint256 exactScyIn,
-        uint256 netYtOutGuessMin,
-        uint256 netYtOutGuessMax,
-        uint256 maxIteration,
-        uint256 eps
+        ApproxParams memory approx
     ) external returns (uint256 netYtOut);
 
     function swapYtForExactScy(
         address receiver,
         address market,
         uint256 exactScyOut,
-        uint256 netYtInGuessMin,
-        uint256 netYtInGuessMax,
-        uint256 maxIteration,
-        uint256 eps
+        ApproxParams memory approx
     ) external returns (uint256 netYtIn);
 
     function swapExactRawTokenForYt(
@@ -41,10 +37,7 @@ interface IPActionYT {
         address receiver,
         address[] calldata path,
         address market,
-        uint256 netYtOutGuessMin,
-        uint256 netYtOutGuessMax,
-        uint256 maxIteration,
-        uint256 eps
+        ApproxParams memory approx
     ) external returns (uint256 netYtOut);
 
     function swapExactYtForRawToken(