@pendle/core-v2 0.16.2-testnet → 0.16.3-testnet

package/contracts/offchain-helpers/RouterStatic.sol

@@ -4,6 +4,8 @@ pragma solidity 0.8.17;
 import "../interfaces/IPYieldContractFactory.sol";
 import "../interfaces/IPMarketFactory.sol";
 import "../interfaces/IPVotingEscrowMainchain.sol";
+import "../interfaces/IPBulkSellerFactory.sol";
+import "../interfaces/IPBulkSeller.sol";
 
 import "./MarketMathStatic.sol";
 
@@ -58,15 +60,18 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
     IPYieldContractFactory internal immutable yieldContractFactory;
     IPMarketFactory internal immutable marketFactory;
     IPVotingEscrowMainchain internal immutable vePENDLE;
+    IPBulkSellerFactory internal immutable bulkFactory;
 
     constructor(
         IPYieldContractFactory _yieldContractFactory,
         IPMarketFactory _marketFactory,
-        IPVotingEscrowMainchain _vePENDLE
+        IPVotingEscrowMainchain _vePENDLE,
+        IPBulkSellerFactory _bulkFactory
     ) initializer {
         yieldContractFactory = _yieldContractFactory;
         marketFactory = _marketFactory;
         vePENDLE = _vePENDLE;
+        bulkFactory = _bulkFactory;
     }
 
     function initialize() external initializer {
@@ -283,6 +288,7 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         address market,
         address tokenIn,
         uint256 netTokenDesired,
+        bool useBulk,
         uint256 netPtDesired
     )
         external
@@ -293,13 +299,23 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 netPtUsed
         )
     {
-        return
-            MarketMathStatic.addLiquidityDualTokenAndPtStatic(
-                market,
-                tokenIn,
-                netTokenDesired,
-                netPtDesired
-            );
+        uint256 netSyDesired = previewDepositStatic(
+            getSyMarket(market),
+            tokenIn,
+            netTokenDesired,
+            useBulk
+        );
+
+        uint256 netSyUsed;
+        (netLpOut, netSyUsed, netPtUsed) = MarketMathStatic.addLiquidityDualSyAndPtStatic(
+            market,
+            netSyDesired,
+            netPtDesired
+        );
+
+        if (netSyUsed != netSyDesired) revert Errors.RouterNotAllSyUsed(netSyDesired, netSyUsed);
+
+        netTokenUsed = netTokenDesired;
     }
 
     function addLiquiditySinglePtStatic(address market, uint256 netPtIn)
@@ -331,7 +347,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
     function addLiquiditySingleBaseTokenStatic(
         address market,
         address baseToken,
-        uint256 netBaseTokenIn
+        uint256 netBaseTokenIn,
+        bool useBulk
     )
         external
         returns (
@@ -341,13 +358,15 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 priceImpact
         )
     {
+        uint256 netSyIn = previewDepositStatic(
+            getSyMarket(market),
+            baseToken,
+            netBaseTokenIn,
+            useBulk
+        );
+
         return
-            MarketMathStatic.addLiquiditySingleBaseTokenStatic(
-                market,
-                baseToken,
-                netBaseTokenIn,
-                getDefaultApproxParams()
-            );
+            MarketMathStatic.addLiquiditySingleSyStatic(market, netSyIn, getDefaultApproxParams());
     }
 
     function removeLiquidityDualSyAndPtStatic(address market, uint256 netLpToRemove)
@@ -361,10 +380,17 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
     function removeLiquidityDualTokenAndPtStatic(
         address market,
         uint256 netLpToRemove,
-        address tokenOut
+        address tokenOut,
+        bool useBulk
     ) external view returns (uint256 netTokenOut, uint256 netPtOut) {
-        return
-            MarketMathStatic.removeLiquidityDualTokenAndPtStatic(market, netLpToRemove, tokenOut);
+        uint256 netSyOut;
+
+        (netSyOut, netPtOut) = MarketMathStatic.removeLiquidityDualSyAndPtStatic(
+            market,
+            netLpToRemove
+        );
+
+        netTokenOut = previewRedeemStatic(getSyMarket(market), tokenOut, netSyOut, useBulk);
     }
 
     function removeLiquiditySinglePtStatic(address market, uint256 netLpToRemove)
@@ -398,7 +424,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
     function removeLiquiditySingleBaseTokenStatic(
         address market,
         uint256 netLpToRemove,
-        address baseToken
+        address baseToken,
+        bool useBulk
     )
         external
         returns (
@@ -407,12 +434,14 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 priceImpact
         )
     {
-        return
-            MarketMathStatic.removeLiquiditySingleBaseTokenStatic(
-                market,
-                netLpToRemove,
-                baseToken
-            );
+        uint256 netSyOut;
+
+        (netSyOut, netSyFee, priceImpact) = MarketMathStatic.removeLiquiditySingleSyStatic(
+            market,
+            netLpToRemove
+        );
+
+        netBaseTokenOut = previewRedeemStatic(getSyMarket(market), baseToken, netSyOut, useBulk);
     }
 
     function swapExactPtForSyStatic(address market, uint256 exactPtIn)
@@ -464,7 +493,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
     function swapExactBaseTokenForPtStatic(
         address market,
         address baseToken,
-        uint256 amountBaseToken
+        uint256 amountBaseToken,
+        bool useBulk
     )
         external
         returns (
@@ -473,19 +503,20 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 priceImpact
         )
     {
-        return
-            MarketMathStatic.swapExactBaseTokenForPtStatic(
-                market,
-                baseToken,
-                amountBaseToken,
-                getDefaultApproxParams()
-            );
+        uint256 netSyIn = previewDepositStatic(
+            getSyMarket(market),
+            baseToken,
+            amountBaseToken,
+            useBulk
+        );
+        return MarketMathStatic.swapExactSyForPtStatic(market, netSyIn, getDefaultApproxParams());
     }
 
     function swapExactPtForBaseTokenStatic(
         address market,
         uint256 exactPtIn,
-        address baseToken
+        address baseToken,
+        bool useBulk
     )
         external
         returns (
@@ -494,7 +525,13 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 priceImpact
         )
     {
-        return MarketMathStatic.swapExactPtForBaseTokenStatic(market, exactPtIn, baseToken);
+        uint256 netSyOut;
+        (netSyOut, netSyFee, priceImpact) = MarketMathStatic.swapExactPtForSyStatic(
+            market,
+            exactPtIn
+        );
+
+        netBaseTokenOut = previewRedeemStatic(getSyMarket(market), baseToken, netSyOut, useBulk);
     }
 
     function swapSyForExactYtStatic(address market, uint256 exactYtOut)
@@ -546,7 +583,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
     function swapExactYtForBaseTokenStatic(
         address market,
         uint256 exactYtIn,
-        address baseToken
+        address baseToken,
+        bool useBulk
     )
         external
         returns (
@@ -555,13 +593,20 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 priceImpact
         )
     {
-        return MarketMathStatic.swapExactYtForBaseTokenStatic(market, exactYtIn, baseToken);
+        uint256 netSyOut;
+        (netSyOut, netSyFee, priceImpact) = MarketMathStatic.swapExactYtForSyStatic(
+            market,
+            exactYtIn
+        );
+
+        netBaseTokenOut = previewRedeemStatic(getSyMarket(market), baseToken, netSyOut, useBulk);
     }
 
     function swapExactBaseTokenForYtStatic(
         address market,
         address baseToken,
-        uint256 amountBaseToken
+        uint256 amountBaseToken,
+        bool useBulk
     )
         external
         returns (
@@ -570,13 +615,14 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 priceImpact
         )
     {
-        return
-            MarketMathStatic.swapExactBaseTokenForYtStatic(
-                market,
-                baseToken,
-                amountBaseToken,
-                getDefaultApproxParams()
-            );
+        uint256 netSyIn = previewDepositStatic(
+            getSyMarket(market),
+            baseToken,
+            amountBaseToken,
+            useBulk
+        );
+
+        return MarketMathStatic.swapExactSyForYtStatic(market, netSyIn, getDefaultApproxParams());
     }
 
     function swapExactPtForYtStatic(address market, uint256 exactPtIn)
@@ -661,19 +707,51 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
     function mintPYFromBaseStatic(
         address YT,
         address baseToken,
-        uint256 amountBaseToken
+        uint256 amountBaseToken,
+        bool useBulk
     ) external returns (uint256 amountPY) {
         IStandardizedYield SY = IStandardizedYield(IPYieldToken(YT).SY());
-        return mintPYFromSyStatic(YT, SY.previewDeposit(baseToken, amountBaseToken));
+        uint256 amountSy = previewDepositStatic(SY, baseToken, amountBaseToken, useBulk);
+        return mintPYFromSyStatic(YT, amountSy);
     }
 
     function redeemPYToBaseStatic(
         address YT,
         uint256 amountPYToRedeem,
-        address baseToken
+        address baseToken,
+        bool useBulk
     ) external returns (uint256 amountBaseToken) {
         IStandardizedYield SY = IStandardizedYield(IPYieldToken(YT).SY());
-        return SY.previewRedeem(baseToken, redeemPYToSyStatic(YT, amountPYToRedeem));
+        uint256 amountSy = redeemPYToSyStatic(YT, amountPYToRedeem);
+        return previewRedeemStatic(SY, baseToken, amountSy, useBulk);
+    }
+
+    function previewDepositStatic(
+        IStandardizedYield SY,
+        address baseToken,
+        uint256 amountToken,
+        bool useBulk
+    ) public view returns (uint256 amountSy) {
+        if (useBulk) {
+            address bulk = bulkFactory.get(baseToken, address(SY));
+            return IPBulkSeller(bulk).calcSwapExactTokenForSy(amountToken);
+        } else {
+            return SY.previewDeposit(baseToken, amountToken);
+        }
+    }
+
+    function previewRedeemStatic(
+        IStandardizedYield SY,
+        address baseToken,
+        uint256 amountSy,
+        bool useBulk
+    ) public view returns (uint256 amountBaseToken) {
+        if (useBulk) {
+            address bulk = bulkFactory.get(baseToken, address(SY));
+            return IPBulkSeller(bulk).calcSwapExactSyForToken(amountSy);
+        } else {
+            return SY.previewRedeem(baseToken, amountSy);
+        }
     }
 
     function getPtImpliedYield(address market) public view returns (int256) {
@@ -719,10 +797,48 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
     }
 
     function getAmountTokenToMintSy(
-        address SY,
+        IStandardizedYield SY,
         address tokenIn,
+        bool useBulk,
         uint256 netSyOut
     ) public view returns (uint256 netTokenIn) {
-        return MarketMathStatic.getAmountTokenToMintSy(SY, tokenIn, netSyOut);
+        uint256 pivotAmount = netSyOut;
+
+        uint256 low = pivotAmount;
+        {
+            while (true) {
+                uint256 lowSyOut = previewDepositStatic(SY, tokenIn, low, useBulk);
+                if (lowSyOut >= netSyOut) low /= 10;
+                else break;
+            }
+        }
+
+        uint256 high = pivotAmount;
+        {
+            while (true) {
+                uint256 highSyOut = previewDepositStatic(SY, tokenIn, high, useBulk);
+                if (highSyOut < netSyOut) high *= 10;
+                else break;
+            }
+        }
+
+        while (low <= high) {
+            uint256 mid = (low + high) / 2;
+            uint256 syOut = previewDepositStatic(SY, tokenIn, mid, useBulk);
+
+            if (syOut >= netSyOut) {
+                netTokenIn = mid;
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+
+        assert(netTokenIn > 0);
+    }
+
+    function getSyMarket(address market) public view returns (IStandardizedYield) {
+        (IStandardizedYield SY, , ) = IPMarket(market).readTokens();
+        return SY;
     }
 }

package/contracts/router/ActionAddRemoveLiq.sol

@@ -14,10 +14,11 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     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, address _bulkSellerDirectory)
+        ActionBaseMintRedeem(_kyberScalingLib, _bulkSellerDirectory) //solhint-disable-next-line no-empty-blocks
     {}
 
     function addLiquidityDualSyAndPt(
@@ -36,6 +37,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,6 +48,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         // early-check
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
 
+        // execute the addLiquidity
         IERC20(SY).safeTransferFrom(msg.sender, market, netSyUsed);
         IERC20(PT).safeTransferFrom(msg.sender, market, netPtUsed);
 
@@ -63,8 +66,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     function addLiquidityDualTokenAndPt(
         address receiver,
         address market,
-        address tokenIn,
-        uint256 netTokenDesired,
+        TokenInput calldata input,
         uint256 netPtDesired,
         uint256 minLpOut
     )
@@ -78,46 +80,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 (netSyDesired != netSyUsed) revert Errors.RouterNotAllSyUsed(netSyDesired, netSyUsed);
-        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
-
-        IERC20(PT).safeTransferFrom(msg.sender, market, netPtUsed);
 
-        // convert tokenIn to SY to deposit
-        netTokenUsed = netTokenDesired;
+            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
+        IERC20(PT).safeTransferFrom(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
         );
@@ -132,6 +126,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(
@@ -141,6 +136,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             guessPtSwapToSy
         );
 
+        // execute the swap
         IERC20(PT).safeTransferFrom(msg.sender, market, netPtIn);
 
         uint256 netSyReceived;
@@ -148,8 +144,9 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             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);
@@ -165,8 +162,11 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         ApproxParams calldata guessPtReceivedFromSy
     ) external returns (uint256 netLpOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        // transfer SY to market
         IERC20(SY).safeTransferFrom(msg.sender, market, netSyIn);
 
+        // mint LP
         (netLpOut, netSyFee) = _addLiquiditySingleSy(
             receiver,
             market,
@@ -188,9 +188,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,
@@ -238,28 +239,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();
 
+        // burn LP, SY sent to either SY or bulk, PT sent to receiver
         IERC20(market).safeTransferFrom(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
         );
     }
@@ -273,8 +279,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(
@@ -287,14 +292,17 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         if (ptFromBurn + ptFromSwap < minPtOut)
             revert Errors.RouterInsufficientPtOut(ptFromBurn + ptFromSwap, minPtOut);
 
+        // execute the burn & the swap
+        IERC20(market).safeTransferFrom(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);
     }
 
@@ -304,8 +312,12 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         uint256 netLpToRemove,
         uint256 minSyOut
     ) external returns (uint256 netSyOut, uint256 netSyFee) {
+        // transfer LP to market
         IERC20(market).safeTransferFrom(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);
     }
 
@@ -317,19 +329,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
         IERC20(market).safeTransferFrom(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(
@@ -352,20 +364,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);
     }
@@ -412,6 +427,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
             ptFromBurn,
             EMPTY_BYTES
         );
+
         netSyOut = syFromBurn + syFromSwap;
     }
 }