@pendle/core-v2 4.5.2 → 4.7.0

package/contracts/oracles/{PendlePtOracleLib.sol → PendlePYOracleLib.sol}

@@ -6,7 +6,7 @@ import "../core/libraries/math/PMath.sol";
 
 // This library can & should be integrated directly for optimal gas usage.
 // If you prefer not to integrate it directly, the PendlePtOracle contract (a pre-deployed version of this contract) can be used.
-library PendlePtOracleLib {
+library PendlePYOracleLib {
     using PMath for uint256;
     using PMath for int256;
 
@@ -25,6 +25,21 @@ library PendlePtOracleLib {
         }
     }
 
+    /**
+     * This function returns the twap rate YT/Asset on market, but take into account the current rate of SY
+     This is to account for special cases where underlying asset becomes insolvent and has decreasing exchangeRate
+     * @param market market to get rate from
+     * @param duration twap duration
+     */
+    function getYtToAssetRate(IPMarket market, uint32 duration) internal view returns (uint256) {
+        (uint256 syIndex, uint256 pyIndex) = getSYandPYIndexCurrent(market);
+        if (syIndex >= pyIndex) {
+            return getYtToAssetRateRaw(market, duration);
+        } else {
+            return (getYtToAssetRateRaw(market, duration) * syIndex) / pyIndex;
+        }
+    }
+
     /// @notice Similar to getPtToAsset but returns the rate in SY instead
     function getPtToSyRate(IPMarket market, uint32 duration) internal view returns (uint256) {
         (uint256 syIndex, uint256 pyIndex) = getSYandPYIndexCurrent(market);
@@ -35,6 +50,16 @@ library PendlePtOracleLib {
         }
     }
 
+    /// @notice Similar to getPtToAsset but returns the rate in SY instead
+    function getYtToSyRate(IPMarket market, uint32 duration) internal view returns (uint256) {
+        (uint256 syIndex, uint256 pyIndex) = getSYandPYIndexCurrent(market);
+        if (syIndex >= pyIndex) {
+            return getYtToAssetRateRaw(market, duration).divDown(syIndex);
+        } else {
+            return getYtToAssetRateRaw(market, duration).divDown(pyIndex);
+        }
+    }
+
     /// @notice returns the raw rate without taking into account whether SY is solvent
     function getPtToAssetRateRaw(IPMarket market, uint32 duration) internal view returns (uint256) {
         uint256 expiry = market.expiry();
@@ -49,6 +74,11 @@ library PendlePtOracleLib {
         }
     }
 
+    /// @notice returns the raw rate without taking into account whether SY is solvent
+    function getYtToAssetRateRaw(IPMarket market, uint32 duration) internal view returns (uint256) {
+        return PMath.ONE - getPtToAssetRateRaw(market, duration);
+    }
+
     function getSYandPYIndexCurrent(IPMarket market) internal view returns (uint256 syIndex, uint256 pyIndex) {
         (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
 

package/contracts/oracles/samples/BoringLpGlpOracle.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.17;
 
 import "../PendleLpOracleLib.sol";
-import "../../interfaces/IPPtLpOracle.sol";
+import "../../interfaces/IPPYLpOracle.sol";
 import "../../interfaces/GMX/IGlpManager.sol";
 import "../../core/libraries/math/PMath.sol";
 
@@ -23,7 +23,7 @@ contract BoringLpGlpOracle {
         market = _market;
         glpManager = _glpManager;
 
-        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtLpOracle(_ptOracle).getOracleState(
+        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPYLpOracle(_ptOracle).getOracleState(
             market,
             twapDuration
         );

package/contracts/oracles/samples/{BoringPtUsdChainlinkOracle.sol → BoringPYUsdChainlinkAssetOracle.sol}

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "../../interfaces/IPPtLpOracle.sol";
+import "../../interfaces/IPPYLpOracle.sol";
 import "../../interfaces/IPMarket.sol";
 import "../../core/libraries/math/PMath.sol";
 import "../PendleLpOracleLib.sol";
@@ -9,29 +9,41 @@ import "../PendleLpOracleLib.sol";
 import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
 
 /**
- * @notice The returned price from this contract is multiplied by the default USD price of the asset, as read from Chainlink Oracles.
- * For more details into how the oracle is implemented, refer to PendlePtOracle & PendlePtOracleLib.
+ * @notice The returned price from this contract is multiplied by the default USD price of the
+ * underlying asset, as read from a Chainlink-interface oracle.
+ *
+ * Example of this usage:
+ * - PT-wstETH = ptToAssetRate * stETH price
+ * - PT-silo-crvUSD = ptToAssetRate * crvUSD price
+ *
+ * For more details into how the oracle is implemented, refer to PendlePYLpOracle & PendlePYOracleLib.
  */
-contract BoringPtUsdChainlinkOracle {
-    using PendlePtOracleLib for IPMarket;
+contract BoringPYUsdChainlinkAssetOracle {
+    using PendlePYOracleLib for IPMarket;
 
     uint32 public immutable twapDuration;
     address public immutable market;
     address public immutable feed;
     uint8 public immutable feedDecimals;
-    address public immutable ptOracle;
+    address public immutable pyLpOracle;
 
-    constructor(uint32 _twapDuration, address _market, address _feed, address _ptOracle) {
+    constructor(uint32 _twapDuration, address _market, address _feed, address _pyLpOracle) {
         twapDuration = _twapDuration;
         market = _market;
         feed = _feed;
         feedDecimals = IChainlinkAggregator(feed).decimals();
 
         // required only for sample2
-        ptOracle = _ptOracle;
+        pyLpOracle = _pyLpOracle;
+
+        /**
+         * @notice All pricing functions in this contract should only be used after checkOracleState() is ran successfully without reverting.
+         * This equals to calling checkOracleState() in your oracle constructor.
+         */
+        // checkOracleState();
     }
 
-    /// @notice direct integration with PendlePtOracleLib, which optimizes gas efficiency.
+    /// @notice direct integration with PendlePYOracleLib, which optimizes gas efficiency.
     /// @notice please checkOracleState() before use
     function getPtPriceSample1() external view virtual returns (uint256) {
         uint256 ptRate = IPMarket(market).getPtToAssetRate(twapDuration);
@@ -43,11 +55,23 @@ contract BoringPtUsdChainlinkOracle {
     /// but slightly higher gas usage (~ 4000 gas, 2 external calls & 1 cold code load)
     /// @notice please checkOracleState() before use
     function getPtPriceSample2() external view virtual returns (uint256) {
-        uint256 ptRate = IPPtLpOracle(ptOracle).getPtToAssetRate(market, twapDuration);
+        uint256 ptRate = IPPYLpOracle(pyLpOracle).getPtToAssetRate(market, twapDuration);
         uint256 assetPrice = _getUnderlyingAssetPrice();
         return (assetPrice * ptRate) / PMath.ONE;
     }
 
+    function getYtPriceSample1() external view virtual returns (uint256) {
+        uint256 ytRate = IPMarket(market).getYtToAssetRate(twapDuration);
+        uint256 assetPrice = _getUnderlyingAssetPrice();
+        return (assetPrice * ytRate) / PMath.ONE;
+    }
+
+    function getYtPriceSample2() external view virtual returns (uint256) {
+        uint256 ytRate = IPPYLpOracle(pyLpOracle).getYtToAssetRate(market, twapDuration);
+        uint256 assetPrice = _getUnderlyingAssetPrice();
+        return (assetPrice * ytRate) / PMath.ONE;
+    }
+
     function _getUnderlyingAssetPrice() internal view virtual returns (uint256) {
         uint256 rawPrice = uint256(IChainlinkAggregator(feed).latestAnswer());
         return feedDecimals < 18 ? rawPrice * 10 ** (18 - feedDecimals) : rawPrice / 10 ** (feedDecimals - 18);
@@ -60,8 +84,8 @@ contract BoringPtUsdChainlinkOracle {
 
     /// @notice Call only once for each (market, duration). Once successful, it's permanently valid (also for any shorter duration).
     function checkOracleState() external view {
-        (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied) = IPPtLpOracle(
-            ptOracle
+        (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied) = IPPYLpOracle(
+            pyLpOracle
         ).getOracleState(market, twapDuration);
 
         if (increaseCardinalityRequired) {

package/contracts/oracles/samples/BoringPYUsdChainlinkSYOracle.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../interfaces/IPPYLpOracle.sol";
+import "../../interfaces/IPMarket.sol";
+import "../../core/libraries/math/PMath.sol";
+import "../PendleLpOracleLib.sol";
+
+import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+/**
+ * @notice The returned price from this contract is multiplied by the default USD price of the
+ * SY-equivalent token, as read from a Chainlink-interface oracle.
+ *
+ * Example of this usage:
+ * - PT-weETH = ptToSyRate * weETH price
+ * - PT-ezETH = ptToSyRate * ezETH price
+ *
+ * For more details into how the oracle is implemented, refer to PendlePYLpOracle & PendlePYOracleLib.
+ */
+contract BoringPYUsdChainlinkSYOracle {
+    using PendlePYOracleLib for IPMarket;
+
+    uint32 public immutable twapDuration;
+    address public immutable market;
+    address public immutable feed;
+    uint8 public immutable feedDecimals;
+    address public immutable pyLpOracle;
+
+    constructor(uint32 _twapDuration, address _market, address _feed, address _pyLpOracle) {
+        twapDuration = _twapDuration;
+        market = _market;
+        feed = _feed;
+        feedDecimals = IChainlinkAggregator(feed).decimals();
+
+        // required only for sample2
+        pyLpOracle = _pyLpOracle;
+
+        /**
+         * @notice All pricing functions in this contract should only be used after checkOracleState() is ran successfully without reverting.
+         * This equals to calling checkOracleState() in your oracle constructor.
+         */
+        // checkOracleState();
+    }
+
+    /// @notice direct integration with PendlePYOracleLib, which optimizes gas efficiency.
+    /// @notice please checkOracleState() before use
+    function getPtPriceSample1() external view virtual returns (uint256) {
+        uint256 ptRate = IPMarket(market).getPtToSyRate(twapDuration);
+        uint256 syEquivalentTokenPrice = _getSYEquivalentTokenPrice();
+        return (syEquivalentTokenPrice * ptRate) / PMath.ONE;
+    }
+
+    /// @notice integration with the PendlePtOracle contract, resulting in a smaller bytecode size and simpler structure
+    /// but slightly higher gas usage (~ 4000 gas, 2 external calls & 1 cold code load)
+    /// @notice please checkOracleState() before use
+    function getPtPriceSample2() external view virtual returns (uint256) {
+        uint256 ptRate = IPPYLpOracle(pyLpOracle).getPtToSyRate(market, twapDuration);
+        uint256 syEquivalentTokenPrice = _getSYEquivalentTokenPrice();
+        return (syEquivalentTokenPrice * ptRate) / PMath.ONE;
+    }
+
+    function getYtPriceSample1() external view virtual returns (uint256) {
+        uint256 ytRate = IPMarket(market).getYtToSyRate(twapDuration);
+        uint256 syEquivalentTokenPrice = _getSYEquivalentTokenPrice();
+        return (syEquivalentTokenPrice * ytRate) / PMath.ONE;
+    }
+
+    function getYtPriceSample2() external view virtual returns (uint256) {
+        uint256 ytRate = IPPYLpOracle(pyLpOracle).getYtToSyRate(market, twapDuration);
+        uint256 syEquivalentTokenPrice = _getSYEquivalentTokenPrice();
+        return (syEquivalentTokenPrice * ytRate) / PMath.ONE;
+    }
+
+    function _getSYEquivalentTokenPrice() internal view virtual returns (uint256) {
+        uint256 rawPrice = uint256(IChainlinkAggregator(feed).latestAnswer());
+        return feedDecimals < 18 ? rawPrice * 10 ** (18 - feedDecimals) : rawPrice / 10 ** (feedDecimals - 18);
+    }
+
+    // ------------------ NOT TO INCLUDE IN PRODUCTION CODE ------------------
+
+    error IncreaseCardinalityRequired(uint16 cardinalityRequired);
+    error AdditionalWaitRequired(uint32 duration);
+
+    /// @notice Call only once for each (market, duration). Once successful, it's permanently valid (also for any shorter duration).
+    function checkOracleState() external view {
+        (bool increaseCardinalityRequired, uint16 cardinalityRequired, bool oldestObservationSatisfied) = IPPYLpOracle(
+            pyLpOracle
+        ).getOracleState(market, twapDuration);
+
+        if (increaseCardinalityRequired) {
+            // It's required to call IPMarket(market).increaseObservationsCardinalityNext(cardinalityRequired) and wait for
+            // at least the twapDuration, to allow data population.
+            revert IncreaseCardinalityRequired(cardinalityRequired);
+        }
+
+        if (!oldestObservationSatisfied) {
+            // It's necessary to wait for at least the twapDuration, to allow data population.
+            revert AdditionalWaitRequired(twapDuration);
+        }
+    }
+}

package/contracts/router/ActionMiscV3.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.17;
 
 import "./base/ActionBase.sol";
 import "../interfaces/IPActionMiscV3.sol";
+import "../interfaces/IPReflector.sol";
 
 contract ActionMiscV3 is IPActionMiscV3, ActionBase {
     function mintSyFromToken(
@@ -79,18 +80,16 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         address[] calldata yts,
         address[] calldata markets
     ) external {
-        unchecked {
-            for (uint256 i = 0; i < sys.length; ++i) {
-                IStandardizedYield(sys[i]).claimRewards(user);
-            }
+        for (uint256 i = 0; i < sys.length; ++i) {
+            IStandardizedYield(sys[i]).claimRewards(user);
+        }
 
-            for (uint256 i = 0; i < yts.length; ++i) {
-                IPYieldToken(yts[i]).redeemDueInterestAndRewards(user, true, true);
-            }
+        for (uint256 i = 0; i < yts.length; ++i) {
+            IPYieldToken(yts[i]).redeemDueInterestAndRewards(user, true, true);
+        }
 
-            for (uint256 i = 0; i < markets.length; ++i) {
-                IPMarket(markets[i]).redeemRewards(user);
-            }
+        for (uint256 i = 0; i < markets.length; ++i) {
+            IPMarket(markets[i]).redeemRewards(user);
         }
     }
 
@@ -118,45 +117,194 @@ contract ActionMiscV3 is IPActionMiscV3, ActionBase {
         netTokenOut = IStandardizedYield(SY).redeem(receiver, netSyInterm, tokenRedeemSy, minTokenOut, true);
     }
 
+    /// @dev The interface might change in the future, check with Pendle team before use
+    function exitPreExpToToken(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        TokenOutput calldata output,
+        LimitOrderData calldata limit
+    ) external returns (uint256 totalTokenOut, ExitPreExpReturnParams memory params) {
+        IStandardizedYield SY;
+
+        (SY, params) = _exitPreExpToSy(true, address(0), market, netPtIn, netYtIn, netLpIn, limit);
+        totalTokenOut = _redeemSyToToken(receiver, address(SY), params.totalSyOut, output, false);
+
+        emit ExitPreExpToToken(msg.sender, market, output.tokenOut, receiver, netLpIn, totalTokenOut, params);
+    }
+
+    /// @dev The interface might change in the future, check with Pendle team before use
+    function exitPreExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        uint256 minSyOut,
+        LimitOrderData calldata limit
+    ) external returns (ExitPreExpReturnParams memory params) {
+        (, params) = _exitPreExpToSy(false, receiver, market, netPtIn, netYtIn, netLpIn, limit);
+        require(params.totalSyOut >= minSyOut, "Slippage: INSUFFICIENT_SY_OUT");
+
+        emit ExitPreExpToSy(msg.sender, market, receiver, netLpIn, params);
+    }
+
+    function _exitPreExpToSy(
+        bool setReceiverToSy,
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netYtIn,
+        uint256 netLpIn,
+        LimitOrderData calldata limit
+    ) internal returns (IStandardizedYield SY, ExitPreExpReturnParams memory p) {
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+        (SY, PT, YT) = IPMarket(market).readTokens();
+
+        if (setReceiverToSy) receiver = address(SY);
+
+        if (netLpIn > 0) {
+            _transferFrom(IERC20(market), msg.sender, market, netLpIn);
+            (p.netSyFromRemove, p.netPtFromRemove) = IPMarket(market).burn(receiver, address(this), netLpIn);
+        }
+
+        if (netPtIn > 0) {
+            _transferIn(address(PT), msg.sender, netPtIn);
+        }
+
+        p.netPyRedeem = PMath.min(p.netPtFromRemove + netPtIn, netYtIn);
+
+        if (p.netPyRedeem > 0) {
+            _transferOut(address(PT), address(YT), p.netPyRedeem);
+            _transferFrom(YT, msg.sender, address(YT), p.netPyRedeem);
+            p.netSyFromRedeem = IPYieldToken(YT).redeemPY(receiver);
+        }
+
+        p.netPtSwap = p.netPtFromRemove + netPtIn - p.netPyRedeem;
+        p.netYtSwap = netYtIn - p.netPyRedeem;
+
+        if (p.netPtSwap > 0) {
+            address ptEntry = _entry_swapExactPtForSy(market, limit);
+            if (ptEntry != address(this)) _transferOut(address(PT), ptEntry, p.netPtSwap);
+            (p.netSyFromSwap, p.netSyFee) = _swapExactPtForSy(receiver, market, p.netPtSwap, 0, limit);
+        } else if (p.netYtSwap > 0) {
+            _transferFrom(YT, msg.sender, _entry_swapExactYtForSy(YT, limit), p.netYtSwap);
+            (p.netSyFromSwap, p.netSyFee) = _swapExactYtForSy(receiver, market, SY, YT, p.netYtSwap, 0, limit);
+        }
+
+        p.totalSyOut = p.netSyFromRemove + p.netSyFromRedeem + p.netSyFromSwap;
+    }
+
+    /// @dev The interface might change in the future, check with Pendle team before use
+    function exitPostExpToToken(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn,
+        TokenOutput calldata output
+    ) external returns (uint256 totalTokenOut, ExitPostExpReturnParams memory params) {
+        IStandardizedYield SY;
+
+        (SY, params) = _exitPostExpToSy(true, address(0), market, netPtIn, netLpIn);
+        totalTokenOut = _redeemSyToToken(receiver, address(SY), params.totalSyOut, output, false);
+
+        emit ExitPostExpToToken(msg.sender, market, output.tokenOut, receiver, netLpIn, totalTokenOut, params);
+    }
+
+    /// @dev The interface might change in the future, check with Pendle team before use
+    function exitPostExpToSy(
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn,
+        uint256 minSyOut
+    ) external returns (ExitPostExpReturnParams memory params) {
+        (, params) = _exitPostExpToSy(false, receiver, market, netPtIn, netLpIn);
+        require(params.totalSyOut >= minSyOut, "Slippage: INSUFFICIENT_SY_OUT");
+
+        emit ExitPostExpToSy(msg.sender, market, receiver, netLpIn, params);
+    }
+
+    function _exitPostExpToSy(
+        bool setReceiverToSy,
+        address receiver,
+        address market,
+        uint256 netPtIn,
+        uint256 netLpIn
+    ) internal returns (IStandardizedYield SY, ExitPostExpReturnParams memory p) {
+        IPPrincipalToken PT;
+        IPYieldToken YT;
+        (SY, PT, YT) = IPMarket(market).readTokens();
+
+        if (setReceiverToSy) receiver = address(SY);
+
+        if (netLpIn > 0) {
+            _transferFrom(IERC20(market), msg.sender, market, netLpIn);
+            (p.netSyFromRemove, p.netPtFromRemove) = IPMarket(market).burn(receiver, address(YT), netLpIn);
+        }
+
+        if (netPtIn > 0) {
+            _transferFrom(PT, msg.sender, address(YT), netPtIn);
+        }
+
+        p.netPtRedeem = p.netPtFromRemove + netPtIn;
+        p.netSyFromRedeem = IPYieldToken(YT).redeemPY(receiver);
+
+        p.totalSyOut = p.netSyFromRemove + p.netSyFromRedeem;
+    }
+
     // ----------------- MISC FUNCTIONS -----------------
 
     function boostMarkets(address[] memory markets) external {
-        for (uint256 i = 0; i < markets.length; ) {
+        for (uint256 i = 0; i < markets.length; i++) {
             IPMarket(markets[i]).transferFrom(msg.sender, markets[i], 0);
-            unchecked {
-                i++;
-            }
         }
     }
 
     function multicall(Call3[] calldata calls) external payable returns (Result[] memory res) {
         uint256 length = calls.length;
         res = new Result[](length);
-        Call3 calldata call;
-        for (uint256 i = 0; i < length; ) {
-            call = calls[i];
-
-            // delegatecall to itself, it turns allowing invoking functions from other actions
-            (bool success, bytes memory result) = address(this).delegatecall(call.callData);
-
-            if (!success && !call.allowFailure) {
-                assembly {
-                    // We use Yul's revert() to bubble up errors from the target contract.
-                    revert(add(32, result), mload(result))
-                }
-            }
-
-            res[i].success = success;
-            res[i].returnData = result;
-
-            unchecked {
-                ++i;
-            }
+        for (uint256 i = 0; i < length; i++) {
+            (bool success, bytes memory result) = _delegateToSelf(calls[i].callData, calls[i].allowFailure);
+            res[i] = Result(success, result);
         }
     }
 
+    /// @dev The interface might change in the future, check with Pendle team before use
+    function callAndReflect(
+        address payable reflector,
+        bytes calldata selfCall1,
+        bytes calldata selfCall2,
+        bytes calldata reflectCall
+    ) external payable returns (bytes memory selfRes1, bytes memory selfRes2, bytes memory reflectRes) {
+        (, selfRes1) = _delegateToSelf(selfCall1, false);
+        if (selfCall2.length > 0) (, selfRes2) = _delegateToSelf(selfCall2, false);
+        reflectRes = _callToReflector(reflector, reflectCall);
+    }
+
     function simulate(address target, bytes calldata data) external payable {
         (bool success, bytes memory result) = target.delegatecall(data);
         revert Errors.SimulationResults(success, result);
     }
+
+    function _delegateToSelf(
+        bytes memory data,
+        bool allowFailure
+    ) internal returns (bool success, bytes memory result) {
+        (success, result) = address(this).delegatecall(data);
+
+        if (!success && !allowFailure) {
+            assembly {
+                // We use Yul's revert() to bubble up errors from the target contract.
+                revert(add(32, result), mload(result))
+            }
+        }
+    }
+
+    function _callToReflector(address payable reflector, bytes memory data) internal returns (bytes memory) {
+        return IPReflector(reflector).reflect(data);
+    }
 }

package/contracts/router/ActionSwapYTV3.sol

@@ -52,51 +52,6 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
         emit SwapYtAndSy(msg.sender, market, receiver, netYtOut.Int(), exactSyIn.neg());
     }
 
-    function _entry_swapExactSyForYt(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
-        return !_isEmptyLimit(limit) ? address(this) : address(YT);
-    }
-
-    function _swapExactSyForYt(
-        address receiver,
-        address market,
-        IStandardizedYield SY,
-        IPYieldToken YT,
-        uint256 exactSyIn,
-        uint256 minYtOut,
-        ApproxParams calldata guessYtOut,
-        LimitOrderData calldata limit
-    ) internal returns (uint256 netYtOut, uint256 netSyFee) {
-        uint256 netSyLeft = exactSyIn;
-        bool doMarketOrder = true;
-
-        if (!_isEmptyLimit(limit)) {
-            (netSyLeft, netYtOut, netSyFee, doMarketOrder) = _fillLimit(receiver, SY, netSyLeft, limit);
-            if (doMarketOrder) {
-                _transferOut(address(SY), address(YT), netSyLeft);
-            }
-        }
-
-        if (doMarketOrder) {
-            (uint256 netYtOutMarket, ) = _readMarket(market).approxSwapExactSyForYt(
-                YT.newIndex(),
-                netSyLeft,
-                block.timestamp,
-                guessYtOut
-            );
-
-            (, uint256 netSyFeeMarket) = IPMarket(market).swapExactPtForSy(
-                address(YT),
-                netYtOutMarket, // exactPtIn = netYtOut
-                _encodeSwapExactSyForYt(receiver, YT)
-            );
-
-            netYtOut += netYtOutMarket;
-            netSyFee += netSyFeeMarket;
-        }
-
-        if (netYtOut < minYtOut) revert("Slippage: INSUFFICIENT_YT_OUT");
-    }
-
     // ------------------ SWAP TOKEN FOR TOKEN ------------------
 
     function swapExactYtForToken(
@@ -138,46 +93,6 @@ contract ActionSwapYTV3 is CallbackHelper, IPActionSwapYTV3, ActionBase {
         emit SwapYtAndSy(msg.sender, market, receiver, exactYtIn.neg(), netSyOut.Int());
     }
 
-    function _entry_swapExactYtForSy(IPYieldToken YT, LimitOrderData calldata limit) internal view returns (address) {
-        return !_isEmptyLimit(limit) ? address(this) : address(YT);
-    }
-
-    function _swapExactYtForSy(
-        address receiver,
-        address market,
-        IStandardizedYield SY,
-        IPYieldToken YT,
-        uint256 exactYtIn,
-        uint256 minSyOut,
-        LimitOrderData calldata limit
-    ) internal returns (uint256 netSyOut, uint256 netSyFee) {
-        uint256 netYtLeft = exactYtIn;
-        bool doMarketOrder = true;
-
-        if (!_isEmptyLimit(limit)) {
-            (netYtLeft, netSyOut, netSyFee, doMarketOrder) = _fillLimit(receiver, YT, netYtLeft, limit);
-            if (doMarketOrder) {
-                _transferOut(address(YT), address(YT), netYtLeft);
-            }
-        }
-
-        if (doMarketOrder) {
-            uint256 preSyBalance = SY.balanceOf(receiver);
-
-            (, uint256 netSyFeeMarket) = IPMarket(market).swapSyForExactPt(
-                address(YT),
-                netYtLeft, // exactPtOut = netYtLeft
-                _encodeSwapYtForSy(receiver, YT)
-            );
-
-            // avoid stack issue
-            netSyFee += netSyFeeMarket;
-            netSyOut += SY.balanceOf(receiver) - preSyBalance;
-        }
-
-        if (netSyOut < minSyOut) revert("Slippage: INSUFFICIENT_SY_OUT");
-    }
-
     // ------------------ SWAP PT FOR YT ------------------
 
     function swapExactPtForYt(