@pendle/core-v2 0.6.9 → 0.7.1-beta

package/contracts/core/actions/ActionCore.sol

@@ -1,29 +1,23 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.15;
 
 import "./base/ActionSCYAndPTBase.sol";
 import "./base/ActionSCYAndPYBase.sol";
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPActionCore.sol";
-import "../../libraries/math/MarketMathAux.sol";
 
-contract ActionCore is IPActionCore, ActionSCYAndPTBase, ActionSCYAndPYBase {
+contract ActionCore is IPActionCore, ActionSCYAndPTBase {
     using MarketMathCore for MarketState;
-    using MarketMathAux for MarketState;
     using Math for uint256;
     using Math for int256;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variabless
-    constructor(
-        address _joeRouter,
-        address _joeFactory,
-        address _marketFactory
-    )
-        ActionSCYAndPYBase(_joeRouter, _joeFactory) //solhint-disable-next-line no-empty-blocks
+    constructor(address _joeFactory, address _marketFactory)
+        ActionSCYAndPYBase(_joeFactory) //solhint-disable-next-line no-empty-blocks
     {}
 
-    /// @dev docs can be found in the internal function
+    /// @dev refer to the internal function
     function addLiquidity(
         address receiver,
         address market,
@@ -33,150 +27,173 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase, ActionSCYAndPYBase {
     )
         external
         returns (
-            uint256,
-            uint256,
-            uint256
+            uint256 netLpOut,
+            uint256 scyUsed,
+            uint256 ptUsed
         )
     {
         return _addLiquidity(receiver, market, scyDesired, ptDesired, minLpOut, true);
     }
 
-    /// @dev docs can be found in the internal function
+    /// @dev refer to the internal function
     function removeLiquidity(
         address receiver,
         address market,
         uint256 lpToRemove,
         uint256 scyOutMin,
         uint256 ptOutMin
-    ) external returns (uint256, uint256) {
+    ) external returns (uint256 netScyOut, uint256 netPtOut) {
         return _removeLiquidity(receiver, market, lpToRemove, scyOutMin, ptOutMin, true);
     }
 
-    /// @dev docs can be found in the internal function
+    /// @dev refer to the internal function
     function swapExactPtForScy(
         address receiver,
         address market,
         uint256 exactPtIn,
         uint256 minScyOut
-    ) external returns (uint256) {
+    ) external returns (uint256 netScyOut) {
         return _swapExactPtForScy(receiver, market, exactPtIn, minScyOut, true);
     }
 
-    /// @dev docs can be found in the internal function
+    /// @dev refer to the internal function
     function swapPtForExactScy(
         address receiver,
         address market,
         uint256 exactScyOut,
-        ApproxParams memory approx
-    ) external returns (uint256) {
-        return _swapPtForExactScy(receiver, market, exactScyOut, approx, true);
+        uint256 maxPtIn,
+        ApproxParams memory guessPtIn
+    ) external returns (uint256 netPtIn) {
+        return _swapPtForExactScy(receiver, market, exactScyOut, maxPtIn, guessPtIn, true);
     }
 
-    /// @dev docs can be found in the internal function
+    /// @dev refer to the internal function
     function swapScyForExactPt(
         address receiver,
         address market,
         uint256 exactPtOut,
         uint256 maxScyIn
-    ) external returns (uint256) {
+    ) external returns (uint256 netScyIn) {
         return _swapScyForExactPt(receiver, market, exactPtOut, maxScyIn, true);
     }
 
-    /// @dev docs can be found in the internal function
+    /// @dev refer to the internal function
     function swapExactScyForPt(
         address receiver,
         address market,
         uint256 exactScyIn,
-        ApproxParams memory approx
-    ) external returns (uint256) {
-        return _swapExactScyForPt(receiver, market, exactScyIn, approx, true);
+        uint256 minPtOut,
+        ApproxParams memory guessPtOut
+    ) external returns (uint256 netPtOut) {
+        return _swapExactScyForPt(receiver, market, exactScyIn, minPtOut, guessPtOut, true);
     }
 
-    /// @dev docs can be found in the internal function
+    /// @dev refer to the internal function
     function mintScyFromRawToken(
-        uint256 netRawTokenIn,
+        address receiver,
         address SCY,
+        uint256 netRawTokenIn,
         uint256 minScyOut,
-        address receiver,
         address[] calldata path
-    ) external returns (uint256) {
-        return _mintScyFromRawToken(netRawTokenIn, SCY, minScyOut, receiver, path, true);
+    ) external returns (uint256 netScyOut) {
+        return _mintScyFromRawToken(receiver, SCY, netRawTokenIn, minScyOut, path, true);
     }
 
-    /// @dev docs can be found in the internal function
+    /// @dev refer to the internal function
     function redeemScyToRawToken(
+        address receiver,
         address SCY,
         uint256 netScyIn,
         uint256 minRawTokenOut,
-        address receiver,
         address[] memory path
-    ) external returns (uint256) {
-        return _redeemScyToRawToken(SCY, netScyIn, minRawTokenOut, receiver, path, true);
+    ) external returns (uint256 netRawTokenOut) {
+        return _redeemScyToRawToken(receiver, SCY, netScyIn, minRawTokenOut, path, true);
     }
 
-    /// @dev docs can be found in the internal function
+    /// @dev refer to the internal function
     function mintPyFromRawToken(
-        uint256 netRawTokenIn,
+        address receiver,
         address YT,
+        uint256 netRawTokenIn,
         uint256 minPyOut,
-        address receiver,
         address[] calldata path
-    ) external returns (uint256) {
-        return _mintPyFromRawToken(netRawTokenIn, YT, minPyOut, receiver, path, true);
+    ) external returns (uint256 netPyOut) {
+        return _mintPyFromRawToken(receiver, YT, netRawTokenIn, minPyOut, path, true);
     }
 
-    /// @dev docs can be found in the internal function
+    /// @dev refer to the internal function
     function redeemPyToRawToken(
+        address receiver,
         address YT,
         uint256 netPyIn,
         uint256 minRawTokenOut,
-        address receiver,
         address[] memory path
-    ) external returns (uint256) {
-        return _redeemPyToRawToken(YT, netPyIn, minRawTokenOut, receiver, path, true);
+    ) external returns (uint256 netRawTokenOut) {
+        return _redeemPyToRawToken(receiver, YT, netPyIn, minRawTokenOut, path, true);
     }
 
-    /**
-    * @dev netPtOutGuessMin & netPtOutGuessMax the minimum & maximum possible guess for the netPtOut
-    the correct ptOut must lie between this range, else the function will revert.
-    * @dev the smaller the range, the fewer iterations it will take (hence less gas). The expected way
-    to create the guess is to run this function with min = 0, max = type(uint256.max) to trigger the widest
-    guess range. After getting the result, min = result * (1-eps) & max = result * (1+eps)
-    * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
-    * @param approx params to approx. Guess params will be the min, max & offchain guess for netPtOut
-    */
+    /// @dev refer to the internal function
     function swapExactRawTokenForPt(
-        uint256 exactRawTokenIn,
         address receiver,
-        address[] calldata path,
         address market,
-        ApproxParams memory approx
+        uint256 exactRawTokenIn,
+        uint256 minPtOut,
+        address[] calldata path,
+        ApproxParams memory guessPtOut
     ) external returns (uint256 netPtOut) {
-        address SCY = IPMarket(market).SCY();
-        uint256 netScyUseToBuyPt = _mintScyFromRawToken(
-            exactRawTokenIn,
-            SCY,
-            1,
-            market,
-            path,
-            true
-        );
-        netPtOut = _swapExactScyForPt(receiver, market, netScyUseToBuyPt, approx, false);
+        return
+            _swapExactRawTokenForPt(
+                receiver,
+                market,
+                exactRawTokenIn,
+                minPtOut,
+                path,
+                guessPtOut,
+                true
+            );
     }
 
-    /**
-     * @notice sell all Pt for RawToken
-     * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
-     */
+    /// @dev refer to the internal function
     function swapExactPtForRawToken(
-        uint256 exactPtIn,
         address receiver,
-        address[] calldata path,
         address market,
-        uint256 minRawTokenOut
+        uint256 exactPtIn,
+        uint256 minRawTokenOut,
+        address[] calldata path
     ) external returns (uint256 netRawTokenOut) {
-        address SCY = IPMarket(market).SCY();
-        _swapExactPtForScy(SCY, market, exactPtIn, 1, true);
-        netRawTokenOut = _redeemScyToRawToken(SCY, 0, minRawTokenOut, receiver, path, false);
+        return _swapExactPtForRawToken(receiver, market, exactPtIn, minRawTokenOut, path, true);
+    }
+
+    function redeemDueIncome(
+        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
+            );
+        }
+
+        marketRewards = new uint256[][](markets.length);
+        for (uint256 i = 0; i < markets.length; ++i) {
+            marketRewards[i] = IPMarket(markets[i]).redeemRewards(user);
+        }
     }
 }

package/contracts/core/actions/ActionYT.sol

@@ -1,146 +1,95 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.15;
 
 import "./base/ActionSCYAndYTBase.sol";
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPActionYT.sol";
-import "../../libraries/math/MarketMathAux.sol";
 
 contract ActionYT is IPActionYT, ActionSCYAndYTBase {
     using MarketMathCore for MarketState;
-    using MarketMathAux 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 _joeRouter, address _joeFactory)
-        ActionSCYAndPYBase(_joeRouter, _joeFactory)
+    constructor(address _joeFactory)
+        ActionSCYAndPYBase(_joeFactory)
     //solhint-disable-next-line no-empty-blocks
     {
 
     }
 
-    /**
-     * @dev Take in a fixed amount of YT and returns receiver a corresponding amount of SCY
-     * @dev inner working step
-       - Transfer exactYtIn amount of YT to YT
-       - market.swapScyToExactPt is called, the receiver of PT is YT
-       - YT.redeemPY is called, burning exactYtIn YT & PT to SCY
-       - Return the owed Scy for contract, the rest is transferred to user
-     */
+    /// @dev refer to the internal function
     function swapExactYtForScy(
         address receiver,
         address market,
         uint256 exactYtIn,
         uint256 minScyOut
-    ) external returns (uint256) {
+    ) external returns (uint256 netScyOut) {
         return _swapExactYtForScy(receiver, market, exactYtIn, minScyOut, true);
     }
 
-    /**
-     * @dev Take in a corresponding amount of SCY & return receiver a fixed amount of YT
-     * @dev inner working step
-       - Input SCY is transferred to YT address
-       - swap.swapExactPtForScy is called the receiver is YT
-       - YT.mintPY is called, granting router exactYtOut YT & PT
-       - The owed PT is paid by setting the PT receiver is market, YT receiver is $receiver
-     */
+    /// @dev refer to the internal function
     function swapScyForExactYt(
         address receiver,
         address market,
         uint256 exactYtOut,
         uint256 maxScyIn
-    ) external returns (uint256) {
+    ) external returns (uint256 netScyIn) {
         return _swapScyForExactYt(receiver, market, exactYtOut, maxScyIn);
     }
 
-    /**
-     * @dev Take in a fixed a mount of SCY and return receiver the corresponding amount of YT
-     * @dev can refer to the doc of swapExactRawTokenForYt
-     * @param approx params to approx. Guess params will be the min, max & offchain guess for netYtOut
-     */
+    /// @dev refer to the internal function
     function swapExactScyForYt(
         address receiver,
         address market,
         uint256 exactScyIn,
-        ApproxParams memory approx
+        uint256 minYtOut,
+        ApproxParams memory guessYtOut
     ) external returns (uint256 netYtOut) {
-        return _swapExactScyForYt(receiver, market, exactScyIn, approx, true);
+        return _swapExactScyForYt(receiver, market, exactScyIn, minYtOut, guessYtOut, true);
     }
 
-    /**
-     * @dev take in a correesponding amount of YT & return an exactScyOut amount of SCY
-     * @dev can refer to the doc of swapExactYtForRawToken
-     * @param approx params to approx. Guess params will be the min, max & offchain guess for netYtIn
-     */
+    /// @dev refer to the internal function
     function swapYtForExactScy(
         address receiver,
         address market,
         uint256 exactScyOut,
-        ApproxParams memory approx
+        uint256 maxYtIn,
+        ApproxParams memory guessYtIn
     ) external returns (uint256 netYtIn) {
-        return _swapYtForExactScy(receiver, market, exactScyOut, approx, true);
+        return _swapYtForExactScy(receiver, market, exactScyOut, maxYtIn, guessYtIn, true);
     }
 
-    /**
-     * @dev netYtOutGuessMin & Max can be used in the same way as RawTokenPT
-     * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
-     * @dev inner working of this function:
-     - mintScyFromRawToken is invoked, except the YT contract will receive all the outcome SCY
-     - market.swapExactPtToScy is called, which will transfer SCY to the YT contract, and callback is invoked
-     - callback will do call YT.mintPT, which will mint PT to the market & YT to the receiver
-     * @param approx params to approx. Guess params will be the min, max & offchain guess for netYtOut
-     */
+    /// @dev refer to the internal function
     function swapExactRawTokenForYt(
-        uint256 exactRawTokenIn,
         address receiver,
-        address[] calldata path,
         address market,
-        ApproxParams memory approx
+        uint256 exactRawTokenIn,
+        uint256 minYtOut,
+        address[] calldata path,
+        ApproxParams memory guessYtOut
     ) external returns (uint256 netYtOut) {
-        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
-
-        uint256 netScyUsedToBuyYT = _mintScyFromRawToken(
-            exactRawTokenIn,
-            address(SCY),
-            1,
-            address(YT),
-            path,
-            true
-        );
-
-        netYtOut = _swapExactScyForYt(receiver, market, netScyUsedToBuyYT, approx, false);
+        return
+            _swapExactRawTokenForYt(
+                receiver,
+                market,
+                exactRawTokenIn,
+                minYtOut,
+                path,
+                guessYtOut,
+                true
+            );
     }
 
-    /**
-     * @notice swap YT -> SCY -> baseToken -> rawToken
-     * @notice the algorithm to swap will guarantee to swap all the YT available
-     * @param path the path to swap from rawToken to baseToken. path = [baseToken] if no swap is needed
-     * @dev inner working of this function:
-     - YT is transferred to the YT contract
-     - market.swapScyForExactPt is called, which will transfer PT directly to the YT contract, and callback is invoked
-     - callback will do call YT.redeemPY, which will redeem the outcome SCY to this router, then
-        all SCY owed to the market will be paid, the rest is used to feed redeemScyToRawToken
-     */
+    /// @dev refer to the internal function
     function swapExactYtForRawToken(
-        uint256 exactYtIn,
         address receiver,
-        address[] calldata path,
         address market,
-        uint256 minRawTokenOut
+        uint256 exactYtIn,
+        uint256 minRawTokenOut,
+        address[] calldata path
     ) external returns (uint256 netRawTokenOut) {
-        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
-
-        uint256 netScyOut = _swapExactYtForScy(address(SCY), market, exactYtIn, 1, true);
-
-        netRawTokenOut = _redeemScyToRawToken(
-            address(SCY),
-            netScyOut,
-            minRawTokenOut,
-            receiver,
-            path,
-            false
-        );
+        return _swapExactYtForRawToken(receiver, market, exactYtIn, minRawTokenOut, path, true);
     }
 }