@pendle/core-v2 0.6.9 → 0.7.0

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

@@ -1,32 +1,29 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 import "../../../interfaces/IPMarketFactory.sol";
 import "../../../interfaces/IPMarket.sol";
 import "../../../interfaces/IPMarketAddRemoveCallback.sol";
 import "../../../interfaces/IPMarketSwapCallback.sol";
 import "../../../libraries/math/MarketApproxLib.sol";
-import "../../../libraries/math/MarketMathAux.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "./ActionSCYAndPYBase.sol";
 
-abstract contract ActionSCYAndPTBase {
+abstract contract ActionSCYAndPTBase is ActionSCYAndPYBase {
     using Math for uint256;
     using Math for int256;
     using MarketMathCore for MarketState;
-    using MarketMathAux for MarketState;
     using MarketApproxLib for MarketState;
     using SafeERC20 for IERC20;
+    using SCYIndexLib for ISuperComposableYield;
+
+    bytes private constant EMPTY_BYTES = abi.encode();
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
 
-    /**
-     * @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 & pt from msg.sender to the market, and finish the callback
-     */
+    /// @dev For doPull: if doPull is true, this function will do transferFrom as necessary from msg.sender. Else, it will
+    /// assume tokens have already been transferred in.
+
     function _addLiquidity(
         address receiver,
         address market,
@@ -46,12 +43,13 @@ abstract contract ActionSCYAndPTBase {
 
         MarketState memory state = IPMarket(market).readState(false);
         (, netLpOut, scyUsed, ptUsed) = state.addLiquidity(
-            SCYIndexLib.newIndex(SCY),
+            SCY.newIndex(),
             scyDesired,
             ptDesired,
             false
         );
 
+        // early-check
         require(netLpOut >= minLpOut, "insufficient lp out");
 
         if (doPull) {
@@ -59,17 +57,17 @@ abstract contract ActionSCYAndPTBase {
             IERC20(PT).safeTransferFrom(msg.sender, market, ptUsed);
         }
 
-        IPMarket(market).addLiquidity(receiver, ptDesired, scyDesired, abi.encode()); // ignore return
+        (netLpOut, , ) = IPMarket(market).addLiquidity(
+            receiver,
+            ptDesired,
+            scyDesired,
+            EMPTY_BYTES
+        );
+
+        // fail-safe
+        require(netLpOut >= minLpOut, "FS insufficient lp out");
     }
 
-    /**
-     * @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 & 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(
         address receiver,
         address market,
@@ -81,24 +79,27 @@ abstract contract ActionSCYAndPTBase {
         MarketState memory state = IPMarket(market).readState(false);
 
         (netScyOut, netPtOut) = state.removeLiquidity(lpToRemove, false);
-        require(netScyOut >= scyOutMin, "insufficient scy out");
-        require(netPtOut >= ptOutMin, "insufficient pt out");
+
+        // early-check
+        require(netScyOut >= scyOutMin, "insufficient SCY out");
+        require(netPtOut >= ptOutMin, "insufficient PT out");
 
         if (doPull) {
             IERC20(market).safeTransferFrom(msg.sender, market, lpToRemove);
         }
 
-        IPMarket(market).removeLiquidity(receiver, lpToRemove, abi.encode()); // ignore return
+        (netScyOut, netPtOut) = IPMarket(market).removeLiquidity(
+            receiver,
+            receiver,
+            lpToRemove,
+            EMPTY_BYTES
+        );
+
+        // fail-safe
+        require(netScyOut >= scyOutMin, "FS insufficient SCY out");
+        require(netPtOut >= ptOutMin, "FS insufficient PT out");
     }
 
-    /**
-     * @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 PT from msg.sender to the market, and finish the callback
-     */
     function _swapExactPtForScy(
         address receiver,
         address market,
@@ -107,58 +108,48 @@ abstract contract ActionSCYAndPTBase {
         bool doPull
     ) internal returns (uint256 netScyOut) {
         if (doPull) {
-            address PT = IPMarket(market).PT();
-            IERC20(PT).safeTransferFrom(msg.sender, market, exactPtIn);
+            (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
+            IERC20(address(PT)).safeTransferFrom(msg.sender, market, exactPtIn);
         }
 
-        (netScyOut, ) = IPMarket(market).swapExactPtForScy(
-            receiver,
-            exactPtIn,
-            minScyOut,
-            abi.encode()
-        );
+        (netScyOut, ) = IPMarket(market).swapExactPtForScy(receiver, exactPtIn, EMPTY_BYTES);
 
-        require(netScyOut >= minScyOut, "insufficient scy out");
+        require(netScyOut >= minScyOut, "insufficient SCY out");
     }
 
     /**
-     * @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
+     * @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,
-        ApproxParams memory approx,
+        uint256 maxPtIn,
+        ApproxParams memory guessPtIn,
         bool doPull
     ) internal returns (uint256 netPtIn) {
         MarketState memory state = IPMarket(market).readState(false);
         (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         (netPtIn, ) = state.approxSwapPtForExactScy(
-            SCYIndexLib.newIndex(SCY),
+            SCY.newIndex(),
             exactScyOut,
             block.timestamp,
-            approx
+            guessPtIn
         );
+        require(netPtIn <= maxPtIn, "exceed limit PT in");
 
         if (doPull) {
             IERC20(PT).safeTransferFrom(msg.sender, market, netPtIn);
         }
 
-        IPMarket(market).swapExactPtForScy(receiver, netPtIn, exactScyOut, abi.encode()); // ignore return
+        (uint256 netScyOut, ) = IPMarket(market).swapExactPtForScy(receiver, netPtIn, EMPTY_BYTES);
+
+        // fail-safe
+        require(netScyOut >= exactScyOut, "FS insufficient SCY out");
     }
 
-    /**
-     * @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
-     - 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 _swapScyForExactPt(
         address receiver,
         address market,
@@ -167,52 +158,116 @@ abstract contract ActionSCYAndPTBase {
         bool doPull
     ) internal returns (uint256 netScyIn) {
         MarketState memory state = IPMarket(market).readState(false);
-        address SCY = IPMarket(market).SCY();
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
-        (netScyIn, ) = state.swapScyForExactPt(
-            SCYIndexLib.newIndex(SCY),
-            exactPtOut,
-            block.timestamp,
-            false
-        );
-        require(netScyIn <= maxScyIn, "exceed limit scy in");
+        (netScyIn, ) = state.swapScyForExactPt(SCY.newIndex(), exactPtOut, block.timestamp);
+
+        require(netScyIn <= maxScyIn, "exceed limit SCY in");
 
         if (doPull) {
             IERC20(SCY).safeTransferFrom(msg.sender, market, netScyIn);
         }
 
-        IPMarket(market).swapScyForExactPt(receiver, exactPtOut, maxScyIn, abi.encode()); // ignore return
+        IPMarket(market).swapScyForExactPt(receiver, exactPtOut, EMPTY_BYTES); // ignore return
+
+        // no fail-safe since exactly netScyIn will go into the market
     }
 
     /**
-     * @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
+     * @notice Note that although we will only use almost all of the `exactScyIn`, we will still transfer all in so that
+        not to leave dust behind
      */
     function _swapExactScyForPt(
         address receiver,
         address market,
         uint256 exactScyIn,
-        ApproxParams memory approx,
+        uint256 minPtOut,
+        ApproxParams memory guessPtOut,
         bool doPull
     ) internal returns (uint256 netPtOut) {
         MarketState memory state = IPMarket(market).readState(false);
-        address SCY = IPMarket(market).SCY();
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
 
         (netPtOut, ) = state.approxSwapExactScyForPt(
-            SCYIndexLib.newIndex(SCY),
+            SCY.newIndex(),
             exactScyIn,
             block.timestamp,
-            approx
+            guessPtOut
         );
 
+        require(netPtOut >= minPtOut, "insufficient PT out");
+
         if (doPull) {
             IERC20(SCY).safeTransferFrom(msg.sender, market, exactScyIn);
         }
 
-        IPMarket(market).swapScyForExactPt(receiver, netPtOut, exactScyIn, abi.encode()); // ignore return
+        IPMarket(market).swapScyForExactPt(receiver, netPtOut, EMPTY_BYTES); // ignore return
+
+        // no fail-safe since exactly netPtOut >= minPtOut will be out
+    }
+
+    /**
+     * @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 _mintScyFromRawToken & _swapExactScyForPt
+     */
+    function _swapExactRawTokenForPt(
+        address receiver,
+        address market,
+        uint256 exactRawTokenIn,
+        uint256 minPtOut,
+        address[] calldata path,
+        ApproxParams memory guessPtOut,
+        bool doPull
+    ) internal returns (uint256 netPtOut) {
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+
+        // all output SCY is transferred directly to the market
+        uint256 netScyUseToBuyPt = _mintScyFromRawToken(
+            market,
+            address(SCY),
+            exactRawTokenIn,
+            1,
+            path,
+            doPull
+        );
+
+        // SCY is already in the market, hence doPull = false
+        netPtOut = _swapExactScyForPt(
+            receiver,
+            market,
+            netScyUseToBuyPt,
+            minPtOut,
+            guessPtOut,
+            false
+        );
+    }
+
+    /**
+     * @notice swap from PT to SCY, then redeem SCY to baseToken & swap through Uniswap's forks to get rawTokenOut
+     * @dev simply a combination of _swapExactPtForScy & _redeemScyToRawToken
+     */
+    function _swapExactPtForRawToken(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        uint256 minRawTokenOut,
+        address[] calldata path,
+        bool doPull
+    ) internal returns (uint256 netRawTokenOut) {
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+
+        // all output SCY is directly transferred to the SCY contract
+        _swapExactPtForScy(address(SCY), market, exactPtIn, 1, doPull);
+
+        // since all SCY is already at the SCY contract, doPull = false
+        netRawTokenOut = _redeemScyToRawToken(
+            receiver,
+            address(SCY),
+            0,
+            minRawTokenOut,
+            path,
+            false
+        );
     }
 }

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

@@ -1,9 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "../../../periphery/PendleJoeSwapHelperUpg.sol";
-import "../../../SuperComposableYield/ISuperComposableYield.sol";
+import "../../../libraries/traderjoe/PendleJoeSwapHelperUpg.sol";
+import "../../../libraries/helpers/MiniHelpers.sol";
+import "../../../interfaces/ISuperComposableYield.sol";
 import "../../../interfaces/IPYieldToken.sol";
 
 // solhint-disable no-empty-blocks
@@ -43,24 +44,19 @@ abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg {
     );
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _joeRouter, address _joeFactory)
-        PendleJoeSwapHelperUpg(_joeRouter, _joeFactory)
-    {}
+    constructor(address _joeFactory) PendleJoeSwapHelperUpg(_joeFactory) {}
+
+    /// @dev for Path. If no swap is needed, path = [token]
+    /// else, path = [inputToken, token0, token1, ...., outputToken]
 
     /**
-     * @notice swap rawToken to baseToken -> baseToken to mint SCY
-     * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
-     * @dev inner working of this function:
-     - if [rawToken == baseToken], rawToken is transferred to SCY contract
-       else, it is transferred to the first pair of path, swap is called, and the output token is transferred
-            to SCY contract
-     - SCY.mint is called, minting SCY directly to receiver
+     * @notice swap rawToken to baseToken through Uniswap's forks & use it to mint SCY
      */
     function _mintScyFromRawToken(
-        uint256 netRawTokenIn,
+        address receiver,
         address SCY,
+        uint256 netRawTokenIn,
         uint256 minScyOut,
-        address receiver,
         address[] calldata path,
         bool doPull
     ) internal returns (uint256 netScyOut) {
@@ -74,26 +70,18 @@ abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg {
         }
 
         address baseToken = path[path.length - 1];
-        netScyOut = ISuperComposableYield(SCY).mintNoPull(receiver, baseToken, minScyOut);
+        netScyOut = ISuperComposableYield(SCY).deposit(receiver, baseToken, 0, minScyOut);
         emit MintScyFromRawToken(msg.sender, path[0], netRawTokenIn, SCY, netScyOut);
     }
 
     /**
-    * @notice redeem SCY to baseToken -> swap baseToken to rawToken
-    * @dev path[0] will be the baseToken that SCY is redeemed to, and path[path.length-1] is the
-    final rawToken output
-    * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
-    * @dev inner working of this function:
-     - SCY is transferred to SCY contract
-     - if [rawToken == baseToken], SCY.redeem is called & directly redeem tokens to the receiver
-       else, SCY.redeem is called with receiver = first pair in the path,
-        and swap is called, and the output token is transferred to receiver
+     * @notice redeem SCY to baseToken -> swap baseToken to rawToken through Uniswap's forks
      */
     function _redeemScyToRawToken(
+        address receiver,
         address SCY,
         uint256 netScyIn,
         uint256 minRawTokenOut,
-        address receiver,
         address[] memory path,
         bool doPull
     ) internal returns (uint256 netRawTokenOut) {
@@ -103,14 +91,16 @@ abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg {
 
         address baseToken = path[0];
         if (path.length == 1) {
-            netRawTokenOut = ISuperComposableYield(SCY).redeemNoPull(
+            netRawTokenOut = ISuperComposableYield(SCY).redeem(
                 receiver,
+                0,
                 baseToken,
                 minRawTokenOut
             );
         } else {
-            uint256 netBaseTokenOut = ISuperComposableYield(SCY).redeemNoPull(
+            uint256 netBaseTokenOut = ISuperComposableYield(SCY).redeem(
                 _getFirstPair(path),
+                0,
                 baseToken,
                 1
             );
@@ -122,40 +112,35 @@ abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg {
     }
 
     /**
-     * @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 mintPY
-     will be called, minting PT + YT directly to receiver
+     * @notice swap rawToken to baseToken through Uniswap's forks -> convert to SCY -> convert to PT + YT
      */
     function _mintPyFromRawToken(
-        uint256 netRawTokenIn,
+        address receiver,
         address YT,
+        uint256 netRawTokenIn,
         uint256 minPyOut,
-        address receiver,
         address[] calldata path,
         bool doPull
     ) internal returns (uint256 netPyOut) {
         address SCY = IPYieldToken(YT).SCY();
-        _mintScyFromRawToken(netRawTokenIn, SCY, 1, YT, path, doPull);
+
+        _mintScyFromRawToken(YT, SCY, netRawTokenIn, 1, path, doPull);
+
         netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
         require(netPyOut >= minPyOut, "insufficient PY out");
+
         emit MintPyFromRawToken(msg.sender, path[0], netRawTokenIn, YT, netPyOut);
     }
 
     /**
-     * @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:
-     - 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)
+     * @notice redeem PT + YT to SCY -> redeem SCY to baseToken -> swap baseToken to rawToken through Uniswap's forks.
+        If the YT hasn't expired, both PT & YT will be needed to redeem. Else, only PT is needed
      */
     function _redeemPyToRawToken(
+        address receiver,
         address YT,
         uint256 netPyIn,
         uint256 minRawTokenOut,
-        address receiver,
         address[] memory path,
         bool doPull
     ) internal returns (uint256 netRawTokenOut) {
@@ -163,14 +148,14 @@ abstract contract ActionSCYAndPYBase is PendleJoeSwapHelperUpg {
         address SCY = IPYieldToken(YT).SCY();
 
         if (doPull) {
-            bool isNeedToBurnYt = (!IPBaseToken(YT).isExpired());
+            bool needToBurnYt = (!IPYieldToken(YT).isExpired());
             IERC20(PT).safeTransferFrom(msg.sender, YT, netPyIn);
-            if (isNeedToBurnYt) IERC20(YT).safeTransferFrom(msg.sender, YT, netPyIn);
+            if (needToBurnYt) IERC20(YT).safeTransferFrom(msg.sender, YT, netPyIn);
         }
 
         IPYieldToken(YT).redeemPY(SCY); // ignore return
 
-        netRawTokenOut = _redeemScyToRawToken(SCY, 0, minRawTokenOut, receiver, path, false);
+        netRawTokenOut = _redeemScyToRawToken(receiver, SCY, 0, minRawTokenOut, path, false);
 
         emit RedeemPyToRawToken(msg.sender, YT, netPyIn, path[path.length - 1], netRawTokenOut);
     }