@pendle/core-v2 0.15.0-mainnet → 0.15.2-mainnet

package/contracts/router/ActionAddRemoveLiq.sol

@@ -12,12 +12,12 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     using MarketMathCore for MarketState;
     using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;
-    using SafeERC20 for IERC20;
     using PYIndexLib for IPYieldToken;
+    using BulkSellerMathCore for BulkSellerState;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberSwapRouter)
-        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberScalingLib)
+        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
     {}
 
     function addLiquidityDualSyAndPt(
@@ -36,6 +36,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     {
         (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
+        // calculate the amount of SY and PT to be used
         MarketState memory state = IPMarket(market).readState();
         (, netLpOut, netSyUsed, netPtUsed) = state.addLiquidity(
             netSyDesired,
@@ -46,8 +47,9 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         // early-check
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
 
-        IERC20(SY).safeTransferFrom(msg.sender, market, netSyUsed);
-        IERC20(PT).safeTransferFrom(msg.sender, market, netPtUsed);
+        // execute the addLiquidity
+        _transferFrom(IERC20(SY), msg.sender, market, netSyUsed);
+        _transferFrom(IERC20(PT), msg.sender, market, netPtUsed);
 
         (netLpOut, , ) = IPMarket(market).mint(receiver, netSyUsed, netPtUsed);
 
@@ -57,11 +59,13 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         emit AddLiquidityDualSyAndPt(msg.sender, market, receiver, netSyUsed, netPtUsed, netLpOut);
     }
 
+    /**
+     * @dev this function assumes that netTokenDesired = netTokenUsed, and fails if this does not hold
+     */
     function addLiquidityDualTokenAndPt(
         address receiver,
         address market,
-        address tokenIn,
-        uint256 netTokenDesired,
+        TokenInput calldata input,
         uint256 netPtDesired,
         uint256 minLpOut
     )
@@ -75,45 +79,38 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     {
         (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
-        uint256 netSyDesired = SY.previewDeposit(tokenIn, netTokenDesired);
+        uint256 netSyDesired = _mintSyFromToken(market, address(SY), 1, input);
         uint256 netSyUsed;
 
         {
+            // calc the amount of SY and PT to be used
             MarketState memory state = IPMarket(market).readState();
             (, netLpOut, netSyUsed, netPtUsed) = state.addLiquidity(
                 netSyDesired,
                 netPtDesired,
                 block.timestamp
             );
-        }
-
-        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
-
-        IERC20(PT).safeTransferFrom(msg.sender, market, netPtUsed);
 
-        // convert tokenIn to SY to deposit
-        netTokenUsed = (netTokenDesired * netSyUsed).rawDivUp(netSyDesired);
+            if (netSyDesired != netSyUsed)
+                revert Errors.RouterNotAllSyUsed(netSyDesired, netSyUsed);
+            if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
 
-        if (tokenIn == NATIVE) {
-            _transferIn(tokenIn, msg.sender, netTokenDesired);
-            SY.deposit{ value: netTokenUsed }(market, tokenIn, netTokenUsed, netSyUsed);
-            _transferOut(tokenIn, msg.sender, netTokenDesired - netTokenUsed);
-        } else {
-            _transferIn(tokenIn, msg.sender, netTokenUsed);
-            _safeApproveInf(tokenIn, address(SY));
-            SY.deposit(market, tokenIn, netTokenUsed, netSyUsed);
+            netTokenUsed = input.netTokenIn;
         }
 
+        // SY has been minted and transferred to the market
+        _transferFrom(IERC20(PT), msg.sender, market, netPtUsed);
         (netLpOut, , ) = IPMarket(market).mint(receiver, netSyUsed, netPtUsed);
 
+        // fail-safe
         if (netLpOut < minLpOut) assert(false);
 
         emit AddLiquidityDualTokenAndPt(
             msg.sender,
             market,
             receiver,
-            tokenIn,
-            netTokenDesired,
+            input.tokenIn,
+            netTokenUsed,
             netPtUsed,
             netLpOut
         );
@@ -128,6 +125,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     ) external returns (uint256 netLpOut, uint256 netSyFee) {
         (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
 
+        // calculate the amount of PT to swap
         MarketState memory state = IPMarket(market).readState();
 
         (uint256 netPtSwap, , ) = state.approxSwapPtToAddLiquidity(
@@ -137,15 +135,17 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             guessPtSwapToSy
         );
 
-        IERC20(PT).safeTransferFrom(msg.sender, market, netPtIn);
+        // execute the swap
+        _transferFrom(IERC20(PT), msg.sender, market, netPtIn);
 
         uint256 netSyReceived;
         (netSyReceived, netSyFee) = IPMarket(market).swapExactPtForSy(
             market,
             netPtSwap,
             EMPTY_BYTES
-        ); // ignore return, receiver = market
+        );
 
+        // execute the addLiquidity
         (netLpOut, , ) = IPMarket(market).mint(receiver, netSyReceived, netPtIn - netPtSwap);
 
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
@@ -161,8 +161,11 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         ApproxParams calldata guessPtReceivedFromSy
     ) external returns (uint256 netLpOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
-        IERC20(SY).safeTransferFrom(msg.sender, market, netSyIn);
 
+        // transfer SY to market
+        _transferFrom(IERC20(SY), msg.sender, market, netSyIn);
+
+        // mint LP
         (netLpOut, netSyFee) = _addLiquiditySingleSy(
             receiver,
             market,
@@ -184,9 +187,10 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     ) external payable returns (uint256 netLpOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        // all output SY is transferred directly to the market
-        uint256 netSyUsed = _mintSyFromToken(address(market), address(SY), 1, input);
+        // mint SY directly to the market
+        uint256 netSyUsed = _mintSyFromToken(market, address(SY), 1, input);
 
+        // mint LP
         (netLpOut, netSyFee) = _addLiquiditySingleSy(
             receiver,
             market,
@@ -213,7 +217,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         uint256 minSyOut,
         uint256 minPtOut
     ) external returns (uint256 netSyOut, uint256 netPtOut) {
-        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
+        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
 
         (netSyOut, netPtOut) = IPMarket(market).burn(receiver, receiver, netLpToRemove);
 
@@ -234,28 +238,33 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         address receiver,
         address market,
         uint256 netLpToRemove,
-        address tokenOut,
-        uint256 minTokenOut,
+        TokenOutput calldata output,
         uint256 minPtOut
     ) external returns (uint256 netTokenOut, uint256 netPtOut) {
         (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
 
-        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
+        // burn LP, SY sent to either SY or bulk, PT sent to receiver
+        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
 
         uint256 netSyOut;
-        (netSyOut, netPtOut) = IPMarket(market).burn(address(SY), receiver, netLpToRemove);
-
-        netTokenOut = SY.redeem(receiver, netSyOut, tokenOut, minTokenOut, true);
+        (netSyOut, netPtOut) = IPMarket(market).burn(
+            _syOrBulk(address(SY), output),
+            receiver,
+            netLpToRemove
+        );
 
         if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
 
+        // redeem SY to token
+        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyOut, output, false);
+
         emit RemoveLiquidityDualTokenAndPt(
             msg.sender,
             market,
             receiver,
             netLpToRemove,
             netPtOut,
-            tokenOut,
+            output.tokenOut,
             netTokenOut
         );
     }
@@ -269,8 +278,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     ) external returns (uint256 netPtOut, uint256 netSyFee) {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
-
+        // calculate the total amount of PT received from burning & selling SY
         MarketState memory state = IPMarket(market).readState();
         (uint256 syFromBurn, uint256 ptFromBurn) = state.removeLiquidity(netLpToRemove);
         (uint256 ptFromSwap, ) = state.approxSwapExactSyForPt(
@@ -283,14 +291,17 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         if (ptFromBurn + ptFromSwap < minPtOut)
             revert Errors.RouterInsufficientPtOut(ptFromBurn + ptFromSwap, minPtOut);
 
+        // execute the burn & the swap
+        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
+
         (, ptFromBurn) = IPMarket(market).burn(market, receiver, netLpToRemove);
         (, netSyFee) = IPMarket(market).swapSyForExactPt(receiver, ptFromSwap, EMPTY_BYTES);
 
-        // fail-safe
-        if (ptFromBurn + ptFromSwap < minPtOut) assert(false);
-
         netPtOut = ptFromBurn + ptFromSwap;
 
+        // fail-safe
+        if (netPtOut < minPtOut) assert(false);
+
         emit RemoveLiquiditySinglePt(msg.sender, market, receiver, netLpToRemove, netPtOut);
     }
 
@@ -300,8 +311,12 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         uint256 netLpToRemove,
         uint256 minSyOut
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
-        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
+        // transfer LP to market
+        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
+
+        // burn LP, SY sent to receiver
         (netSyOut, netSyFee) = _removeLiquiditySingleSy(receiver, market, netLpToRemove, minSyOut);
+
         emit RemoveLiquiditySingleSy(msg.sender, market, receiver, netLpToRemove, netSyOut);
     }
 
@@ -313,19 +328,19 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     ) external returns (uint256 netTokenOut, uint256 netSyFee) {
         (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
 
-        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
+        // transfer LP to market, burn LP, SY sent to either SY or bulk
+        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
 
-        // all output SY is directly transferred to the SY contract
         uint256 netSyReceived;
 
         (netSyReceived, netSyFee) = _removeLiquiditySingleSy(
-            address(SY),
+            _syOrBulk(address(SY), output),
             market,
             netLpToRemove,
             1
         );
 
-        // since all SY is already at the SY contract, doPull = false
+        // redeem SY to token
         netTokenOut = _redeemSyToToken(receiver, address(SY), netSyReceived, output, false);
 
         emit RemoveLiquiditySingleToken(
@@ -348,20 +363,23 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     ) internal returns (uint256 netLpOut, uint256 netSyFee) {
         MarketState memory state = IPMarket(market).readState();
 
-        (uint256 netPtReceived, , ) = state.approxSwapSyToAddLiquidity(
+        // calculate the PT amount needed to add liquidity
+        (uint256 netPtFromSwap, , ) = state.approxSwapSyToAddLiquidity(
             YT.newIndex(),
             netSyIn,
             block.timestamp,
             guessPtReceivedFromSy
         );
 
+        // execute the swap & the addLiquidity
         uint256 netSySwapped;
         (netSySwapped, netSyFee) = IPMarket(market).swapSyForExactPt(
             market,
-            netPtReceived,
+            netPtFromSwap,
             EMPTY_BYTES
-        ); // ignore return, receiver = market
-        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyIn - netSySwapped, netPtReceived);
+        );
+
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyIn - netSySwapped, netPtFromSwap);
 
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
     }
@@ -408,6 +426,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             ptFromBurn,
             EMPTY_BYTES
         );
+
         netSyOut = syFromBurn + syFromSwap;
     }
 }

package/contracts/router/ActionCallback.sol

@@ -12,13 +12,9 @@ import "./base/CallbackHelper.sol";
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
+contract ActionCallback is IPMarketSwapCallback, CallbackHelper, TokenHelper {
     using Math for int256;
     using Math for uint256;
-    using SafeERC20 for IStandardizedYield;
-    using SafeERC20 for IPYieldToken;
-    using SafeERC20 for IPPrincipalToken;
-    using SafeERC20 for IERC20;
     using PYIndexLib for PYIndex;
     using PYIndexLib for IPYieldToken;
 
@@ -114,7 +110,7 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         /// mint & transfer
         /// ------------------------------------------------------------
         if (netSyToPull > 0) {
-            SY.safeTransferFrom(vars.payer, address(YT), netSyToPull);
+            _transferFrom(IERC20(SY), vars.payer, address(YT), netSyToPull);
         }
 
         uint256 netPyOut = YT.mintPY(market, vars.receiver);
@@ -175,7 +171,7 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
 
         uint256 netSyOwed = syToAccount.abs();
 
-        PT.safeTransfer(address(YT), exactYtIn);
+        _transferOut(address(PT), address(YT), exactYtIn);
         uint256 netSyToMarket = YT.redeemPY(market);
 
         if (netSyToMarket < netSyOwed)
@@ -184,6 +180,6 @@ contract ActionCallback is IPMarketSwapCallback, CallbackHelper {
         uint256 netPtOut = ptToAccount.Uint() - exactYtIn;
         if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
 
-        PT.safeTransfer(receiver, netPtOut);
+        _transferOut(address(PT), receiver, netPtOut);
     }
 }

package/contracts/router/ActionMintRedeem.sol

@@ -10,14 +10,12 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     using MarketMathCore for MarketState;
     using Math for uint256;
     using Math for int256;
-    using SafeERC20 for IERC20;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberSwapRouter)
-        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberScalingLib)
+        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
     {}
 
-    /// @dev refer to the internal function
     function mintSyFromToken(
         address receiver,
         address SY,
@@ -25,11 +23,9 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         TokenInput calldata input
     ) external payable returns (uint256 netSyOut) {
         netSyOut = _mintSyFromToken(receiver, SY, minSyOut, input);
-
         emit MintSyFromToken(msg.sender, receiver, SY, input.tokenIn, input.netTokenIn, netSyOut);
     }
 
-    /// @dev refer to the internal function
     function redeemSyToToken(
         address receiver,
         address SY,
@@ -40,25 +36,31 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         emit RedeemSyToToken(msg.sender, receiver, SY, netSyIn, output.tokenOut, netTokenOut);
     }
 
-    /// @dev refer to the internal function
     function mintPyFromToken(
         address receiver,
         address YT,
         uint256 minPyOut,
         TokenInput calldata input
     ) external payable returns (uint256 netPyOut) {
-        netPyOut = _mintPyFromToken(receiver, YT, minPyOut, input);
+        address SY = IPYieldToken(YT).SY();
+
+        uint256 netSyToMint = _mintSyFromToken(YT, SY, 0, input);
+        netPyOut = _mintPyFromSy(receiver, YT, netSyToMint, minPyOut, false);
+
         emit MintPyFromToken(msg.sender, receiver, YT, input.tokenIn, input.netTokenIn, netPyOut);
     }
 
-    /// @dev refer to the internal function
     function redeemPyToToken(
         address receiver,
         address YT,
         uint256 netPyIn,
         TokenOutput calldata output
     ) external returns (uint256 netTokenOut) {
-        netTokenOut = _redeemPyToToken(receiver, YT, netPyIn, output, true);
+        address SY = IPYieldToken(YT).SY();
+
+        uint256 netSyToRedeem = _redeemPyToSy(_syOrBulk(SY, output), YT, netPyIn, 1);
+        netTokenOut = _redeemSyToToken(receiver, SY, netSyToRedeem, output, false);
+
         emit RedeemPyToToken(msg.sender, receiver, YT, netPyIn, output.tokenOut, netTokenOut);
     }
 
@@ -78,7 +80,7 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         uint256 netPyIn,
         uint256 minSyOut
     ) external returns (uint256 netSyOut) {
-        netSyOut = _redeemPyToSy(receiver, YT, netPyIn, minSyOut, true);
+        netSyOut = _redeemPyToSy(receiver, YT, netPyIn, minSyOut);
         emit RedeemPyToSy(msg.sender, receiver, YT, netPyIn, netSyOut);
     }
 
@@ -181,13 +183,14 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
 
         // guaranteed no ETH, all rewards are ERC20
         for (uint256 i = 0; i < tokensOut.tokens.length; ++i) {
-            IERC20(tokensOut.tokens[i]).safeTransferFrom(
+            _transferFrom(
+                IERC20(tokensOut.tokens[i]),
                 msg.sender,
                 address(this),
                 tokensOut.amounts[i]
             );
         }
-        _redeemAllSys(sysOut, dataYT.tokenRedeemSys, tokensOut);
+        _redeemAllSys(sysOut, dataYT.bulks, dataYT.tokenRedeemSys, tokensOut);
 
         // now swap all to outputToken
         netTokenOut = _swapAllToOutputToken(tokensOut, dataSwap);
@@ -218,18 +221,19 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     /// @dev pull SYs from users & redeem them, then add to tokensOut
     function _redeemAllSys(
         RouterTokenAmounts memory sys,
+        address[] calldata bulks,
         address[] calldata tokenRedeemSys,
         RouterTokenAmounts memory tokensOut
     ) internal {
         for (uint256 i = 0; i < sys.tokens.length; ++i) {
             if (sys.amounts[i] == 0) continue;
 
-            IERC20(sys.tokens[i]).safeTransferFrom(msg.sender, sys.tokens[i], sys.amounts[i]);
-            uint256 amountOut = IStandardizedYield(sys.tokens[i]).redeem(
+            TokenOutput memory output = _wrapTokenOutput(tokenRedeemSys[i], 1, bulks[i]);
+            uint256 amountOut = _redeemSyToToken(
                 address(this),
+                sys.tokens[i],
                 sys.amounts[i],
-                tokenRedeemSys[i],
-                1,
+                output,
                 true
             );
 
@@ -243,7 +247,12 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     ) internal returns (uint256 netTokenOut) {
         for (uint256 i = 0; i < tokens.tokens.length; ++i) {
             if (tokens.amounts[i] == 0) continue;
-            _kyberswap(tokens.tokens[i], tokens.amounts[i], dataSwap.kybercalls[i]);
+            _kyberswap(
+                tokens.tokens[i],
+                tokens.amounts[i],
+                dataSwap.kyberRouter,
+                dataSwap.kybercalls[i]
+            );
         }
         netTokenOut = _selfBalance(dataSwap.outputToken);
         _transferOut(dataSwap.outputToken, msg.sender, netTokenOut);

package/contracts/router/ActionSwapPT.sol

@@ -12,12 +12,11 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
     using MarketApproxPtOutLib for MarketState;
     using Math for uint256;
     using Math for int256;
-    using SafeERC20 for IERC20;
     using PYIndexLib for IPYieldToken;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberSwapRouter)
-        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberScalingLib)
+        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
     {}
 
     function swapExactPtForSy(
@@ -27,7 +26,7 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
         uint256 minSyOut
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
         (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
-        IERC20(address(PT)).safeTransferFrom(msg.sender, market, exactPtIn);
+        _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
 
         (netSyOut, netSyFee) = IPMarket(market).swapExactPtForSy(receiver, exactPtIn, EMPTY_BYTES);
 
@@ -59,7 +58,7 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
 
         if (netPtIn > maxPtIn) revert Errors.RouterExceededLimitPtIn(netPtIn, maxPtIn);
 
-        IERC20(PT).safeTransferFrom(msg.sender, market, netPtIn);
+        _transferFrom(IERC20(PT), msg.sender, market, netPtIn);
 
         uint256 netSyOut;
         (netSyOut, netSyFee) = IPMarket(market).swapExactPtForSy(receiver, netPtIn, EMPTY_BYTES);
@@ -83,7 +82,7 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
 
         if (netSyIn > maxSyIn) revert Errors.RouterExceededLimitSyIn(netSyIn, maxSyIn);
 
-        IERC20(SY).safeTransferFrom(msg.sender, market, netSyIn);
+        _transferFrom(IERC20(SY), msg.sender, market, netSyIn);
 
         (, netSyFee) = IPMarket(market).swapSyForExactPt(receiver, exactPtOut, EMPTY_BYTES); // ignore return
 
@@ -100,7 +99,7 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
     ) external returns (uint256 netPtOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        IERC20(SY).safeTransferFrom(msg.sender, market, exactSyIn);
+        _transferFrom(IERC20(SY), msg.sender, market, exactSyIn);
 
         (netPtOut, netSyFee) = _swapExactSyForPt(
             receiver,
@@ -163,12 +162,12 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
     ) external returns (uint256 netTokenOut, uint256 netSyFee) {
         (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
-        IERC20(address(PT)).safeTransferFrom(msg.sender, market, exactPtIn);
+        _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
 
         // all output SY is directly transferred to the SY contract
         uint256 netSyReceived;
         (netSyReceived, netSyFee) = IPMarket(market).swapExactPtForSy(
-            address(SY),
+            _syOrBulk(address(SY), output),
             exactPtIn,
             EMPTY_BYTES
         );

package/contracts/router/ActionSwapPTYT.sol

@@ -5,17 +5,13 @@ import "../interfaces/IPActionSwapPTYT.sol";
 import "../interfaces/IPMarket.sol";
 import "./base/CallbackHelper.sol";
 
-contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper {
+contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper, TokenHelper {
     using MarketMathCore for MarketState;
     using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;
     using Math for uint256;
     using Math for int256;
-    using SafeERC20 for IERC20;
     using PYIndexLib for IPYieldToken;
-    using SafeERC20 for IStandardizedYield;
-    using SafeERC20 for IPYieldToken;
-    using SafeERC20 for IPPrincipalToken;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
     constructor() //solhint-disable-next-line no-empty-blocks
@@ -33,7 +29,7 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper {
         (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
         MarketState memory state = IPMarket(market).readState();
 
-        PT.safeTransferFrom(msg.sender, market, exactPtIn);
+        _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
 
         uint256 totalPtToSwap;
         (netYtOut, totalPtToSwap, netSyFee) = state.approxSwapExactPtForYt(
@@ -64,7 +60,7 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
         MarketState memory state = IPMarket(market).readState();
 
-        YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
+        _transferFrom(IERC20(YT), msg.sender, address(YT), exactYtIn);
 
         uint256 totalPtSwapped;
         (netPtOut, totalPtSwapped, netSyFee) = state.approxSwapExactYtForPt(

package/contracts/router/ActionSwapYT.sol

@@ -13,13 +13,11 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     using MarketMathCore for MarketState;
     using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;
-    using SafeERC20 for IStandardizedYield;
-    using SafeERC20 for IPYieldToken;
     using PYIndexLib for IPYieldToken;
 
     /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _kyberSwapRouter)
-        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberScalingLib)
+        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
     {}
 
     /**
@@ -41,7 +39,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     ) external returns (uint256 netYtOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        SY.safeTransferFrom(msg.sender, address(YT), exactSyIn);
+        _transferFrom(IERC20(SY), msg.sender, address(YT), exactSyIn);
 
         (netYtOut, netSyFee) = _swapExactSyForYt(
             receiver,
@@ -73,7 +71,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
+        _transferFrom(IERC20(YT), msg.sender, address(YT), exactYtIn);
 
         (netSyOut, netSyFee) = _swapExactYtForSy(receiver, market, SY, YT, exactYtIn, minSyOut);
 
@@ -139,7 +137,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
 
         if (netYtIn > maxYtIn) revert Errors.RouterExceededLimitYtIn(netYtIn, maxYtIn);
 
-        YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
+        _transferFrom(IERC20(YT), msg.sender, address(YT), netYtIn);
 
         (, netSyFee) = IPMarket(market).swapSyForExactPt(
             address(YT),
@@ -188,11 +186,18 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     ) external returns (uint256 netTokenOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
+        _transferFrom(IERC20(YT), msg.sender, address(YT), netYtIn);
 
         uint256 netSyOut;
 
-        (netSyOut, netSyFee) = _swapExactYtForSy(address(SY), market, SY, YT, netYtIn, 1);
+        (netSyOut, netSyFee) = _swapExactYtForSy(
+            _syOrBulk(address(SY), output),
+            market,
+            SY,
+            YT,
+            netYtIn,
+            1
+        );
 
         netTokenOut = _redeemSyToToken(receiver, address(SY), netSyOut, output, false);
 
@@ -247,7 +252,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
             address(YT),
             exactYtIn, // exactPtOut = exactYtIn
             _encodeSwapYtForSy(receiver, minSyOut)
-        ); // ignore return
+        );
 
         netSyOut = SY.balanceOf(receiver) - preSyBalance;
     }

package/contracts/router/PendleRouter.sol

@@ -40,6 +40,9 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
         ACTION_MISC = _ACTION_MISC;
     }
 
+    receive() external payable virtual override {
+    }
+
     function initialize() external initializer {
         __BoringOwnable_init();
     }