@pendle/core-v2 0.21.0-testnet → 1.0.0-testnet

package/contracts/router/ActionAddRemoveLiq.sol

@@ -21,13 +21,9 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     using MarketApproxPtInLib for MarketState;
     using MarketApproxPtOutLib for MarketState;
     using PYIndexLib for IPYieldToken;
+    using PYIndexLib for PYIndex;
     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
-    {}
-
     /**
      * @notice Adds liquidity to the SY/PT market, granting LP tokens in return
      * @dev Will mint as much LP as possible given no more than `netSyDesired` and `netPtDesired`,
@@ -258,6 +254,78 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         );
     }
 
+    /**
+     * @notice Mints partial SY to PT+YT, returns YT to user, then uses PT+SY to add liquidity
+     * @param netSyIn amount of SY to be transferred in from caller
+     * @return netLpOut actual LP output, will not be lower than `minLpOut`
+     * @return netYtOut actual YT output, will not be lower than `minYtOut`
+     * @dev Reverts if market is expired
+     */
+    function addLiquiditySingleSyKeepYt(
+        address receiver,
+        address market,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) external returns (uint256 netLpOut, uint256 netYtOut) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        _transferIn(address(SY), msg.sender, netSyIn);
+
+        (netLpOut, netYtOut) = _addLiquiditySingleSyKeepYt(
+            receiver,
+            market,
+            SY,
+            YT,
+            netSyIn,
+            minLpOut,
+            minYtOut
+        );
+
+        emit AddLiquiditySingleSyKeepYt(msg.sender, market, receiver, netSyIn, netLpOut, netYtOut);
+    }
+
+    /**
+     * @notice Adds liquidity and returns leftover YT using a single token input. The input token
+     * is first swapped through Kyberswap to a SY-mintable token, the rest is the same as
+     * `addLiquiditySingleSyKeepYt()`
+     * @param input data for input token, see {`./kyberswap/KyberSwapHelper.sol`}
+     * @return netLpOut actual LP output, will not be lower than `minLpOut`
+     * @return netYtOut actual YT output, will not be lower than `minYtOut`
+     * @dev Reverts if market is expired
+     */
+    function addLiquiditySingleTokenKeepYt(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input
+    ) external returns (uint256 netLpOut, uint256 netYtOut) {
+        (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 netSyUsed = _mintSyFromToken(address(this), address(SY), 1, input);
+
+        (netLpOut, netYtOut) = _addLiquiditySingleSyKeepYt(
+            receiver,
+            market,
+            SY,
+            YT,
+            netSyUsed,
+            minLpOut,
+            minYtOut
+        );
+
+        emit AddLiquiditySingleTokenKeepYt(
+            msg.sender,
+            market,
+            input.tokenIn,
+            receiver,
+            input.netTokenIn,
+            netLpOut,
+            netYtOut
+        );
+    }
+
     /**
      * @notice Burns LP token to remove SY/PT liquidity
      * @param netLpToRemove amount of LP to be burned from caller
@@ -473,6 +541,48 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
         if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
     }
 
+    /**
+     * @dev algorithm:
+        - Split SY into a SY and b SY (with a + b = netSyIn)
+        - Mint PY with a SY ---> gives (a * pyIndex / ONE) PT + YT
+        - Mint LP with (a * pyIndex / ONE) PT and b SY
+
+        -> We want (a * pyIndex / ONE) / totalPt = b / totalSy
+        -> a * (1 + pyIndex * totalSy / ONE / totalPt) = netSyIn
+        -> a = (netSyIn * totalPt) / (totalPt + (pyIndex * totalSy / ONE))
+        -> a = (netSyIn * totalPt) / (totalPt + totalAsset)
+     */
+    function _addLiquiditySingleSyKeepYt(
+        address receiver,
+        address market,
+        IStandardizedYield SY,
+        IPYieldToken YT,
+        uint256 netSyIn,
+        uint256 minLpOut,
+        uint256 minYtOut
+    ) internal returns (uint256 netLpOut, uint256 netYtOut) {
+        MarketState memory state = IPMarket(market).readState(address(this));
+
+        PYIndex pyIndex = YT.newIndex();
+
+        uint256 netSyToPt = (netSyIn * state.totalPt.Uint()) /
+            (state.totalPt.Uint() + pyIndex.syToAsset(state.totalSy.Uint()));
+
+        // transfer SY to mint PY
+        _transferOut(address(SY), address(YT), netSyToPt);
+
+        // the rest of SY goes to market
+        _transferOut(address(SY), market, netSyIn - netSyToPt);
+
+        // PT goes to market, YT goes to receiver
+        netYtOut = YT.mintPY(market, receiver);
+
+        (netLpOut, , ) = IPMarket(market).mint(receiver, netSyIn - netSyToPt, netYtOut);
+
+        if (netLpOut < minLpOut) revert Errors.RouterInsufficientLpOut(netLpOut, minLpOut);
+        if (netYtOut < minYtOut) revert Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
+    }
+
     /// @dev removes SY/PT liquidity, then converts PT to SY
     function _removeLiquiditySingleSy(
         address receiver,
@@ -497,7 +607,7 @@ contract ActionAddRemoveLiq is IPActionAddRemoveLiq, ActionBaseMintRedeem {
     ) internal returns (uint256 netSyOut) {
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
         (uint256 syFromBurn, ) = IPMarket(market).burn(receiver, address(YT), netLpToRemove);
-        netSyOut = syFromBurn + IPYieldToken(YT).redeemPY(receiver);
+        netSyOut = syFromBurn + YT.redeemPY(receiver);
     }
 
     /// @dev swaps PT to SY pre-expiry

package/contracts/router/ActionMintRedeem.sol

@@ -11,11 +11,6 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
     using Math for uint256;
     using Math for int256;
 
-    /// @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
-    {}
-
     /**
      * @notice swaps input token for SY-mintable tokens (if needed), then mints SY from such
      * @param input data for input token, see {`./kyberswap/KyberSwapHelper.sol`}
@@ -61,7 +56,7 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         address SY = IPYieldToken(YT).SY();
 
         uint256 netSyToMint = _mintSyFromToken(YT, SY, 0, input);
-        netPyOut = _mintPyFromSy(receiver, YT, netSyToMint, minPyOut, false);
+        netPyOut = _mintPyFromSy(receiver, SY, YT, netSyToMint, minPyOut, false);
 
         emit MintPyFromToken(msg.sender, input.tokenIn, YT, receiver, input.netTokenIn, netPyOut);
     }
@@ -96,7 +91,7 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         uint256 netSyIn,
         uint256 minPyOut
     ) external returns (uint256 netPyOut) {
-        netPyOut = _mintPyFromSy(receiver, YT, netSyIn, minPyOut, true);
+        netPyOut = _mintPyFromSy(receiver, IPYieldToken(YT).SY(), YT, netSyIn, minPyOut, true);
         emit MintPyFromSy(msg.sender, receiver, YT, netSyIn, netPyOut);
     }
 
@@ -121,204 +116,19 @@ contract ActionMintRedeem is IPActionMintRedeem, ActionBaseMintRedeem {
         address[] calldata sys,
         address[] calldata yts,
         address[] calldata markets
-    )
-        external
-        returns (
-            uint256[][] memory syRewards,
-            uint256[] memory ytInterests,
-            uint256[][] memory ytRewards,
-            uint256[][] memory marketRewards
-        )
-    {
-        syRewards = new uint256[][](sys.length);
-        for (uint256 i = 0; i < sys.length; ++i) {
-            syRewards[i] = IStandardizedYield(sys[i]).claimRewards(user);
-        }
-
-        ytInterests = new uint256[](yts.length);
-        ytRewards = new uint256[][](yts.length);
-        for (uint256 i = 0; i < yts.length; ++i) {
-            (ytInterests[i], ytRewards[i]) = IPYieldToken(yts[i]).redeemDueInterestAndRewards(
-                user,
-                true,
-                true
-            );
-        }
-
-        marketRewards = new uint256[][](markets.length);
-        for (uint256 i = 0; i < markets.length; ++i) {
-            marketRewards[i] = IPMarket(markets[i]).redeemRewards(user);
-        }
-        emit RedeemDueInterestAndRewards(
-            user,
-            sys,
-            yts,
-            markets,
-            syRewards,
-            ytInterests,
-            ytRewards,
-            marketRewards
-        );
-    }
-
-    struct RouterTokenAmounts {
-        address[] tokens;
-        uint256[] amounts;
-    }
-
-    /**
-     * @notice A function to:
-        - Redeem all of caller's due interest and rewards in SYs, YTs, and markets
-        - Redeem SYs themselves
-        - Finally swaps all resulting tokens to `dataSwap.outputToken`
-     * @return netTokenOut total token output amount, will not be lower than `dataSwap.minTokenOut`
-     * @return amountsSwapped the amounts swapped for each token defined in `dataSwap.tokens`
-     */
-    function redeemDueInterestAndRewardsThenSwapAll(
-        address[] calldata sys,
-        RouterYtRedeemStruct calldata dataYT,
-        address[] calldata markets,
-        RouterSwapAllStruct calldata dataSwap
-    ) external returns (uint256 netTokenOut, uint256[] memory amountsSwapped) {
-        if (dataSwap.tokens.length != dataSwap.kybercalls.length)
-            revert Errors.ArrayLengthMismatch();
-
-        if (dataYT.tokenRedeemSys.length != dataYT.syAddrs.length)
-            revert Errors.ArrayLengthMismatch();
-
-        RouterTokenAmounts memory tokensOut = _newRouterTokenAmounts(dataSwap.tokens);
-        RouterTokenAmounts memory sysOut = _newRouterTokenAmounts(dataYT.syAddrs);
-
-        // redeem SY
-        for (uint256 i = 0; i < sys.length; ++i) {
-            IStandardizedYield SY = IStandardizedYield(sys[i]);
-
-            address[] memory rewardTokens = SY.getRewardTokens();
-            uint256[] memory rewardAmounts = SY.claimRewards(msg.sender);
-            _addTokenAmounts(tokensOut, rewardTokens, rewardAmounts);
-        }
-
-        // redeem YT
-        for (uint256 i = 0; i < dataYT.yts.length; ++i) {
-            IPYieldToken YT = IPYieldToken(dataYT.yts[i]);
-
-            (uint256 interestAmount, uint256[] memory rewardAmounts) = YT
-                .redeemDueInterestAndRewards(msg.sender, true, true);
-
-            address syAddr = YT.SY();
-            address[] memory rewardTokens = YT.getRewardTokens();
-
-            _addTokenAmount(sysOut, syAddr, interestAmount);
-            _addTokenAmounts(tokensOut, rewardTokens, rewardAmounts);
-        }
-
-        // redeem market
-        for (uint256 i = 0; i < markets.length; ++i) {
-            IPMarket market = IPMarket(markets[i]);
-
-            address[] memory rewardTokens = market.getRewardTokens();
-            uint256[] memory rewardAmounts = market.redeemRewards(msg.sender);
-            _addTokenAmounts(tokensOut, rewardTokens, rewardAmounts);
-        }
-
-        // guaranteed no ETH, all rewards are ERC20
-        for (uint256 i = 0; i < tokensOut.tokens.length; ++i) {
-            _transferFrom(
-                IERC20(tokensOut.tokens[i]),
-                msg.sender,
-                address(this),
-                tokensOut.amounts[i]
-            );
-        }
-        _redeemAllSys(sysOut, dataYT.bulks, dataYT.tokenRedeemSys, tokensOut);
-
-        // now swap all to outputToken
-        netTokenOut = _swapAllToOutputToken(tokensOut, dataSwap);
-
-        if (netTokenOut < dataSwap.minTokenOut)
-            revert Errors.RouterInsufficientTokenOut(netTokenOut, dataSwap.minTokenOut);
-
-        amountsSwapped = tokensOut.amounts;
-
-        emit RedeemDueInterestAndRewardsThenSwapAll(
-            msg.sender,
-            sys,
-            dataYT.yts,
-            markets,
-            dataSwap.outputToken,
-            netTokenOut
-        );
-    }
-
-    function _newRouterTokenAmounts(address[] memory tokens)
-        internal
-        pure
-        returns (RouterTokenAmounts memory)
-    {
-        return RouterTokenAmounts(tokens, new uint256[](tokens.length));
-    }
-
-    /// @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(
-                address(this),
-                sys.tokens[i],
-                sys.amounts[i],
-                output,
-                true
-            );
-
-            _addTokenAmount(tokensOut, tokenRedeemSys[i], amountOut);
-        }
-    }
-
-    function _swapAllToOutputToken(
-        RouterTokenAmounts memory tokens,
-        RouterSwapAllStruct memory dataSwap
-    ) 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]
-            );
-        }
-        netTokenOut = _selfBalance(dataSwap.outputToken);
-        _transferOut(dataSwap.outputToken, msg.sender, netTokenOut);
-    }
+    ) external {
+        unchecked {
+            for (uint256 i = 0; i < sys.length; ++i) {
+                IStandardizedYield(sys[i]).claimRewards(user);
+            }
 
-    function _addTokenAmount(
-        RouterTokenAmounts memory data,
-        address token,
-        uint256 amount
-    ) internal pure {
-        for (uint256 j = 0; j < data.tokens.length; j++) {
-            if (data.tokens[j] == token) {
-                data.amounts[j] += amount;
-                return;
+            for (uint256 i = 0; i < yts.length; ++i) {
+                IPYieldToken(yts[i]).redeemDueInterestAndRewards(user, true, true);
             }
-        }
-        revert("token not found");
-    }
 
-    function _addTokenAmounts(
-        RouterTokenAmounts memory data,
-        address[] memory tokens,
-        uint256[] memory amounts
-    ) internal pure {
-        for (uint256 i = 0; i < tokens.length; i++) {
-            _addTokenAmount(data, tokens[i], amounts[i]);
+            for (uint256 i = 0; i < markets.length; ++i) {
+                IPMarket(markets[i]).redeemRewards(user);
+            }
         }
     }
 }

package/contracts/router/ActionMisc.sol

@@ -1,25 +1,51 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "../interfaces/IPMarket.sol";
 import "../interfaces/IPActionMisc.sol";
-import "../core/libraries/Errors.sol";
-
-contract ActionMisc is IPActionMisc {
-    using Math for uint256;
-
-    function consult(address market, uint32 secondsAgo)
-        external
-        view
-        returns (uint96 lnImpliedRateMean)
-    {
-        if (secondsAgo == 0) revert Errors.RouterTimeRangeZero();
-        uint32[] memory secondsAgos = new uint32[](2);
-        secondsAgos[0] = secondsAgo;
-        secondsAgos[1] = 0;
-        uint216[] memory lnImpliedRateCumulatives = IPMarket(market).observe(secondsAgos);
-        return
-            (uint256(lnImpliedRateCumulatives[1] - lnImpliedRateCumulatives[0]) / secondsAgo)
-                .Uint96();
+import "../core/libraries/TokenHelper.sol";
+
+contract ActionMisc is IPActionMisc, TokenHelper {
+    function approveInf(MultiApproval[] calldata arr) external {
+        for (uint256 i = 0; i < arr.length; ) {
+            MultiApproval calldata ele = arr[i];
+            for (uint256 j = 0; j < ele.tokens.length; ) {
+                _safeApproveInf(ele.tokens[j], ele.spender);
+                unchecked {
+                    j++;
+                }
+            }
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function batchExec(Call3[] calldata calls) external payable returns (Result[] memory res) {
+        uint256 length = calls.length;
+
+        res = new Result[](length);
+
+        Call3 calldata calli;
+
+        for (uint256 i = 0; i < length; ) {
+            calli = calls[i];
+
+            // delegatecall to itself, it turns allowing invoking functions from other actions
+            (bool success, bytes memory result) = address(this).delegatecall(calli.callData);
+
+            if (!success && !calli.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;
+            }
+        }
     }
 }

package/contracts/router/ActionSwapPT.sol

@@ -15,11 +15,6 @@ contract ActionSwapPT is IPActionSwapPT, ActionBaseMintRedeem {
     using Math for int256;
     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
-    {}
-
     /**
      * @notice swaps exact amount of PT for SY
      * @param exactPtIn will always consume this exact amount of PT for as much SY as possible

package/contracts/router/ActionSwapYT.sol

@@ -7,8 +7,10 @@ import "../interfaces/IPActionSwapYT.sol";
 import "../interfaces/IPMarket.sol";
 import "../core/libraries/Errors.sol";
 
+import "./base/ActionBaseCallback.sol";
+
 /// @dev All swap actions will revert if market is expired
-contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
+contract ActionSwapYT is ActionBaseCallback, IPActionSwapYT, ActionBaseMintRedeem {
     using Math for uint256;
     using Math for int256;
     using MarketMathCore for MarketState;
@@ -16,10 +18,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
     using MarketApproxPtOutLib for MarketState;
     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 _marketFactory) ActionBaseCallback(_marketFactory) {}
 
     /**
      * @notice swap exact SY to YT with the help of flashswaps & YT tokenization / redemption
@@ -38,7 +37,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         address market,
         uint256 exactSyIn,
         uint256 minYtOut,
-        ApproxParams memory guessYtOut
+        ApproxParams calldata guessYtOut
     ) external returns (uint256 netYtOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
 
@@ -105,7 +104,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         (, netSyFee) = IPMarket(market).swapExactPtForSy(
             address(YT),
             exactYtOut, // exactPtIn = exactYtOut
-            _encodeSwapSyForExactYt(msg.sender, receiver, maxSyIn)
+            _encodeSwapSyForExactYt(msg.sender, receiver, maxSyIn, SY, YT)
         );
 
         netSyIn = preSyBalance - SY.balanceOf(msg.sender);
@@ -129,7 +128,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         address market,
         uint256 exactSyOut,
         uint256 maxYtIn,
-        ApproxParams memory guessYtIn
+        ApproxParams calldata guessYtIn
     ) external returns (uint256 netYtIn, uint256 netSyFee) {
         MarketState memory state = IPMarket(market).readState(address(this));
         (, , IPYieldToken YT) = IPMarket(market).readTokens();
@@ -148,7 +147,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         (, netSyFee) = IPMarket(market).swapSyForExactPt(
             address(YT),
             netYtIn, // exactPtOut = netYtIn
-            _encodeSwapYtForSy(receiver, exactSyOut)
+            _encodeSwapYtForSy(receiver, exactSyOut, YT)
         );
 
         emit SwapYtAndSy(msg.sender, market, receiver, netYtIn.neg(), exactSyOut.Int());
@@ -163,7 +162,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         address receiver,
         address market,
         uint256 minYtOut,
-        ApproxParams memory guessYtOut,
+        ApproxParams calldata guessYtOut,
         TokenInput calldata input
     ) external payable returns (uint256 netYtOut, uint256 netSyFee) {
         (IStandardizedYield SY, , IPYieldToken YT) = IPMarket(market).readTokens();
@@ -227,13 +226,99 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         );
     }
 
+    /**
+     * @notice swap exact PT to YT with the help of flashswaps & YT tokenization / redemption
+     * @dev inner working of this function:
+     - `exactPtIn` PT is transferred to market contract
+     - `market.swapExactPtForSy` is called, which will transfer SY directly to YT contract & callback is invoked.
+        Note that we will owe PT, the amount before is not sufficient
+     - in callback, all SY in YT contract is used to mint PT + YT, with PT used to pay the rest of the loan, and YT
+        transferred to the receiver
+     * @param exactPtIn will always consume this amount of PT for as much YT as possible
+     * @param guessTotalPtToSwap approximation data for PT used for the PT-to-SY flashswap
+     * @dev this function works in conjunction with ActionCallback
+     */
+    function swapExactPtForYt(
+        address receiver,
+        address market,
+        uint256 exactPtIn,
+        uint256 minYtOut,
+        ApproxParams calldata guessTotalPtToSwap
+    ) external returns (uint256 netYtOut, uint256 netSyFee) {
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+        MarketState memory state = IPMarket(market).readState(address(this));
+
+        _transferFrom(IERC20(PT), msg.sender, market, exactPtIn);
+
+        uint256 totalPtToSwap;
+        (netYtOut, totalPtToSwap, netSyFee) = state.approxSwapExactPtForYt(
+            YT.newIndex(),
+            exactPtIn,
+            block.timestamp,
+            guessTotalPtToSwap
+        );
+
+        if (netYtOut < minYtOut) revert Errors.RouterInsufficientYtOut(netYtOut, minYtOut);
+
+        IPMarket(market).swapExactPtForSy(
+            address(YT),
+            totalPtToSwap,
+            _encodeSwapExactPtForYt(receiver, exactPtIn, minYtOut, YT)
+        );
+
+        emit SwapPtAndYt(msg.sender, market, receiver, exactPtIn.neg(), netYtOut.Int());
+    }
+
+    /**
+     * @notice swap exact YT to PT with the help of flashswaps & YT tokenization / redemption
+     * @dev inner working of this function:
+     - `exactYtIn` YT is transferred to yield contract
+     - `market.swapSyForExactPt` is called, which will transfer PT directly to this contract & callback is invoked.
+        Note that we now owe SY
+     - in callback, a portion of PT + YT is used to redeem SY, which is then used to payback the loan. The rest of
+       of the PT is transferred to `receiver`
+     * @param exactYtIn will always consume this amount of YT for as much PT as possible
+     * @param guessTotalPtFromSwap approximation data for PT output of the SY-to-PT flashswap
+     * @dev this function works in conjunction with ActionCallback
+     */
+    function swapExactYtForPt(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        uint256 minPtOut,
+        ApproxParams calldata guessTotalPtFromSwap
+    ) external returns (uint256 netPtOut, uint256 netSyFee) {
+        (, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market).readTokens();
+        MarketState memory state = IPMarket(market).readState(address(this));
+
+        _transferFrom(IERC20(YT), msg.sender, address(YT), exactYtIn);
+
+        uint256 totalPtFromSwap;
+        (netPtOut, totalPtFromSwap, netSyFee) = state.approxSwapExactYtForPt(
+            YT.newIndex(),
+            exactYtIn,
+            block.timestamp,
+            guessTotalPtFromSwap
+        );
+
+        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
+
+        IPMarket(market).swapSyForExactPt(
+            address(this),
+            totalPtFromSwap,
+            _encodeSwapExactYtForPt(receiver, exactYtIn, minPtOut, PT, YT)
+        );
+
+        emit SwapPtAndYt(msg.sender, market, receiver, netPtOut.Int(), exactYtIn.neg());
+    }
+
     function _swapExactSyForYt(
         address receiver,
         address market,
         IPYieldToken YT,
         uint256 exactSyIn,
         uint256 minYtOut,
-        ApproxParams memory guessYtOut
+        ApproxParams calldata guessYtOut
     ) internal returns (uint256 netYtOut, uint256 netSyFee) {
         MarketState memory state = IPMarket(market).readState(address(this));
 
@@ -250,7 +335,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         (, netSyFee) = IPMarket(market).swapExactPtForSy(
             address(YT),
             netYtOut, // exactPtIn = netYtOut
-            _encodeSwapExactSyForYt(receiver, minYtOut)
+            _encodeSwapExactSyForYt(receiver, minYtOut, YT)
         );
     }
 
@@ -267,7 +352,7 @@ contract ActionSwapYT is IPActionSwapYT, ActionBaseMintRedeem, CallbackHelper {
         (, netSyFee) = IPMarket(market).swapSyForExactPt(
             address(YT),
             exactYtIn, // exactPtOut = exactYtIn
-            _encodeSwapYtForSy(receiver, minSyOut)
+            _encodeSwapYtForSy(receiver, minSyOut, YT)
         );
 
         netSyOut = SY.balanceOf(receiver) - preSyBalance;