@pendle/core-v2 0.8.1-gamma → 0.9.2-beta

package/build/artifacts/contracts/periphery/PermissionsV2Upg.sol/PermissionsV2Upg.dbg.json

@@ -1,4 +1,4 @@
 {
   "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/a4ba5d2a874c9e63492c072e1e1ee71d.json"
+  "buildInfo": "../../../build-info/24357fe9edb216d369aebd37d2cbdc6d.json"
 }

package/contracts/SuperComposableYield/SCY-implementations/TraderJoe/PendleSJoeSCY.sol

@@ -40,10 +40,10 @@ contract PendleSJoeSCY is SCYBaseWithRewards {
         string memory _name,
         string memory _symbol,
         address _sJOE
-    ) SCYBaseWithRewards(_name, _symbol, _sJOE) {
+    ) SCYBaseWithRewards(_name, _symbol, ISJoe(_sJOE).joe()) {
         require(_sJOE != address(0), "zero address");
         SJOE = _sJOE;
-        JOE = ISJoe(SJOE).joe();
+        JOE = yieldToken;
 
         _safeApprove(JOE, SJOE, type(uint256).max);
     }
@@ -130,7 +130,7 @@ contract PendleSJoeSCY is SCYBaseWithRewards {
                 MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+    function _previewDeposit(address, uint256 amountTokenToDeposit)
         internal
         view
         override
@@ -138,18 +138,16 @@ contract PendleSJoeSCY is SCYBaseWithRewards {
     {
         uint256 sJoeDepositFeePrecision = ISJoe(SJOE).depositFeePercent();
 
-        amountSharesOut =
-            (((1e18 - sJoeDepositFeePrecision / 1e18) * amountTokenToDeposit) * 1e18) /
-            exchangeRate();
+        amountSharesOut = ((1e18 - sJoeDepositFeePrecision / 1e18) * amountTokenToDeposit);
     }
 
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+    function _previewRedeem(address, uint256 amountSharesToRedeem)
         internal
         pure
         override
         returns (uint256 amountTokenOut)
     {
-        amountTokenOut = (amountSharesToRedeem * exchangeRate()) / 1e18;
+        amountTokenOut = amountSharesToRedeem;
     }
 
     function getTokensIn() public view virtual override returns (address[] memory res) {

package/contracts/core/PendleRouter.sol

@@ -44,26 +44,28 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, PermissionsV2Upg
 
     function getRouterImplementation(bytes4 sig) public view returns (address) {
         if (
-            sig == IPActionCore.mintScyFromRawToken.selector ||
-            sig == IPActionCore.redeemScyToRawToken.selector ||
-            sig == IPActionCore.mintPyFromRawToken.selector ||
-            sig == IPActionCore.redeemPyToRawToken.selector ||
+            sig == IPActionCore.mintScyFromToken.selector ||
+            sig == IPActionCore.redeemScyToToken.selector ||
+            sig == IPActionCore.mintPyFromToken.selector ||
+            sig == IPActionCore.redeemPyToToken.selector ||
             sig == IPActionCore.mintPyFromScy.selector ||
             sig == IPActionCore.redeemPyToScy.selector ||
-            sig == IPActionCore.addLiquidity.selector ||
+            sig == IPActionCore.addLiquidityDualScyAndPt.selector ||
+            sig == IPActionCore.addLiquidityDualIbTokenAndPt.selector ||
             sig == IPActionCore.addLiquiditySinglePt.selector ||
             sig == IPActionCore.addLiquiditySingleScy.selector ||
-            sig == IPActionCore.addLiquiditySingleRawToken.selector ||
-            sig == IPActionCore.removeLiquidity.selector ||
+            sig == IPActionCore.addLiquiditySingleToken.selector ||
+            sig == IPActionCore.removeLiquidityDualScyAndPt.selector ||
+            sig == IPActionCore.removeLiquidityDualIbTokenAndPt.selector ||
             sig == IPActionCore.removeLiquiditySinglePt.selector ||
             sig == IPActionCore.removeLiquiditySingleScy.selector ||
-            sig == IPActionCore.removeLiquiditySingleRawToken.selector ||
+            sig == IPActionCore.removeLiquiditySingleToken.selector ||
             sig == IPActionCore.swapExactPtForScy.selector ||
             sig == IPActionCore.swapPtForExactScy.selector ||
             sig == IPActionCore.swapScyForExactPt.selector ||
             sig == IPActionCore.swapExactScyForPt.selector ||
-            sig == IPActionCore.swapExactRawTokenForPt.selector ||
-            sig == IPActionCore.swapExactPtForRawToken.selector ||
+            sig == IPActionCore.swapExactTokenForPt.selector ||
+            sig == IPActionCore.swapExactPtForToken.selector ||
             sig == IPActionCore.redeemDueInterestAndRewards.selector
         ) {
             return ACTION_CORE;
@@ -71,8 +73,8 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, PermissionsV2Upg
             sig == IPActionYT.swapExactYtForScy.selector ||
             sig == IPActionYT.swapScyForExactYt.selector ||
             sig == IPActionYT.swapExactScyForYt.selector ||
-            sig == IPActionYT.swapExactRawTokenForYt.selector ||
-            sig == IPActionYT.swapExactYtForRawToken.selector ||
+            sig == IPActionYT.swapExactTokenForYt.selector ||
+            sig == IPActionYT.swapExactYtForToken.selector ||
             sig == IPActionYT.swapYtForExactScy.selector
         ) {
             return ACTION_YT;

package/contracts/core/actions/ActionCore.sol

@@ -13,12 +13,12 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
     using Math for int256;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variabless
-    constructor(address _joeFactory, address _marketFactory)
-        ActionSCYAndPYBase(_joeFactory) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberSwapRouter, address _marketFactory)
+        ActionSCYAndPYBase(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
     {}
 
     /// @dev refer to the internal function
-    function addLiquidity(
+    function addLiquidityDualScyAndPt(
         address receiver,
         address market,
         uint256 scyDesired,
@@ -32,7 +32,7 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
             uint256 ptUsed
         )
     {
-        (netLpOut, scyUsed, ptUsed) = _addLiquidity(
+        (netLpOut, scyUsed, ptUsed) = _addLiquidityDualScyAndPt(
             receiver,
             market,
             scyDesired,
@@ -40,7 +40,39 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
             minLpOut,
             true
         );
-        emit AddLiquidity(msg.sender, market, receiver, scyUsed, ptUsed, netLpOut);
+        emit AddLiquidityDualScyAndPt(msg.sender, market, receiver, scyUsed, ptUsed, netLpOut);
+    }
+
+    /// @dev refer to the internal function
+    function addLiquidityDualIbTokenAndPt(
+        address receiver,
+        address market,
+        uint256 ibTokenDesired,
+        uint256 ptDesired,
+        uint256 minLpOut
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 ibTokenUsed,
+            uint256 ptUsed
+        )
+    {
+        (netLpOut, ibTokenUsed, ptUsed) = _addLiquidityDualIbTokenAndPt(
+            receiver,
+            market,
+            ibTokenDesired,
+            ptDesired,
+            minLpOut
+        );
+        emit AddLiquidityDualIbTokenAndPt(
+            msg.sender,
+            market,
+            receiver,
+            ibTokenDesired,
+            ptUsed,
+            netLpOut
+        );
     }
 
     function addLiquiditySinglePt(
@@ -48,7 +80,7 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 netPtIn,
         uint256 minLpOut,
-        ApproxParams memory guessPtSwapToScy
+        ApproxParams calldata guessPtSwapToScy
     ) external returns (uint256 netLpOut) {
         require(false, "NOT IMPLEMENTED");
     }
@@ -58,39 +90,69 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 netScyIn,
         uint256 minLpOut,
-        ApproxParams memory guessPtReceivedFromScy
+        ApproxParams calldata guessPtReceivedFromScy
     ) external returns (uint256 netLpOut) {
         require(false, "NOT IMPLEMENTED");
     }
 
-    function addLiquiditySingleRawToken(
+    function addLiquiditySingleToken(
         address receiver,
         address market,
-        uint256 netRawTokenIn,
         uint256 minLpOut,
-        address[] calldata path,
-        ApproxParams memory guessPtReceivedFromScy
+        ApproxParams calldata guessPtReceivedFromScy,
+        TokenInput calldata input
     ) external returns (uint256 netLpOut) {
         require(false, "NOT IMPLEMENTED");
     }
 
     /// @dev refer to the internal function
-    function removeLiquidity(
+    function removeLiquidityDualScyAndPt(
         address receiver,
         address market,
         uint256 lpToRemove,
         uint256 scyOutMin,
         uint256 ptOutMin
     ) external returns (uint256 netScyOut, uint256 netPtOut) {
-        (netScyOut, netPtOut) = _removeLiquidity(
+        (netScyOut, netPtOut) = _removeLiquidityDualScyAndPt(
             receiver,
             market,
             lpToRemove,
             scyOutMin,
-            ptOutMin,
-            true
+            ptOutMin
+        );
+        emit RemoveLiquidityDualScyAndPt(
+            msg.sender,
+            market,
+            receiver,
+            lpToRemove,
+            netPtOut,
+            netScyOut
+        );
+    }
+
+    /// @dev refer to the internal function
+    function removeLiquidityDualIbTokenAndPt(
+        address receiver,
+        address market,
+        uint256 lpToRemove,
+        uint256 ibTokenMin,
+        uint256 ptOutMin
+    ) external returns (uint256 netIbTokenOut, uint256 netPtOut) {
+        (netIbTokenOut, netPtOut) = _removeLiquidityDualIbTokenAndPt(
+            receiver,
+            market,
+            lpToRemove,
+            ibTokenMin,
+            ptOutMin
+        );
+        emit RemoveLiquidityDualIbTokenAndPt(
+            msg.sender,
+            market,
+            receiver,
+            lpToRemove,
+            netPtOut,
+            netIbTokenOut
         );
-        emit RemoveLiquidity(msg.sender, market, receiver, lpToRemove, netPtOut, netScyOut);
     }
 
     function removeLiquiditySinglePt(
@@ -98,7 +160,7 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 lpToRemove,
         uint256 minPtOut,
-        ApproxParams memory guessPtOut
+        ApproxParams calldata guessPtOut
     ) external returns (uint256 netPtOut) {
         require(false, "NOT IMPLEMENTED");
     }
@@ -112,13 +174,12 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         require(false, "NOT IMPLEMENTED");
     }
 
-    function removeLiquiditySingleRawToken(
+    function removeLiquiditySingleToken(
         address receiver,
         address market,
         uint256 lpToRemove,
-        uint256 minRawTokenOut,
-        address[] memory path
-    ) external returns (uint256 netRawTokenOut) {
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
         require(false, "NOT IMPLEMENTED");
     }
 
@@ -139,7 +200,7 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 exactScyOut,
         uint256 maxPtIn,
-        ApproxParams memory guessPtIn
+        ApproxParams calldata guessPtIn
     ) external returns (uint256 netPtIn) {
         netPtIn = _swapPtForExactScy(receiver, market, exactScyOut, maxPtIn, guessPtIn, true);
         emit SwapPtAndScy(msg.sender, market, receiver, netPtIn.neg(), exactScyOut.Int());
@@ -162,71 +223,62 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
         address market,
         uint256 exactScyIn,
         uint256 minPtOut,
-        ApproxParams memory guessPtOut
+        ApproxParams calldata guessPtOut
     ) external returns (uint256 netPtOut) {
         netPtOut = _swapExactScyForPt(receiver, market, exactScyIn, minPtOut, guessPtOut, true);
         emit SwapPtAndScy(msg.sender, market, receiver, netPtOut.Int(), exactScyIn.neg());
     }
 
     /// @dev refer to the internal function
-    function mintScyFromRawToken(
+    function mintScyFromToken(
         address receiver,
         address SCY,
-        uint256 netRawTokenIn,
         uint256 minScyOut,
-        address[] calldata path
+        TokenInput calldata input
     ) external returns (uint256 netScyOut) {
-        return _mintScyFromRawToken(receiver, SCY, netRawTokenIn, minScyOut, path, true);
+        netScyOut = _mintScyFromToken(receiver, SCY, minScyOut, input);
+
+        emit MintScyFromToken(
+            msg.sender,
+            receiver,
+            SCY,
+            input.tokenIn,
+            input.netTokenIn,
+            netScyOut
+        );
     }
 
     /// @dev refer to the internal function
-    function redeemScyToRawToken(
+    function redeemScyToToken(
         address receiver,
         address SCY,
         uint256 netScyIn,
-        uint256 minRawTokenOut,
-        address[] memory path
-    ) external returns (uint256 netRawTokenOut) {
-        netRawTokenOut = _redeemScyToRawToken(receiver, SCY, netScyIn, minRawTokenOut, path, true);
-        emit RedeemScyToRawToken(
-            msg.sender,
-            receiver,
-            SCY,
-            netScyIn,
-            path[path.length - 1],
-            netRawTokenOut
-        );
+        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 mintPyFromRawToken(
+    function mintPyFromToken(
         address receiver,
         address YT,
-        uint256 netRawTokenIn,
         uint256 minPyOut,
-        address[] calldata path
+        TokenInput calldata input
     ) external returns (uint256 netPyOut) {
-        netPyOut = _mintPyFromRawToken(receiver, YT, netRawTokenIn, minPyOut, path, true);
-        emit MintPyFromRawToken(msg.sender, receiver, YT, path[0], netRawTokenIn, 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 redeemPyToRawToken(
+    function redeemPyToToken(
         address receiver,
         address YT,
         uint256 netPyIn,
-        uint256 minRawTokenOut,
-        address[] memory path
-    ) external returns (uint256 netRawTokenOut) {
-        netRawTokenOut = _redeemPyToRawToken(receiver, YT, netPyIn, minRawTokenOut, path, true);
-        emit RedeemPyToRawToken(
-            msg.sender,
-            receiver,
-            YT,
-            netPyIn,
-            path[path.length - 1],
-            netRawTokenOut
-        );
+        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(
@@ -250,57 +302,41 @@ contract ActionCore is IPActionCore, ActionSCYAndPTBase {
     }
 
     /// @dev refer to the internal function
-    function swapExactRawTokenForPt(
+    function swapExactTokenForPt(
         address receiver,
         address market,
-        uint256 exactRawTokenIn,
         uint256 minPtOut,
-        address[] calldata path,
-        ApproxParams memory guessPtOut
+        ApproxParams calldata guessPtOut,
+        TokenInput calldata input
     ) external returns (uint256 netPtOut) {
-        netPtOut = _swapExactRawTokenForPt(
-            receiver,
-            market,
-            exactRawTokenIn,
-            minPtOut,
-            path,
-            guessPtOut,
-            true
-        );
+        netPtOut = _swapExactTokenForPt(receiver, market, minPtOut, guessPtOut, input);
 
-        emit SwapPtAndRawToken(
+        emit SwapPtAndToken(
             msg.sender,
             market,
-            path[0],
+            input.tokenIn,
             receiver,
             netPtOut.Int(),
-            exactRawTokenIn.neg()
+            input.netTokenIn.neg()
         );
     }
 
     /// @dev refer to the internal function
-    function swapExactPtForRawToken(
+    function swapExactPtForToken(
         address receiver,
         address market,
         uint256 exactPtIn,
-        uint256 minRawTokenOut,
-        address[] calldata path
-    ) external returns (uint256 netRawTokenOut) {
-        netRawTokenOut = _swapExactPtForRawToken(
-            receiver,
-            market,
-            exactPtIn,
-            minRawTokenOut,
-            path,
-            true
-        );
-        emit SwapPtAndRawToken(
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        netTokenOut = _swapExactPtForToken(receiver, market, exactPtIn, output, true);
+
+        emit SwapPtAndToken(
             msg.sender,
             market,
-            path[path.length - 1],
+            output.tokenOut,
             receiver,
             exactPtIn.neg(),
-            netRawTokenOut.Int()
+            netTokenOut.Int()
         );
     }
 

package/contracts/core/actions/ActionYT.sol

@@ -12,12 +12,9 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
     using Math for int256;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _joeFactory)
-        ActionSCYAndPYBase(_joeFactory)
-    //solhint-disable-next-line no-empty-blocks
-    {
-
-    }
+    constructor(address _kyberSwapRouter)
+        ActionSCYAndPYBase(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    {}
 
     /// @dev refer to the internal function
     function swapExactYtForScy(
@@ -66,48 +63,31 @@ contract ActionYT is IPActionYT, ActionSCYAndYTBase {
     }
 
     /// @dev refer to the internal function
-    function swapExactRawTokenForYt(
+    function swapExactTokenForYt(
         address receiver,
         address market,
-        uint256 exactRawTokenIn,
         uint256 minYtOut,
-        address[] calldata path,
-        ApproxParams memory guessYtOut
+        ApproxParams memory guessYtOut,
+        TokenInput calldata input
     ) external returns (uint256 netYtOut) {
-        netYtOut = _swapExactRawTokenForYt(
+        netYtOut = _swapExactTokenForYt(receiver, market, minYtOut, guessYtOut, input);
+        emit SwapYTAndToken(
             receiver,
             market,
-            exactRawTokenIn,
-            minYtOut,
-            path,
-            guessYtOut,
-            true
+            input.tokenIn,
+            netYtOut.Int(),
+            input.netTokenIn.neg()
         );
-        emit SwapYTAndRawToken(receiver, market, path[0], netYtOut.Int(), exactRawTokenIn.neg());
     }
 
     /// @dev refer to the internal function
-    function swapExactYtForRawToken(
+    function swapExactYtForToken(
         address receiver,
         address market,
-        uint256 exactYtIn,
-        uint256 minRawTokenOut,
-        address[] calldata path
-    ) external returns (uint256 netRawTokenOut) {
-        netRawTokenOut = _swapExactYtForRawToken(
-            receiver,
-            market,
-            exactYtIn,
-            minRawTokenOut,
-            path,
-            true
-        );
-        emit SwapYTAndRawToken(
-            receiver,
-            market,
-            path[path.length - 1],
-            exactYtIn.neg(),
-            netRawTokenOut.Int()
-        );
+        uint256 netYtIn,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut) {
+        netTokenOut = _swapExactYtForToken(receiver, market, netYtIn, output, true);
+        emit SwapYTAndToken(receiver, market, output.tokenOut, netYtIn.neg(), netTokenOut.Int());
     }
 }