@pendle/core-v2 0.15.3-mainnet → 0.16.0-testnet

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 _kyberScalingLib)
-        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberSwapRouter)
+        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
     {}
 
     function addLiquidityDualSyAndPt(
@@ -36,7 +36,6 @@ 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,
@@ -47,9 +46,8 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         // early-check
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
 
-        // execute the addLiquidity
-        _transferFrom(IERC20(SY), msg.sender, market, netSyUsed);
-        _transferFrom(IERC20(PT), msg.sender, market, netPtUsed);
+        IERC20(SY).safeTransferFrom(msg.sender, market, netSyUsed);
+        IERC20(PT).safeTransferFrom(msg.sender, market, netPtUsed);
 
         (netLpOut, , ) = IPMarket(market).mint(receiver, netSyUsed, netPtUsed);
 
@@ -59,13 +57,11 @@ 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,
-        TokenInput calldata input,
+        address tokenIn,
+        uint256 netTokenDesired,
         uint256 netPtDesired,
         uint256 minLpOut
     )
@@ -79,38 +75,45 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     {
         (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
-        uint256 netSyDesired = _mintSyFromToken(market, address(SY), 1, input);
+        uint256 netSyDesired = SY.previewDeposit(tokenIn, netTokenDesired);
         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);
 
-            if (netSyDesired != netSyUsed)
-                revert Errors.RouterNotAllSyUsed(netSyDesired, netSyUsed);
-            if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
+        // convert tokenIn to SY to deposit
+        netTokenUsed = (netTokenDesired * netSyUsed).rawDivUp(netSyDesired);
 
-            netTokenUsed = input.netTokenIn;
+        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);
         }
 
-        // 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,
-            input.tokenIn,
-            netTokenUsed,
+            tokenIn,
+            netTokenDesired,
             netPtUsed,
             netLpOut
         );
@@ -125,7 +128,6 @@ 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(
@@ -135,17 +137,15 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             guessPtSwapToSy
         );
 
-        // execute the swap
-        _transferFrom(IERC20(PT), msg.sender, market, netPtIn);
+        IERC20(PT).safeTransferFrom(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,11 +161,8 @@ 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,
@@ -187,10 +184,9 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     ) external payable returns (uint256 netLpOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        // mint SY directly to the market
-        uint256 netSyUsed = _mintSyFromToken(market, address(SY), 1, input);
+        // all output SY is transferred directly to the market
+        uint256 netSyUsed = _mintSyFromToken(address(market), address(SY), 1, input);
 
-        // mint LP
         (netLpOut, netSyFee) = _addLiquiditySingleSy(
             receiver,
             market,
@@ -217,7 +213,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         uint256 minSyOut,
         uint256 minPtOut
     ) external returns (uint256 netSyOut, uint256 netPtOut) {
-        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
+        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
 
         (netSyOut, netPtOut) = IPMarket(market).burn(receiver, receiver, netLpToRemove);
 
@@ -238,25 +234,20 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         address receiver,
         address market,
         uint256 netLpToRemove,
-        TokenOutput calldata output,
+        address tokenOut,
+        uint256 minTokenOut,
         uint256 minPtOut
     ) external returns (uint256 netTokenOut, uint256 netPtOut) {
         (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
 
-        // burn LP, SY sent to either SY or bulk, PT sent to receiver
-        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
+        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
 
         uint256 netSyOut;
-        (netSyOut, netPtOut) = IPMarket(market).burn(
-            _syOrBulk(address(SY), output),
-            receiver,
-            netLpToRemove
-        );
+        (netSyOut, netPtOut) = IPMarket(market).burn(address(SY), receiver, netLpToRemove);
 
-        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
+        netTokenOut = SY.redeem(receiver, netSyOut, tokenOut, minTokenOut, true);
 
-        // redeem SY to token
-        netTokenOut = _redeemSyToToken(receiver, address(SY), netSyOut, output, false);
+        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
 
         emit RemoveLiquidityDualTokenAndPt(
             msg.sender,
@@ -264,7 +255,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             receiver,
             netLpToRemove,
             netPtOut,
-            output.tokenOut,
+            tokenOut,
             netTokenOut
         );
     }
@@ -278,7 +269,8 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     ) external returns (uint256 netPtOut, uint256 netSyFee) {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        // calculate the total amount of PT received from burning & selling SY
+        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
+
         MarketState memory state = IPMarket(market).readState();
         (uint256 syFromBurn, uint256 ptFromBurn) = state.removeLiquidity(netLpToRemove);
         (uint256 ptFromSwap, ) = state.approxSwapExactSyForPt(
@@ -291,16 +283,13 @@ 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);
 
-        netPtOut = ptFromBurn + ptFromSwap;
-
         // fail-safe
-        if (netPtOut < minPtOut) assert(false);
+        if (ptFromBurn + ptFromSwap < minPtOut) assert(false);
+
+        netPtOut = ptFromBurn + ptFromSwap;
 
         emit RemoveLiquiditySinglePt(msg.sender, market, receiver, netLpToRemove, netPtOut);
     }
@@ -311,12 +300,8 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         uint256 netLpToRemove,
         uint256 minSyOut
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
-        // transfer LP to market
-        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
-
-        // burn LP, SY sent to receiver
+        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
         (netSyOut, netSyFee) = _removeLiquiditySingleSy(receiver, market, netLpToRemove, minSyOut);
-
         emit RemoveLiquiditySingleSy(msg.sender, market, receiver, netLpToRemove, netSyOut);
     }
 
@@ -328,19 +313,19 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     ) external returns (uint256 netTokenOut, uint256 netSyFee) {
         (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
 
-        // transfer LP to market, burn LP, SY sent to either SY or bulk
-        _transferFrom(IERC20(market), msg.sender, market, netLpToRemove);
+        IERC20(market).safeTransferFrom(msg.sender, market, netLpToRemove);
 
+        // all output SY is directly transferred to the SY contract
         uint256 netSyReceived;
 
         (netSyReceived, netSyFee) = _removeLiquiditySingleSy(
-            _syOrBulk(address(SY), output),
+            address(SY),
             market,
             netLpToRemove,
             1
         );
 
-        // redeem SY to token
+        // since all SY is already at the SY contract, doPull = false
         netTokenOut = _redeemSyToToken(receiver, address(SY), netSyReceived, output, false);
 
         emit RemoveLiquiditySingleToken(
@@ -363,23 +348,20 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     ) internal returns (uint256 netLpOut, uint256 netSyFee) {
         MarketState memory state = IPMarket(market).readState();
 
-        // calculate the PT amount needed to add liquidity
-        (uint256 netPtFromSwap, , ) = state.approxSwapSyToAddLiquidity(
+        (uint256 netPtReceived, , ) = state.approxSwapSyToAddLiquidity(
             YT.newIndex(),
             netSyIn,
             block.timestamp,
             guessPtReceivedFromSy
         );
 
-        // execute the swap & the addLiquidity
         uint256 netSySwapped;
         (netSySwapped, netSyFee) = IPMarket(market).swapSyForExactPt(
             market,
-            netPtFromSwap,
+            netPtReceived,
             EMPTY_BYTES
-        );
-
-        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyIn - netSySwapped, netPtFromSwap);
+        ); // ignore return, receiver = market
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyIn - netSySwapped, netPtReceived);
 
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
     }
@@ -426,7 +408,6 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             ptFromBurn,
             EMPTY_BYTES
         );
-
         netSyOut = syFromBurn + syFromSwap;
     }
 }

package/contracts/router/ActionCallback.sol

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

package/contracts/router/ActionMintRedeem.sol

@@ -10,12 +10,14 @@ 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 _kyberScalingLib)
-        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberSwapRouter)
+        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
     {}
 
+    /// @dev refer to the internal function
     function mintSyFromToken(
         address receiver,
         address SY,
@@ -23,9 +25,11 @@ 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,
@@ -36,31 +40,25 @@ 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) {
-        address SY = IPYieldToken(YT).SY();
-
-        uint256 netSyToMint = _mintSyFromToken(YT, SY, 0, input);
-        netPyOut = _mintPyFromSy(receiver, YT, netSyToMint, minPyOut, false);
-
+        netPyOut = _mintPyFromToken(receiver, YT, minPyOut, input);
         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) {
-        address SY = IPYieldToken(YT).SY();
-
-        uint256 netSyToRedeem = _redeemPyToSy(_syOrBulk(SY, output), YT, netPyIn, 1);
-        netTokenOut = _redeemSyToToken(receiver, SY, netSyToRedeem, output, false);
-
+        netTokenOut = _redeemPyToToken(receiver, YT, netPyIn, output, true);
         emit RedeemPyToToken(msg.sender, receiver, YT, netPyIn, output.tokenOut, netTokenOut);
     }
 
@@ -80,7 +78,7 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         uint256 netPyIn,
         uint256 minSyOut
     ) external returns (uint256 netSyOut) {
-        netSyOut = _redeemPyToSy(receiver, YT, netPyIn, minSyOut);
+        netSyOut = _redeemPyToSy(receiver, YT, netPyIn, minSyOut, true);
         emit RedeemPyToSy(msg.sender, receiver, YT, netPyIn, netSyOut);
     }
 
@@ -183,14 +181,13 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
 
         // guaranteed no ETH, all rewards are ERC20
         for (uint256 i = 0; i < tokensOut.tokens.length; ++i) {
-            _transferFrom(
-                IERC20(tokensOut.tokens[i]),
+            IERC20(tokensOut.tokens[i]).safeTransferFrom(
                 msg.sender,
                 address(this),
                 tokensOut.amounts[i]
             );
         }
-        _redeemAllSys(sysOut, dataYT.bulks, dataYT.tokenRedeemSys, tokensOut);
+        _redeemAllSys(sysOut, dataYT.tokenRedeemSys, tokensOut);
 
         // now swap all to outputToken
         netTokenOut = _swapAllToOutputToken(tokensOut, dataSwap);
@@ -221,19 +218,18 @@ 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;
 
-            TokenOutput memory output = _wrapTokenOutput(tokenRedeemSys[i], 1, bulks[i]);
-            uint256 amountOut = _redeemSyToToken(
+            IERC20(sys.tokens[i]).safeTransferFrom(msg.sender, sys.tokens[i], sys.amounts[i]);
+            uint256 amountOut = IStandardizedYield(sys.tokens[i]).redeem(
                 address(this),
-                sys.tokens[i],
                 sys.amounts[i],
-                output,
+                tokenRedeemSys[i],
+                1,
                 true
             );
 
@@ -247,12 +243,7 @@ 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.kyberRouter,
-                dataSwap.kybercalls[i]
-            );
+            _kyberswap(tokens.tokens[i], tokens.amounts[i], dataSwap.kybercalls[i]);
         }
         netTokenOut = _selfBalance(dataSwap.outputToken);
         _transferOut(dataSwap.outputToken, msg.sender, netTokenOut);

package/contracts/router/ActionSwapPT.sol

@@ -12,11 +12,12 @@ 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 _kyberScalingLib)
-        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberSwapRouter)
+        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
     {}
 
     function swapExactPtForSy(
@@ -26,7 +27,7 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
         uint256 minSyOut
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
         (, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
-        _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
+        IERC20(address(PT)).safeTransferFrom(msg.sender, market, exactPtIn);
 
         (netSyOut, netSyFee) = IPMarket(market).swapExactPtForSy(receiver, exactPtIn, EMPTY_BYTES);
 
@@ -58,7 +59,7 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
 
         if (netPtIn > maxPtIn) revert Errors.RouterExceededLimitPtIn(netPtIn, maxPtIn);
 
-        _transferFrom(IERC20(PT), msg.sender, market, netPtIn);
+        IERC20(PT).safeTransferFrom(msg.sender, market, netPtIn);
 
         uint256 netSyOut;
         (netSyOut, netSyFee) = IPMarket(market).swapExactPtForSy(receiver, netPtIn, EMPTY_BYTES);
@@ -82,7 +83,7 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
 
         if (netSyIn > maxSyIn) revert Errors.RouterExceededLimitSyIn(netSyIn, maxSyIn);
 
-        _transferFrom(IERC20(SY), msg.sender, market, netSyIn);
+        IERC20(SY).safeTransferFrom(msg.sender, market, netSyIn);
 
         (, netSyFee) = IPMarket(market).swapSyForExactPt(receiver, exactPtOut, EMPTY_BYTES); // ignore return
 
@@ -99,7 +100,7 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
     ) external returns (uint256 netPtOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        _transferFrom(IERC20(SY), msg.sender, market, exactSyIn);
+        IERC20(SY).safeTransferFrom(msg.sender, market, exactSyIn);
 
         (netPtOut, netSyFee) = _swapExactSyForPt(
             receiver,
@@ -162,12 +163,12 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
     ) external returns (uint256 netTokenOut, uint256 netSyFee) {
         (IStandardizedYield SY, IPPrincipalToken PT, ) = IPMarket(market).readTokens();
 
-        _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
+        IERC20(address(PT)).safeTransferFrom(msg.sender, market, exactPtIn);
 
         // all output SY is directly transferred to the SY contract
         uint256 netSyReceived;
         (netSyReceived, netSyFee) = IPMarket(market).swapExactPtForSy(
-            _syOrBulk(address(SY), output),
+            address(SY),
             exactPtIn,
             EMPTY_BYTES
         );

package/contracts/router/ActionSwapPTYT.sol

@@ -5,13 +5,17 @@ import "../interfaces/IPActionSwapPTYT.sol";
 import "../interfaces/IPMarket.sol";
 import "./base/CallbackHelper.sol";
 
-contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper, TokenHelper {
+contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper {
     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
@@ -29,7 +33,7 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper, TokenHelper {
         (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
         MarketState memory state = IPMarket(market).readState();
 
-        _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
+        PT.safeTransferFrom(msg.sender, market, exactPtIn);
 
         uint256 totalPtToSwap;
         (netYtOut, totalPtToSwap, netSyFee) = state.approxSwapExactPtForYt(
@@ -60,7 +64,7 @@ contract ActionSwapPTYT is IPActionSwapPTYT, CallbackHelper, TokenHelper {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
         MarketState memory state = IPMarket(market).readState();
 
-        _transferFrom(IERC20(YT), msg.sender, address(YT), exactYtIn);
+        YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
 
         uint256 totalPtSwapped;
         (netPtOut, totalPtSwapped, netSyFee) = state.approxSwapExactYtForPt(

package/contracts/router/ActionSwapYT.sol

@@ -13,11 +13,13 @@ 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 _kyberScalingLib)
-        ActionBaseMintRedeem(_kyberScalingLib) //solhint-disable-next-line no-empty-blocks
+    constructor(address _kyberSwapRouter)
+        ActionBaseMintRedeem(_kyberSwapRouter) //solhint-disable-next-line no-empty-blocks
     {}
 
     /**
@@ -39,7 +41,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     ) external returns (uint256 netYtOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        _transferFrom(IERC20(SY), msg.sender, address(YT), exactSyIn);
+        SY.safeTransferFrom(msg.sender, address(YT), exactSyIn);
 
         (netYtOut, netSyFee) = _swapExactSyForYt(
             receiver,
@@ -71,7 +73,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        _transferFrom(IERC20(YT), msg.sender, address(YT), exactYtIn);
+        YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
 
         (netSyOut, netSyFee) = _swapExactYtForSy(receiver, market, SY, YT, exactYtIn, minSyOut);
 
@@ -137,7 +139,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
 
         if (netYtIn > maxYtIn) revert Errors.RouterExceededLimitYtIn(netYtIn, maxYtIn);
 
-        _transferFrom(IERC20(YT), msg.sender, address(YT), netYtIn);
+        YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
 
         (, netSyFee) = IPMarket(market).swapSyForExactPt(
             address(YT),
@@ -186,18 +188,11 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     ) external returns (uint256 netTokenOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
-        _transferFrom(IERC20(YT), msg.sender, address(YT), netYtIn);
+        YT.safeTransferFrom(msg.sender, address(YT), netYtIn);
 
         uint256 netSyOut;
 
-        (netSyOut, netSyFee) = _swapExactYtForSy(
-            _syOrBulk(address(SY), output),
-            market,
-            SY,
-            YT,
-            netYtIn,
-            1
-        );
+        (netSyOut, netSyFee) = _swapExactYtForSy(address(SY), market, SY, YT, netYtIn, 1);
 
         netTokenOut = _redeemSyToToken(receiver, address(SY), netSyOut, output, false);
 
@@ -252,7 +247,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,9 +40,6 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
         ACTION_MISC = _ACTION_MISC;
     }
 
-    receive() external payable virtual override {
-    }
-
     function initialize() external initializer {
         __BoringOwnable_init();
     }