@pendle/core-v2 0.11.11-testnet → 0.12.1-testnet

package/contracts/core/actions/ActionMintRedeem.sol

@@ -4,6 +4,7 @@ pragma solidity 0.8.15;
 import "./base/ActionBaseMintRedeem.sol";
 import "../../interfaces/IPMarket.sol";
 import "../../interfaces/IPActionMintRedeem.sol";
+import "../../libraries/Errors.sol";
 
 contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     using MarketMathCore for MarketState;
@@ -143,8 +144,11 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         address[] calldata markets,
         RouterSwapAllStruct calldata dataSwap
     ) external returns (uint256 netTokenOut, uint256[] memory amountsSwapped) {
-        require(dataSwap.tokens.length == dataSwap.kybercalls.length, "invalid dataSwap");
-        require(dataYT.tokenRedeemScys.length == dataYT.scyAddrs.length, "invalid dataYT");
+        if (dataSwap.tokens.length != dataSwap.kybercalls.length)
+            revert Errors.ArrayLengthMismatch();
+
+        if (dataYT.tokenRedeemScys.length != dataYT.scyAddrs.length)
+            revert Errors.ArrayLengthMismatch();
 
         RouterTokenAmounts memory tokensOut = _newRouterTokenAmounts(dataSwap.tokens);
         RouterTokenAmounts memory scysOut = _newRouterTokenAmounts(dataYT.scyAddrs);
@@ -189,7 +193,7 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         netTokenOut = _swapAllToOutputToken(tokensOut, dataSwap);
 
         if (netTokenOut < dataSwap.minTokenOut)
-            require(netTokenOut < dataSwap.minTokenOut, "Insufficient Token Out");
+            revert Errors.RouterInsufficientTokenOut(netTokenOut, dataSwap.minTokenOut);
 
         amountsSwapped = tokensOut.amounts;
 
@@ -221,10 +225,12 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
             if (scys.amounts[i] == 0) continue;
 
             _transferFrom(scys.tokens[i], msg.sender, scys.tokens[i], scys.amounts[i]);
-            uint256 amountOut = ISuperComposableYield(scys.tokens[i]).redeemAfterTransfer(
+            uint256 amountOut = ISuperComposableYield(scys.tokens[i]).redeem(
                 address(this),
+                scys.amounts[i],
                 tokenRedeemScys[i],
-                1
+                1,
+                true
             );
 
             _addTokenAmount(tokensOut, tokenRedeemScys[i], amountOut);

package/contracts/core/actions/ActionMisc.sol

@@ -3,6 +3,7 @@ pragma solidity 0.8.15;
 
 import "../../interfaces/IPMarket.sol";
 import "../../interfaces/IPActionMisc.sol";
+import "../../libraries/Errors.sol";
 
 contract ActionMisc is IPActionMisc {
     using Math for uint256;
@@ -12,7 +13,7 @@ contract ActionMisc is IPActionMisc {
         view
         returns (uint96 lnImpliedRateMean)
     {
-        require(secondsAgo != 0, "time range is zero");
+        if (secondsAgo == 0) revert Errors.RouterTimeRangeZero();
         uint32[] memory secondsAgos = new uint32[](2);
         secondsAgos[0] = secondsAgo;
         secondsAgos[1] = 0;

package/contracts/core/actions/ActionSwapPT.sol

@@ -4,6 +4,7 @@ pragma solidity 0.8.15;
 import "./base/ActionBaseMintRedeem.sol";
 import "../../interfaces/IPActionSwapPT.sol";
 import "../../interfaces/IPMarket.sol";
+import "../../libraries/Errors.sol";
 
 contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
     using MarketMathCore for MarketState;
@@ -24,13 +25,17 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
         address market,
         uint256 exactPtIn,
         uint256 minScyOut
-    ) external returns (uint256 netScyOut) {
+    ) external returns (uint256 netScyOut, uint256 netScyFee) {
         (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
         IERC20(address(PT)).safeTransferFrom(msg.sender, market, exactPtIn);
 
-        (netScyOut, ) = IPMarket(market).swapExactPtForScy(receiver, exactPtIn, EMPTY_BYTES);
+        (netScyOut, netScyFee) = IPMarket(market).swapExactPtForScy(
+            receiver,
+            exactPtIn,
+            EMPTY_BYTES
+        );
 
-        require(netScyOut >= minScyOut, "insufficient SCY out");
+        if (netScyOut < minScyOut) revert Errors.RouterInsufficientScyOut(netScyOut, minScyOut);
 
         emit SwapPtAndScy(msg.sender, market, receiver, exactPtIn.neg(), netScyOut.Int());
     }
@@ -45,7 +50,7 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
         uint256 exactScyOut,
         uint256 maxPtIn,
         ApproxParams calldata guessPtIn
-    ) external returns (uint256 netPtIn) {
+    ) external returns (uint256 netPtIn, uint256 netScyFee) {
         MarketState memory state = IPMarket(market).readState();
         (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
 
@@ -55,14 +60,20 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
             block.timestamp,
             guessPtIn
         );
-        require(netPtIn <= maxPtIn, "exceed limit PT in");
+
+        if (netPtIn > maxPtIn) revert Errors.RouterExceededLimitPtIn(netPtIn, maxPtIn);
 
         IERC20(PT).safeTransferFrom(msg.sender, market, netPtIn);
 
-        (uint256 netScyOut, ) = IPMarket(market).swapExactPtForScy(receiver, netPtIn, EMPTY_BYTES);
+        uint256 netScyOut;
+        (netScyOut, netScyFee) = IPMarket(market).swapExactPtForScy(
+            receiver,
+            netPtIn,
+            EMPTY_BYTES
+        );
 
         // fail-safe
-        require(netScyOut >= exactScyOut, "FS insufficient SCY out");
+        if (netScyOut < exactScyOut) assert(false);
 
         emit SwapPtAndScy(msg.sender, market, receiver, netPtIn.neg(), exactScyOut.Int());
     }
@@ -72,17 +83,17 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
         address market,
         uint256 exactPtOut,
         uint256 maxScyIn
-    ) external returns (uint256 netScyIn) {
+    ) external returns (uint256 netScyIn, uint256 netScyFee) {
         MarketState memory state = IPMarket(market).readState();
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         (netScyIn, ) = state.swapScyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
 
-        require(netScyIn <= maxScyIn, "exceed limit SCY in");
+        if (netScyIn > maxScyIn) revert Errors.RouterExceededLimitScyIn(netScyIn, maxScyIn);
 
         IERC20(SCY).safeTransferFrom(msg.sender, market, netScyIn);
 
-        IPMarket(market).swapScyForExactPt(receiver, exactPtOut, EMPTY_BYTES); // ignore return
+        (, netScyFee) = IPMarket(market).swapScyForExactPt(receiver, exactPtOut, EMPTY_BYTES); // ignore return
 
         // no fail-safe since exactly netScyIn will go into the market
         emit SwapPtAndScy(msg.sender, market, receiver, exactPtOut.Int(), netScyIn.neg());
@@ -94,12 +105,19 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
         uint256 exactScyIn,
         uint256 minPtOut,
         ApproxParams calldata guessPtOut
-    ) external returns (uint256 netPtOut) {
+    ) external returns (uint256 netPtOut, uint256 netScyFee) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         IERC20(SCY).safeTransferFrom(msg.sender, market, exactScyIn);
 
-        netPtOut = _swapExactScyForPt(receiver, market, YT, exactScyIn, minPtOut, guessPtOut);
+        (netPtOut, netScyFee) = _swapExactScyForPt(
+            receiver,
+            market,
+            YT,
+            exactScyIn,
+            minPtOut,
+            guessPtOut
+        );
 
         emit SwapPtAndScy(msg.sender, market, receiver, netPtOut.Int(), exactScyIn.neg());
     }
@@ -115,14 +133,14 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
         uint256 minPtOut,
         ApproxParams calldata guessPtOut,
         TokenInput calldata input
-    ) external payable returns (uint256 netPtOut) {
+    ) external payable returns (uint256 netPtOut, uint256 netScyFee) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         // all output SCY is transferred directly to the market
         uint256 netScyUseToBuyPt = _mintScyFromToken(address(market), address(SCY), 1, input);
 
         // SCY is already in the market, hence doPull = false
-        netPtOut = _swapExactScyForPt(
+        (netPtOut, netScyFee) = _swapExactScyForPt(
             receiver,
             market,
             YT,
@@ -150,13 +168,14 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
         address market,
         uint256 exactPtIn,
         TokenOutput calldata output
-    ) external returns (uint256 netTokenOut) {
+    ) external returns (uint256 netTokenOut, uint256 netScyFee) {
         (ISuperComposableYield SCY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
         IERC20(address(PT)).safeTransferFrom(msg.sender, market, exactPtIn);
 
         // all output SCY is directly transferred to the SCY contract
-        (uint256 netScyReceived, ) = IPMarket(market).swapExactPtForScy(
+        uint256 netScyReceived;
+        (netScyReceived, netScyFee) = IPMarket(market).swapExactPtForScy(
             address(SCY),
             exactPtIn,
             EMPTY_BYTES
@@ -182,7 +201,7 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
         uint256 exactScyIn,
         uint256 minPtOut,
         ApproxParams calldata guessPtOut
-    ) internal returns (uint256 netPtOut) {
+    ) internal returns (uint256 netPtOut, uint256 netScyFee) {
         MarketState memory state = IPMarket(market).readState();
 
         (netPtOut, , ) = state.approxSwapExactScyForPt(
@@ -192,9 +211,9 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
             guessPtOut
         );
 
-        require(netPtOut >= minPtOut, "insufficient PT out");
+        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
 
-        IPMarket(market).swapScyForExactPt(receiver, netPtOut, EMPTY_BYTES); // ignore return
+        (, netScyFee) = IPMarket(market).swapScyForExactPt(receiver, netPtOut, EMPTY_BYTES);
         // no fail-safe since exactly netPtOut >= minPtOut will be out
     }
 }

package/contracts/core/actions/ActionSwapPTYT.sol

@@ -29,21 +29,22 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper {
         uint256 exactPtIn,
         uint256 minYtOut,
         ApproxParams calldata guessTotalPtToSwap
-    ) external returns (uint256 netYtOut) {
+    ) external returns (uint256 netYtOut, uint256 netScyFee) {
         (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
         MarketState memory state = IPMarket(market).readState();
 
         PT.safeTransferFrom(msg.sender, market, exactPtIn);
 
         uint256 totalPtToSwap;
-        (netYtOut, , totalPtToSwap, ) = state.approxSwapExactPtForYt(
+        (netYtOut, , totalPtToSwap, netScyFee) = state.approxSwapExactPtForYt(
             YT.newIndex(),
             exactPtIn,
             block.timestamp,
             guessTotalPtToSwap
         );
 
-        require(netYtOut >= minYtOut, "insufficient YT out");
+        if (netYtOut < minYtOut) revert Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
+
         IPMarket(market).swapExactPtForScy(
             address(YT),
             totalPtToSwap,
@@ -59,21 +60,21 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper {
         uint256 exactYtIn,
         uint256 minPtOut,
         ApproxParams calldata guessTotalPtSwapped
-    ) external returns (uint256 netPtOut) {
+    ) external returns (uint256 netPtOut, uint256 netScyFee) {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
         MarketState memory state = IPMarket(market).readState();
 
         YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
 
         uint256 totalPtSwapped;
-        (netPtOut, , totalPtSwapped, ) = state.approxSwapExactYtForPt(
+        (netPtOut, , totalPtSwapped, netScyFee) = state.approxSwapExactYtForPt(
             YT.newIndex(),
             exactYtIn,
             block.timestamp,
             guessTotalPtSwapped
         );
 
-        require(netPtOut >= minPtOut, "insufficient PT out");
+        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
 
         IPMarket(market).swapScyForExactPt(
             address(this),

package/contracts/core/actions/ActionSwapYT.sol

@@ -5,6 +5,7 @@ import "./base/ActionBaseMintRedeem.sol";
 import "./base/CallbackHelper.sol";
 import "../../interfaces/IPActionSwapYT.sol";
 import "../../interfaces/IPMarket.sol";
+import "../../libraries/Errors.sol";
 
 contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     using Math for uint256;
@@ -37,12 +38,19 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         uint256 exactScyIn,
         uint256 minYtOut,
         ApproxParams memory guessYtOut
-    ) external returns (uint256 netYtOut) {
+    ) external returns (uint256 netYtOut, uint256 netScyFee) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         SCY.safeTransferFrom(msg.sender, address(YT), exactScyIn);
 
-        netYtOut = _swapExactScyForYt(receiver, market, YT, exactScyIn, minYtOut, guessYtOut);
+        (netYtOut, netScyFee) = _swapExactScyForYt(
+            receiver,
+            market,
+            YT,
+            exactScyIn,
+            minYtOut,
+            guessYtOut
+        );
 
         emit SwapYtAndScy(msg.sender, market, receiver, netYtOut.Int(), exactScyIn.neg());
     }
@@ -62,12 +70,19 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         address market,
         uint256 exactYtIn,
         uint256 minScyOut
-    ) external returns (uint256 netScyOut) {
+    ) external returns (uint256 netScyOut, uint256 netScyFee) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
 
-        netScyOut = _swapExactYtForScy(receiver, market, SCY, YT, exactYtIn, minScyOut);
+        (netScyOut, netScyFee) = _swapExactYtForScy(
+            receiver,
+            market,
+            SCY,
+            YT,
+            exactYtIn,
+            minScyOut
+        );
 
         emit SwapYtAndScy(msg.sender, market, receiver, exactYtIn.neg(), netScyOut.Int());
     }
@@ -86,12 +101,12 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         address market,
         uint256 exactYtOut,
         uint256 maxScyIn
-    ) external returns (uint256 netScyIn) {
+    ) external returns (uint256 netScyIn, uint256 netScyFee) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         uint256 preScyBalance = SCY.balanceOf(msg.sender);
 
-        IPMarket(market).swapExactPtForScy(
+        (, netScyFee) = IPMarket(market).swapExactPtForScy(
             address(YT),
             exactYtOut, // exactPtIn = exactYtOut
             _encodeSwapScyForExactYt(msg.sender, receiver, maxScyIn)
@@ -118,7 +133,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         uint256 exactScyOut,
         uint256 maxYtIn,
         ApproxParams memory guessYtIn
-    ) external returns (uint256 netYtIn) {
+    ) external returns (uint256 netYtIn, uint256 netScyFee) {
         MarketState memory state = IPMarket(market).readState();
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
@@ -129,15 +144,15 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
             guessYtIn
         );
 
-        require(netYtIn <= maxYtIn, "exceed YT in limit");
+        if (netYtIn > maxYtIn) revert Errors.RouterExceededLimitYtIn(netYtIn, maxYtIn);
 
         YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
 
-        IPMarket(market).swapScyForExactPt(
+        (, netScyFee) = IPMarket(market).swapScyForExactPt(
             address(YT),
             netYtIn, // exactPtOut = netYtIn
             _encodeSwapYtForScy(receiver, exactScyOut)
-        ); // ignore return
+        );
 
         emit SwapYtAndScy(msg.sender, market, receiver, netYtIn.neg(), exactScyOut.Int());
     }
@@ -148,12 +163,12 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         uint256 minYtOut,
         ApproxParams memory guessYtOut,
         TokenInput calldata input
-    ) external payable returns (uint256 netYtOut) {
+    ) external payable returns (uint256 netYtOut, uint256 netScyFee) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         uint256 netScyUsedToBuyYT = _mintScyFromToken(address(YT), address(SCY), 1, input);
 
-        netYtOut = _swapExactScyForYt(
+        (netYtOut, netScyFee) = _swapExactScyForYt(
             receiver,
             market,
             YT,
@@ -177,12 +192,14 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         address market,
         uint256 netYtIn,
         TokenOutput calldata output
-    ) external returns (uint256 netTokenOut) {
+    ) external returns (uint256 netTokenOut, uint256 netScyFee) {
         (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
         YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
 
-        uint256 netScyOut = _swapExactYtForScy(address(SCY), market, SCY, YT, netYtIn, 1);
+        uint256 netScyOut;
+
+        (netScyOut, netScyFee) = _swapExactYtForScy(address(SCY), market, SCY, YT, netYtIn, 1);
 
         netTokenOut = _redeemScyToToken(receiver, address(SCY), netScyOut, output, false);
 
@@ -203,7 +220,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         uint256 exactScyIn,
         uint256 minYtOut,
         ApproxParams memory guessYtOut
-    ) internal returns (uint256 netYtOut) {
+    ) internal returns (uint256 netYtOut, uint256 netScyFee) {
         MarketState memory state = IPMarket(market).readState();
 
         (netYtOut, , ) = state.approxSwapExactScyForYt(
@@ -214,9 +231,9 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         );
 
         // early-check
-        require(netYtOut >= minYtOut, "insufficient YT out");
+        if (netYtOut < minYtOut) revert Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
 
-        IPMarket(market).swapExactPtForScy(
+        (, netScyFee) = IPMarket(market).swapExactPtForScy(
             address(YT),
             netYtOut, // exactPtIn = netYtOut
             _encodeSwapExactScyForYt(receiver, minYtOut)
@@ -230,10 +247,10 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         IPYieldToken YT,
         uint256 exactYtIn,
         uint256 minScyOut
-    ) internal returns (uint256 netScyOut) {
+    ) internal returns (uint256 netScyOut, uint256 netScyFee) {
         uint256 preScyBalance = SCY.balanceOf(receiver);
 
-        IPMarket(market).swapScyForExactPt(
+        (, netScyFee) = IPMarket(market).swapScyForExactPt(
             address(YT),
             exactYtIn, // exactPtOut = exactYtIn
             _encodeSwapYtForScy(receiver, minScyOut)

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

@@ -5,6 +5,7 @@ import "../../../libraries/kyberswap/KyberSwapHelper.sol";
 import "../../../libraries/helpers/TokenHelper.sol";
 import "../../../interfaces/ISuperComposableYield.sol";
 import "../../../interfaces/IPYieldToken.sol";
+import "../../../libraries/Errors.sol";
 
 // solhint-disable no-empty-blocks
 abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
@@ -57,21 +58,27 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         }
 
         if (output.tokenRedeemScy == output.tokenOut) {
-            netTokenOut = ISuperComposableYield(SCY).redeemAfterTransfer(
+            netTokenOut = ISuperComposableYield(SCY).redeem(
                 receiver,
+                netScyIn,
                 output.tokenRedeemScy,
-                output.minTokenOut
+                output.minTokenOut,
+                true
             );
         } else {
-            uint256 netTokenRedeemed = ISuperComposableYield(SCY).redeemAfterTransfer(
+            uint256 netTokenRedeemed = ISuperComposableYield(SCY).redeem(
                 address(this),
+                netScyIn,
                 output.tokenRedeemScy,
-                1
+                1,
+                true
             );
             _kyberswap(output.tokenRedeemScy, netTokenRedeemed, output.kybercall);
 
             netTokenOut = _selfBalance(output.tokenOut);
-            require(netTokenOut >= output.minTokenOut, "insufficient out");
+
+            if (netTokenOut < output.minTokenOut)
+                revert Errors.RouterInsufficientTokenOut(netTokenOut, output.minTokenOut);
 
             _transferOut(output.tokenOut, receiver, netTokenOut);
         }
@@ -91,7 +98,7 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         _mintScyFromToken(YT, SCY, 1, input);
 
         netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
-        require(netPyOut >= minPyOut, "insufficient PY out");
+        if (netPyOut < minPyOut) revert Errors.RouterInsufficientPYOut(netPyOut, minPyOut);
     }
 
     /**
@@ -133,7 +140,7 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         }
 
         netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
-        require(netPyOut >= minPyOut, "insufficient PY out");
+        if (netPyOut < minPyOut) revert Errors.RouterInsufficientPYOut(netPyOut, minPyOut);
     }
 
     function _redeemPyToScy(
@@ -152,6 +159,6 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
         }
 
         netScyOut = IPYieldToken(YT).redeemPY(receiver);
-        require(netScyOut >= minScyOut, "insufficient SCY out");
+        if (netScyOut < minScyOut) revert Errors.RouterInsufficientScyOut(netScyOut, minScyOut);
     }
 }

package/contracts/interfaces/ConvexCurve/IBooster.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface IBooster {
+    function crv() external view returns (address);
+
+    function poolLength() external view returns (uint256);
+
+    function poolInfo(uint256)
+        external
+        view
+        returns (
+            address,
+            address,
+            address,
+            address,
+            address,
+            bool
+        );
+
+    function deposit(
+        uint256 _pid,
+        uint256 _amount,
+        bool _stake
+    ) external returns (bool);
+
+    function depositAll(uint256 _pid, bool _stake) external returns (bool);
+
+    function withdraw(uint256 _pid, uint256 _amount) external returns (bool);
+
+    function withdrawAll(uint256 _pid) external returns (bool);
+}

package/contracts/interfaces/ConvexCurve/ICrvDepositor.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface ICrvDepositor {
+    function crv() external view returns (address);
+
+    function minter() external view returns (address);
+
+    function deposit(
+        uint256 _amount,
+        bool _lock,
+        address _stakeAddress
+    ) external;
+
+    //deposit crv for cvxCrv
+    //can locking immediately or defer locking to someone else by paying a fee.
+    //while users can choose to lock or defer, this is mostly in place so that
+    //the cvx reward contract isnt costly to claim rewards
+    function depositAll(bool _lock, address _stakeAddress) external;
+}

package/contracts/interfaces/ConvexCurve/ICvxCrv.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface ICvxCrv {
+    function operator() external view returns (address);
+}

package/contracts/interfaces/ConvexCurve/IRewards.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface IRewards {
+    function operator() external view returns (address);
+
+    function stake(address, uint256) external;
+
+    function stakeFor(address, uint256) external;
+
+    function withdraw(uint256, bool) external returns (bool);
+
+    function withdrawAndUnwrap(uint256, bool) external returns (bool);
+
+    function exit(address) external;
+
+    function getReward() external;
+
+    function queueNewRewards(uint256) external;
+
+    function notifyRewardAmount(uint256) external;
+
+    function addExtraReward(address) external;
+
+    function rewardToken() external returns (address);
+
+    function rewardPerToken() external returns (uint256);
+
+    function rewardPerTokenStored() external view returns (uint256);
+
+    function extraRewardsLength() external view returns (uint256);
+
+    function extraRewards(uint256) external returns (address);
+
+    function stakingToken() external returns (address);
+
+    function lastTimeRewardApplicable() external view returns (uint256);
+}

package/contracts/interfaces/Curve/ICrvPool.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+interface ICrvPool {
+    function get_virtual_price() external view returns (uint256);
+
+    function get_dy(
+        int128 i,
+        int128 j,
+        uint256 dx // The amount of i being exchanged.
+    ) external view returns (uint256);
+
+    function exchange(
+        int128 i,
+        int128 j,
+        uint256 dx,
+        uint256 min_dy, // The amount of i being exchanged.
+        address _receiver
+    ) external returns (uint256);
+
+    function add_liquidity(
+        uint256[] memory _deposit_amount,
+        uint256 _min_amount,
+        address _receiver
+    ) external returns (uint256);
+
+    function add_liquidity(
+        uint256[2] memory _deposit_amount,
+        uint256 _min_amount
+    ) external;
+
+    function add_liquidity(
+        uint256[3] memory _deposit_amount,
+        uint256 _min_amount
+    ) external;
+
+    function remove_liquidity(
+        uint256 _burn_amount,
+        uint256[] memory _min_amounts,
+        address _receiver
+    ) external returns (uint256[] memory);
+
+    function remove_liquidity_one_coin(
+        uint256 _burn_amount,
+        int128 i,
+        uint256 _min_amount
+    ) external;
+
+    function calc_token_amount(uint256[] memory _amounts, bool _is_deposit)
+        external
+        view
+        returns (uint256);
+
+    function calc_token_amount(uint256[2] memory _amounts, bool _is_deposit)
+        external
+        view
+        returns (uint256);
+
+    function calc_token_amount(uint256[3] memory _amounts, bool _is_deposit)
+        external
+        view
+        returns (uint256);
+
+
+    function calc_withdraw_one_coin(uint256 _burn_amount, int128 i)
+        external
+        view
+        returns (uint256);
+}