@pendle/core-v2 2.29.1 → 3.0.0-beta-2

package/contracts/router/PendleRouterHelper.sol

@@ -1,28 +1,23 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity 0.8.21;
 
-import "../interfaces/IPAllAction.sol";
 import "../interfaces/IPMarket.sol";
 import "../interfaces/IPRouterHelper.sol";
-import "./base/ActionBaseMintRedeem.sol";
 import "./base/MarketApproxLib.sol";
 import "../interfaces/IAddressProvider.sol";
+import "../core/libraries/TokenHelper.sol";
 
 contract PendleRouterHelper is TokenHelper, IPRouterHelper {
-    IPAllAction public immutable ROUTER;
+    RouterV2InterfaceForRouterHelper public immutable ROUTER;
     address public immutable WETH;
 
     constructor(address _ROUTER, IAddressProvider provider) {
-        ROUTER = IPAllAction(_ROUTER);
+        ROUTER = RouterV2InterfaceForRouterHelper(_ROUTER);
         WETH = _getWETHAddress(provider, 1);
         _safeApproveInf(WETH, address(ROUTER));
     }
 
-    function _getWETHAddress(IAddressProvider provider, uint256 providerId)
-        internal
-        view
-        returns (address)
-    {
+    function _getWETHAddress(IAddressProvider provider, uint256 providerId) internal view returns (address) {
         return provider.get(providerId);
     }
 
@@ -30,8 +25,8 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
 
     /**
      * @dev all the parameters for this function should be generated in the same way as they are
-     generated for the main Router, except that input.tokenIn & swapData should be generated
-     for tokenIn == WETH instead of ETH
+     *  generated for the main Router, except that input.tokenIn & swapData should be generated
+     *  for tokenIn == WETH instead of ETH
      */
     function addLiquiditySingleTokenKeepYtWithEth(
         address receiver,
@@ -45,77 +40,31 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
         _transferIn(NATIVE, msg.sender, input.netTokenIn);
 
         _wrap_unwrap_ETH(NATIVE, WETH, input.netTokenIn);
-        (netLpOut, netYtOut) = ROUTER.addLiquiditySingleTokenKeepYt(
-            receiver,
-            market,
-            minLpOut,
-            minYtOut,
-            input
-        );
+        (netLpOut, netYtOut) = ROUTER.addLiquiditySingleTokenKeepYt(receiver, market, minLpOut, minYtOut, input);
 
-        emit AddLiquiditySingleTokenKeepYt(
-            msg.sender,
-            market,
-            NATIVE,
-            msg.sender,
-            input.netTokenIn,
-            netLpOut,
-            netYtOut
-        );
+        emit AddLiquiditySingleTokenKeepYt(msg.sender, market, NATIVE, msg.sender, input.netTokenIn, netLpOut, netYtOut);
     }
 
     function transferLiquidityDifferentSyNormal(
         RemoveLiquiditySingleTokenStruct calldata fromMarket,
         AddLiquiditySingleTokenStruct calldata toMarket
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netTokenZapIn,
-            uint256 netSyFeeOfRemove,
-            uint256 netSyFeeOfAdd
-        )
-    {
+    ) external returns (uint256 netLpOut, uint256 netTokenZapIn, uint256 netSyFeeOfRemove, uint256 netSyFeeOfAdd) {
         (netTokenZapIn, netSyFeeOfRemove) = removeLiquiditySingleToken(fromMarket);
-        (netLpOut, netSyFeeOfAdd) = _addLiquiditySingleToken(
-            toMarket,
-            fromMarket.output.tokenOut,
-            netTokenZapIn
-        );
+        (netLpOut, netSyFeeOfAdd) = _addLiquiditySingleToken(toMarket, fromMarket.output.tokenOut, netTokenZapIn);
     }
 
     function transferLiquidityDifferentSyKeepYt(
         RemoveLiquiditySingleTokenStruct calldata fromMarket,
         AddLiquiditySingleTokenKeepYtStruct calldata toMarket
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netYtOut,
-            uint256 netTokenZapIn,
-            uint256 netSyFeeOfRemove
-        )
-    {
+    ) external returns (uint256 netLpOut, uint256 netYtOut, uint256 netTokenZapIn, uint256 netSyFeeOfRemove) {
         (netTokenZapIn, netSyFeeOfRemove) = removeLiquiditySingleToken(fromMarket);
-        (netLpOut, netYtOut) = _addLiquiditySingleTokenKeepYt(
-            toMarket,
-            fromMarket.output.tokenOut,
-            netTokenZapIn
-        );
+        (netLpOut, netYtOut) = _addLiquiditySingleTokenKeepYt(toMarket, fromMarket.output.tokenOut, netTokenZapIn);
     }
 
     function transferLiquiditySameSyNormal(
         RemoveLiquiditySingleSyStruct calldata fromMarket,
         AddLiquiditySingleSyStruct calldata toMarket
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netSyZapIn,
-            uint256 netSyFeeOfRemove,
-            uint256 netSyFeeOfAdd
-        )
-    {
+    ) external returns (uint256 netLpOut, uint256 netSyZapIn, uint256 netSyFeeOfRemove, uint256 netSyFeeOfAdd) {
         (netSyZapIn, netSyFeeOfRemove) = removeLiquiditySingleSy(fromMarket);
         (netLpOut, netSyFeeOfAdd) = _addLiquiditySingleSy(toMarket, netSyZapIn);
     }
@@ -123,15 +72,7 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
     function transferLiquiditySameSyKeepYt(
         RemoveLiquiditySingleSyStruct calldata fromMarket,
         AddLiquiditySingleSyKeepYtStruct calldata toMarket
-    )
-        external
-        returns (
-            uint256 netLpOut,
-            uint256 netYtOut,
-            uint256 netSyZapIn,
-            uint256 netSyFeeOfRemove
-        )
-    {
+    ) external returns (uint256 netLpOut, uint256 netYtOut, uint256 netSyZapIn, uint256 netSyFeeOfRemove) {
         (netSyZapIn, netSyFeeOfRemove) = removeLiquiditySingleSy(fromMarket);
         (netLpOut, netYtOut) = _addLiquiditySingleSyKeepYt(toMarket, netSyZapIn);
     }
@@ -140,20 +81,12 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
         public
         returns (uint256 netTokenOut, uint256 netSyFee)
     {
-        _transferFrom(
-            IERC20(fromMarket.market),
-            msg.sender,
-            address(this),
-            fromMarket.netLpToRemove
-        );
+        _transferFrom(IERC20(fromMarket.market), msg.sender, address(this), fromMarket.netLpToRemove);
 
         _safeApproveInf(fromMarket.market, address(ROUTER));
 
         (netTokenOut, netSyFee) = ROUTER.removeLiquiditySingleToken(
-            address(this),
-            fromMarket.market,
-            fromMarket.netLpToRemove,
-            fromMarket.output
+            address(this), fromMarket.market, fromMarket.netLpToRemove, fromMarket.output
         );
 
         if (fromMarket.doRedeemRewards) {
@@ -161,12 +94,7 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
         }
 
         emit RemoveLiquiditySingleToken(
-            msg.sender,
-            fromMarket.market,
-            fromMarket.output.tokenOut,
-            msg.sender,
-            fromMarket.netLpToRemove,
-            netTokenOut
+            msg.sender, fromMarket.market, fromMarket.output.tokenOut, msg.sender, fromMarket.netLpToRemove, netTokenOut
         );
     }
 
@@ -174,33 +102,18 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
         public
         returns (uint256 netSyOut, uint256 netSyFee)
     {
-        _transferFrom(
-            IERC20(fromMarket.market),
-            msg.sender,
-            address(this),
-            fromMarket.netLpToRemove
-        );
+        _transferFrom(IERC20(fromMarket.market), msg.sender, address(this), fromMarket.netLpToRemove);
 
         _safeApproveInf(fromMarket.market, address(ROUTER));
 
-        (netSyOut, netSyFee) = ROUTER.removeLiquiditySingleSy(
-            address(this),
-            fromMarket.market,
-            fromMarket.netLpToRemove,
-            0
-        );
+        (netSyOut, netSyFee) =
+            ROUTER.removeLiquiditySingleSy(address(this), fromMarket.market, fromMarket.netLpToRemove, 0);
 
         if (fromMarket.doRedeemRewards) {
             IPMarket(fromMarket.market).redeemRewards(msg.sender);
         }
 
-        emit RemoveLiquiditySingleSy(
-            msg.sender,
-            fromMarket.market,
-            msg.sender,
-            fromMarket.netLpToRemove,
-            netSyOut
-        );
+        emit RemoveLiquiditySingleSy(msg.sender, fromMarket.market, msg.sender, fromMarket.netLpToRemove, netSyOut);
     }
 
     function _addLiquiditySingleToken(
@@ -215,33 +128,22 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
 
         _safeApproveInf(tokenToZapIn, address(ROUTER));
 
-        (netLpOut, netSyFee) = ROUTER.addLiquiditySingleToken{ value: netNativeToAttach }(
+        (netLpOut, netSyFee) = ROUTER.addLiquiditySingleToken{value: netNativeToAttach}(
             msg.sender,
             toMarket.market,
             toMarket.minLpOut,
-            _scaleApproxParams(
-                toMarket.guessPtReceivedFromSy,
-                toMarket.guessNetTokenIn,
-                actualNetTokenIn
-            ),
-            _newTokenInputStruct(tokenToZapIn, actualNetTokenIn, toMarket.bulk)
+            _scaleApproxParams(toMarket.guessPtReceivedFromSy, toMarket.guessNetTokenIn, actualNetTokenIn),
+            _newTokenInputStruct(tokenToZapIn, actualNetTokenIn)
         );
 
-        emit AddLiquiditySingleToken(
-            msg.sender,
-            toMarket.market,
-            tokenToZapIn,
-            msg.sender,
-            actualNetTokenIn,
-            netLpOut
-        );
+        emit AddLiquiditySingleToken(msg.sender, toMarket.market, tokenToZapIn, msg.sender, actualNetTokenIn, netLpOut);
     }
 
-    function _addLiquiditySingleSy(
-        AddLiquiditySingleSyStruct calldata toMarket,
-        uint256 actualNetSyIn
-    ) internal returns (uint256 netLpOut, uint256 netSyFee) {
-        (IStandardizedYield SY, , ) = IPMarket(toMarket.market).readTokens();
+    function _addLiquiditySingleSy(AddLiquiditySingleSyStruct calldata toMarket, uint256 actualNetSyIn)
+        internal
+        returns (uint256 netLpOut, uint256 netSyFee)
+    {
+        (IStandardizedYield SY,,) = IPMarket(toMarket.market).readTokens();
 
         _safeApproveInf(address(SY), address(ROUTER));
 
@@ -250,20 +152,10 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
             toMarket.market,
             actualNetSyIn,
             toMarket.minLpOut,
-            _scaleApproxParams(
-                toMarket.guessPtReceivedFromSy,
-                toMarket.guessNetSyIn,
-                actualNetSyIn
-            )
+            _scaleApproxParams(toMarket.guessPtReceivedFromSy, toMarket.guessNetSyIn, actualNetSyIn)
         );
 
-        emit AddLiquiditySingleSy(
-            msg.sender,
-            toMarket.market,
-            msg.sender,
-            actualNetSyIn,
-            netLpOut
-        );
+        emit AddLiquiditySingleSy(msg.sender, toMarket.market, msg.sender, actualNetSyIn, netLpOut);
     }
 
     function _addLiquiditySingleTokenKeepYt(
@@ -283,77 +175,99 @@ contract PendleRouterHelper is TokenHelper, IPRouterHelper {
             toMarket.market,
             toMarket.minLpOut,
             toMarket.minYtOut,
-            _newTokenInputStruct(tokenToZapIn, actualNetTokenIn, toMarket.bulk)
+            _newTokenInputStruct(tokenToZapIn, actualNetTokenIn)
         );
 
         emit AddLiquiditySingleTokenKeepYt(
-            msg.sender,
-            toMarket.market,
-            tokenToZapIn,
-            msg.sender,
-            actualNetTokenIn,
-            netLpOut,
-            netYtOut
+            msg.sender, toMarket.market, tokenToZapIn, msg.sender, actualNetTokenIn, netLpOut, netYtOut
         );
     }
 
-    function _addLiquiditySingleSyKeepYt(
-        AddLiquiditySingleSyKeepYtStruct calldata toMarket,
-        uint256 actualNetSyIn
-    ) internal returns (uint256 netLpOut, uint256 netYtOut) {
-        (IStandardizedYield SY, , ) = IPMarket(toMarket.market).readTokens();
+    function _addLiquiditySingleSyKeepYt(AddLiquiditySingleSyKeepYtStruct calldata toMarket, uint256 actualNetSyIn)
+        internal
+        returns (uint256 netLpOut, uint256 netYtOut)
+    {
+        (IStandardizedYield SY,,) = IPMarket(toMarket.market).readTokens();
 
         _safeApproveInf(address(SY), address(ROUTER));
 
         (netLpOut, netYtOut) = ROUTER.addLiquiditySingleSyKeepYt(
-            msg.sender,
-            toMarket.market,
-            actualNetSyIn,
-            toMarket.minLpOut,
-            toMarket.minYtOut
+            msg.sender, toMarket.market, actualNetSyIn, toMarket.minLpOut, toMarket.minYtOut
         );
 
-        emit AddLiquiditySingleSyKeepYt(
-            msg.sender,
-            toMarket.market,
-            msg.sender,
-            actualNetSyIn,
-            netLpOut,
-            netYtOut
-        );
+        emit AddLiquiditySingleSyKeepYt(msg.sender, toMarket.market, msg.sender, actualNetSyIn, netLpOut, netYtOut);
     }
 
     // ============ struct helpers ============
 
-    function _newTokenInputStruct(
-        address tokenIn,
-        uint256 netTokenIn,
-        address bulk
-    ) internal pure returns (TokenInput memory res) {
+    function _newTokenInputStruct(address tokenIn, uint256 netTokenIn) internal pure returns (TokenInput memory res) {
         res.tokenIn = res.tokenMintSy = tokenIn;
         res.netTokenIn = netTokenIn;
-        res.bulk = bulk;
         return res;
     }
 
     /// @dev either SY or Token here is good since token->sy conversion is almost linearly proportional
-    function _scaleApproxParams(
-        ApproxParams calldata params,
-        uint256 guessNetTokenIn,
-        uint256 actualNetTokenIn
-    ) internal pure returns (ApproxParams memory) {
+    function _scaleApproxParams(ApproxParams calldata params, uint256 guessNetTokenIn, uint256 actualNetTokenIn)
+        internal
+        pure
+        returns (ApproxParams memory)
+    {
         if (params.guessOffchain == 0) {
             require(params.guessMin == 0 && params.guessMax == type(uint256).max, "invalid guess");
             return params;
         }
 
-        return
-            ApproxParams({
-                guessMin: (params.guessMin * actualNetTokenIn) / guessNetTokenIn,
-                guessMax: (params.guessMax * actualNetTokenIn) / guessNetTokenIn,
-                guessOffchain: (params.guessOffchain * actualNetTokenIn) / guessNetTokenIn,
-                maxIteration: params.maxIteration,
-                eps: params.eps
-            });
+        return ApproxParams({
+            guessMin: (params.guessMin * actualNetTokenIn) / guessNetTokenIn,
+            guessMax: (params.guessMax * actualNetTokenIn) / guessNetTokenIn,
+            guessOffchain: (params.guessOffchain * actualNetTokenIn) / guessNetTokenIn,
+            maxIteration: params.maxIteration,
+            eps: params.eps
+        });
     }
 }
+
+interface RouterV2InterfaceForRouterHelper {
+    function addLiquiditySingleSy(
+        address receiver,
+        address market,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        ApproxParams calldata guessPtReceivedFromSy
+    ) external returns (uint256 netLpOut, uint256 netSyFee);
+
+    function addLiquiditySingleToken(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        ApproxParams calldata guessPtReceivedFromSy,
+        TokenInput calldata input
+    ) external payable returns (uint256 netLpOut, uint256 netSyFee);
+
+    function addLiquiditySingleSyKeepYt(
+        address receiver,
+        address market,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) external returns (uint256 netLpOut, uint256 netYtOut);
+
+    function addLiquiditySingleTokenKeepYt(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input
+    ) external returns (uint256 netLpOut, uint256 netYtOut);
+
+    function removeLiquiditySingleSy(address receiver, address market, uint256 netLpToRemove, uint256 minSyOut)
+        external
+        returns (uint256 netSyOut, uint256 netSyFee);
+
+    function removeLiquiditySingleToken(
+        address receiver,
+        address market,
+        uint256 netLpToRemove,
+        TokenOutput calldata output
+    ) external returns (uint256 netTokenOut, uint256 netSyFee);
+}

package/contracts/router/base/ActionBase.sol

@@ -0,0 +1,238 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../../core/libraries/TokenHelper.sol";
+import "../../interfaces/IStandardizedYield.sol";
+import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IPAllActionType.sol";
+import "../../interfaces/IPMarket.sol";
+import "../../router/base/MarketApproxLib.sol";
+
+import "../../core/libraries/Errors.sol";
+import "../swap-aggregator/IPSwapAggregator.sol";
+
+abstract contract ActionBase is TokenHelper {
+    using MarketApproxPtOutLib for MarketState;
+    using PMath for uint256;
+    using PYIndexLib for IPYieldToken;
+
+    bytes internal constant EMPTY_BYTES = abi.encode();
+
+    // ----------------- MINT REDEEM SY PY -----------------
+
+    function _mintSyFromToken(address receiver, address SY, uint256 minSyOut, TokenInput calldata inp)
+        internal
+        returns (uint256 netSyOut)
+    {
+        SwapType swapType = inp.swapData.swapType;
+
+        uint256 netTokenMintSy;
+
+        if (swapType == SwapType.NONE) {
+            _transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);
+            netTokenMintSy = inp.netTokenIn;
+        } else if (swapType == SwapType.ETH_WETH) {
+            _transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);
+            _wrap_unwrap_ETH(inp.tokenIn, inp.tokenMintSy, inp.netTokenIn);
+            netTokenMintSy = inp.netTokenIn;
+        } else {
+            _swapTokenInput(inp);
+            netTokenMintSy = _selfBalance(inp.tokenMintSy);
+        }
+
+        netSyOut = __mintSy(receiver, SY, netTokenMintSy, minSyOut, inp);
+    }
+
+    function _swapTokenInput(TokenInput calldata inp) internal {
+        if (inp.tokenIn == NATIVE) _transferIn(NATIVE, msg.sender, inp.netTokenIn);
+        else _transferFrom(IERC20(inp.tokenIn), msg.sender, inp.pendleSwap, inp.netTokenIn);
+
+        IPSwapAggregator(inp.pendleSwap).swap{value: inp.tokenIn == NATIVE ? inp.netTokenIn : 0}(
+            inp.tokenIn, inp.netTokenIn, inp.swapData
+        );
+    }
+
+    function __mintSy(address receiver, address SY, uint256 netTokenMintSy, uint256 minSyOut, TokenInput calldata inp)
+        private
+        returns (uint256 netSyOut)
+    {
+        uint256 netNative = inp.tokenMintSy == NATIVE ? netTokenMintSy : 0;
+        netSyOut = IStandardizedYield(SY).deposit{value: netNative}(receiver, inp.tokenMintSy, netTokenMintSy, minSyOut);
+    }
+
+    function _redeemSyToToken(address receiver, address SY, uint256 netSyIn, TokenOutput calldata out, bool doPull)
+        internal
+        returns (uint256 netTokenOut)
+    {
+        SwapType swapType = out.swapData.swapType;
+
+        if (swapType == SwapType.NONE) {
+            netTokenOut = __redeemSy(receiver, SY, netSyIn, out, doPull);
+        } else if (swapType == SwapType.ETH_WETH) {
+            netTokenOut = __redeemSy(address(this), SY, netSyIn, out, doPull); // ETH:WETH is 1:1
+
+            _wrap_unwrap_ETH(out.tokenRedeemSy, out.tokenOut, netTokenOut);
+
+            _transferOut(out.tokenOut, receiver, netTokenOut);
+        } else {
+            uint256 netTokenRedeemed = __redeemSy(out.pendleSwap, SY, netSyIn, out, doPull);
+
+            IPSwapAggregator(out.pendleSwap).swap(out.tokenRedeemSy, netTokenRedeemed, out.swapData);
+
+            netTokenOut = _selfBalance(out.tokenOut);
+
+            _transferOut(out.tokenOut, receiver, netTokenOut);
+        }
+
+        if (netTokenOut < out.minTokenOut) {
+            revert Errors.RouterInsufficientTokenOut(netTokenOut, out.minTokenOut);
+        }
+    }
+
+    function __redeemSy(address receiver, address SY, uint256 netSyIn, TokenOutput calldata out, bool doPull)
+        private
+        returns (uint256 netTokenRedeemed)
+    {
+        if (doPull) {
+            _transferFrom(IERC20(SY), msg.sender, SY, netSyIn);
+        }
+
+        netTokenRedeemed = IStandardizedYield(SY).redeem(receiver, netSyIn, out.tokenRedeemSy, 0, true);
+    }
+
+    function _mintPyFromSy(address receiver, address SY, address YT, uint256 netSyIn, uint256 minPyOut, bool doPull)
+        internal
+        returns (uint256 netPyOut)
+    {
+        if (doPull) {
+            _transferFrom(IERC20(SY), msg.sender, YT, netSyIn);
+        }
+
+        netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
+        if (netPyOut < minPyOut) revert Errors.RouterInsufficientPYOut(netPyOut, minPyOut);
+    }
+
+    function _redeemPyToSy(address receiver, address YT, uint256 netPyIn, uint256 minSyOut)
+        internal
+        returns (uint256 netSyOut)
+    {
+        address PT = IPYieldToken(YT).PT();
+
+        _transferFrom(IERC20(PT), msg.sender, YT, netPyIn);
+
+        bool needToBurnYt = (!IPYieldToken(YT).isExpired());
+        if (needToBurnYt) _transferFrom(IERC20(YT), msg.sender, YT, netPyIn);
+
+        netSyOut = IPYieldToken(YT).redeemPY(receiver);
+        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
+    }
+
+    // ----------------- HELPER -----------------
+
+    function _readMarket(address market) internal view returns (MarketState memory) {
+        return IPMarket(market).readState(address(this));
+    }
+
+    // ----------------- PT SWAP -----------------
+
+    function _entry_swapExactPtForSy(address market, LimitOrderData calldata limit) internal view returns (address) {
+        return !_isEmptyLimit(limit) ? address(this) : market;
+    }
+
+    function _swapExactPtForSy(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) internal returns (uint256 netSyOut, uint256 netSyFee) {
+        (, IPPrincipalToken PT,) = IPMarket(market).readTokens();
+
+        uint256 netPtLeft = exactPtIn;
+        bool doMarketOrder = true;
+
+        if (!_isEmptyLimit(limit)) {
+            (netPtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, netPtLeft, limit);
+            if (doMarketOrder) {
+                _transferOut(address(PT), market, netPtLeft);
+            }
+        }
+
+        if (doMarketOrder) {
+            (uint256 netSyOutMarket, uint256 netSyFeeMarket) =
+                IPMarket(market).swapExactPtForSy(receiver, netPtLeft, EMPTY_BYTES);
+
+            netSyOut += netSyOutMarket;
+            netSyFee += netSyFeeMarket;
+        }
+
+        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
+    }
+
+    function _entry_swapExactSyForPt(address market, LimitOrderData calldata limit) internal view returns (address) {
+        return !_isEmptyLimit(limit) ? address(this) : market;
+    }
+
+    function _swapExactSyForPt(
+        address receiver,
+        address market,
+        uint256 exactSyIn,
+        uint256 minPtOut,
+        ApproxParams calldata guessPtOut,
+        LimitOrderData calldata limit
+    ) internal returns (uint256 netPtOut, uint256 netSyFee) {
+        (IStandardizedYield SY,, IPYieldToken YT) = IPMarket(market).readTokens();
+        uint256 netSyLeft = exactSyIn;
+        bool doMarketOrder = true;
+
+        if (!_isEmptyLimit(limit)) {
+            (netSyLeft, netPtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, netSyLeft, limit);
+            if (doMarketOrder) {
+                _transferOut(address(SY), market, netSyLeft);
+            }
+        }
+
+        if (doMarketOrder) {
+            (uint256 netPtOutMarket,) =
+                _readMarket(market).approxSwapExactSyForPt(YT.newIndex(), netSyLeft, block.timestamp, guessPtOut);
+
+            (, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(receiver, netPtOutMarket, EMPTY_BYTES);
+
+            netPtOut += netPtOutMarket;
+            netSyFee += netSyFeeMarket;
+        }
+
+        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
+    }
+
+    // ----------------- LIMIT ORDERS -----------------
+    function _fillLimit(address receiver, uint256 netInput, LimitOrderData calldata lim)
+        internal
+        returns (uint256 netLeft, uint256 netOut, uint256 netSyFee, bool doMarketOrder)
+    {
+        IPLimitRouter router = IPLimitRouter(lim.limitRouter);
+        netLeft = netInput;
+
+        if (lim.normalFills.length != 0) {
+            (uint256 actualMaking, uint256 actualTaking, uint256 totalFee) =
+                router.normalFill(lim.normalFills, receiver, netLeft, EMPTY_BYTES);
+            netOut += actualMaking;
+            netSyFee += totalFee;
+            netLeft -= actualTaking;
+        }
+
+        if (lim.flashFills.length != 0) {
+            (uint256 totalOutput, uint256 totalInput, uint256 totalFee) =
+                router.flashFill(lim.flashFills, receiver, netLeft, EMPTY_BYTES);
+            netOut += totalOutput;
+            netSyFee += totalFee;
+            netLeft -= totalInput;
+        }
+
+        doMarketOrder = netLeft > netInput.mulDown(lim.epsSkipMarket);
+    }
+
+    function _isEmptyLimit(LimitOrderData calldata a) internal pure returns (bool) {
+        return a.normalFills.length == 0 && a.flashFills.length == 0;
+    }
+}