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

package/contracts/offchain-helpers/Multicall2.sol

@@ -0,0 +1,103 @@
+pragma solidity >=0.5.0;
+pragma experimental ABIEncoderV2;
+
+/// @title Multicall2 - Aggregate results from multiple read-only function calls
+/// @author Michael Elliot <mike@makerdao.com>
+/// @author Joshua Levine <joshua@makerdao.com>
+/// @author Nick Johnson <arachnid@notdot.net>
+
+contract Multicall2 {
+    struct Call {
+        address target;
+        bytes callData;
+    }
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    function aggregate(Call[] memory calls)
+        public
+        returns (uint256 blockNumber, bytes[] memory returnData)
+    {
+        blockNumber = block.number;
+        returnData = new bytes[](calls.length);
+        for (uint256 i = 0; i < calls.length; i++) {
+            (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);
+            require(success, "Multicall aggregate: call failed");
+            returnData[i] = ret;
+        }
+    }
+
+    function blockAndAggregate(Call[] memory calls)
+        public
+        returns (
+            uint256 blockNumber,
+            bytes32 blockHash,
+            Result[] memory returnData
+        )
+    {
+        (blockNumber, blockHash, returnData) = tryBlockAndAggregate(true, calls);
+    }
+
+    function getBlockHash(uint256 blockNumber) public view returns (bytes32 blockHash) {
+        blockHash = blockhash(blockNumber);
+    }
+
+    function getBlockNumber() public view returns (uint256 blockNumber) {
+        blockNumber = block.number;
+    }
+
+    function getCurrentBlockCoinbase() public view returns (address coinbase) {
+        coinbase = block.coinbase;
+    }
+
+    function getCurrentBlockDifficulty() public view returns (uint256 difficulty) {
+        difficulty = block.difficulty;
+    }
+
+    function getCurrentBlockGasLimit() public view returns (uint256 gaslimit) {
+        gaslimit = block.gaslimit;
+    }
+
+    function getCurrentBlockTimestamp() public view returns (uint256 timestamp) {
+        timestamp = block.timestamp;
+    }
+
+    function getEthBalance(address addr) public view returns (uint256 balance) {
+        balance = addr.balance;
+    }
+
+    function getLastBlockHash() public view returns (bytes32 blockHash) {
+        blockHash = blockhash(block.number - 1);
+    }
+
+    function tryAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        returns (Result[] memory returnData)
+    {
+        returnData = new Result[](calls.length);
+        for (uint256 i = 0; i < calls.length; i++) {
+            (bool success, bytes memory ret) = calls[i].target.call(calls[i].callData);
+
+            if (requireSuccess) {
+                require(success, "Multicall2 aggregate: call failed");
+            }
+
+            returnData[i] = Result(success, ret);
+        }
+    }
+
+    function tryBlockAndAggregate(bool requireSuccess, Call[] memory calls)
+        public
+        returns (
+            uint256 blockNumber,
+            bytes32 blockHash,
+            Result[] memory returnData
+        )
+    {
+        blockNumber = block.number;
+        blockHash = blockhash(block.number);
+        returnData = tryAggregate(requireSuccess, calls);
+    }
+}

package/contracts/offchain-helpers/PendleMulticall.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+/// @title PendleMulticall - A more gas-efficient version of Multicall3 (~700 gas saved for each call)
+/// @author UncleGrandpa925 <longvh@pendle.finance>
+contract PendleMulticall {
+    error MulticallFailed(uint256 index);
+
+    struct Call {
+        address target;
+        bytes callData;
+    }
+
+    function aggregate(Call[] calldata calls) external payable {
+        uint256 length = calls.length;
+        Call calldata call;
+        for (uint256 i = 0; i < length; ) {
+            call = calls[i];
+            (bool success, ) = call.target.call(call.callData);
+            if (!success) revert MulticallFailed(i);
+            unchecked {
+                ++i;
+            }
+        }
+    }
+}

package/contracts/offchain-helpers/RouterStatic.sol

@@ -14,9 +14,10 @@ import "../LiquidityMining/libraries/VeBalanceLib.sol";
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/Proxy.sol";
 
 /// EXCLUDED FROM ALL AUDITS, TO BE CALLED ONLY BY PENDLE's SDK
-contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeable {
+contract RouterStatic is Initializable, Proxy, BoringOwnableUpgradeable, UUPSUpgradeable {
     using Math for uint256;
     using VeBalanceLib for VeBalance;
     using VeBalanceLib for LockedPosition;
@@ -62,32 +63,29 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
     IPMarketFactory internal immutable marketFactory;
     IPVotingEscrowMainchain internal immutable vePENDLE;
     IPBulkSellerFactory internal immutable bulkFactory;
+    address internal immutable marketMathStaticLib;
 
     constructor(
         IPYieldContractFactory _yieldContractFactory,
         IPMarketFactory _marketFactory,
         IPVotingEscrowMainchain _vePENDLE,
-        IPBulkSellerFactory _bulkFactory
+        IPBulkSellerFactory _bulkFactory,
+        address _marketMathStaticLib
     ) initializer {
         yieldContractFactory = _yieldContractFactory;
         marketFactory = _marketFactory;
         vePENDLE = _vePENDLE;
         bulkFactory = _bulkFactory;
+        marketMathStaticLib = _marketMathStaticLib;
     }
 
-    function initialize() external initializer {
-        __BoringOwnable_init();
+    // all Market-related functions will go to MarketMathStaticLib
+    function _implementation() internal view override returns (address) {
+        return marketMathStaticLib;
     }
 
-    function getDefaultApproxParams() public pure returns (ApproxParams memory) {
-        return
-            ApproxParams({
-                guessMin: 0,
-                guessMax: type(uint256).max,
-                guessOffchain: 0,
-                maxIteration: 256,
-                eps: 1e14
-            });
+    function initialize() external initializer {
+        __BoringOwnable_init();
     }
 
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
@@ -158,7 +156,7 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         sy = address(SY);
         state = _market.readState(address(this));
         impliedYield = getPtImpliedYield(market);
-        exchangeRate = MarketMathStatic.getExchangeRate(market);
+        exchangeRate = MarketMathStatic.getTradeExchangeRateExcludeFee(market);
     }
 
     // ============= USER INFO =============
@@ -325,11 +323,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 netLpOut,
             uint256 netPtToSwap,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.addLiquiditySinglePtStatic(market, netPtIn, getDefaultApproxParams());
+        return MarketMathStatic.addLiquiditySinglePtStatic(market, netPtIn);
     }
 
     function addLiquiditySingleSyStatic(address market, uint256 netSyIn)
@@ -338,11 +336,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 netLpOut,
             uint256 netPtFromSwap,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.addLiquiditySingleSyStatic(market, netSyIn, getDefaultApproxParams());
+        return MarketMathStatic.addLiquiditySingleSyStatic(market, netSyIn);
     }
 
     function addLiquiditySingleBaseTokenStatic(
@@ -356,7 +354,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 netLpOut,
             uint256 netPtFromSwap,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         uint256 netSyIn = previewDepositStatic(
@@ -366,8 +365,29 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             bulk
         );
 
-        return
-            MarketMathStatic.addLiquiditySingleSyStatic(market, netSyIn, getDefaultApproxParams());
+        return MarketMathStatic.addLiquiditySingleSyStatic(market, netSyIn);
+    }
+
+    function addLiquiditySingleSyKeepYtStatic(address market, uint256 netSyIn)
+        external
+        returns (uint256 netLpOut, uint256 netYtOut)
+    {
+        return MarketMathStatic.addLiquiditySingleSyKeepYtStatic(market, netSyIn);
+    }
+
+    function addLiquiditySingleTokenKeepYtStatic(
+        address market,
+        address baseToken,
+        uint256 netBaseTokenIn,
+        address bulk
+    ) external returns (uint256 netLpOut, uint256 netYtOut) {
+        uint256 netSyIn = previewDepositStatic(
+            getSyMarket(market),
+            baseToken,
+            netBaseTokenIn,
+            bulk
+        );
+        return MarketMathStatic.addLiquiditySingleSyKeepYtStatic(market, netSyIn);
     }
 
     function removeLiquidityDualSyAndPtStatic(address market, uint256 netLpToRemove)
@@ -400,15 +420,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 netPtOut,
             uint256 netPtFromSwap,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.removeLiquiditySinglePtStatic(
-                market,
-                netLpToRemove,
-                getDefaultApproxParams()
-            );
+        return MarketMathStatic.removeLiquiditySinglePtStatic(market, netLpToRemove);
     }
 
     function removeLiquiditySingleSyStatic(address market, uint256 netLpToRemove)
@@ -416,7 +432,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netSyOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         return MarketMathStatic.removeLiquiditySingleSyStatic(market, netLpToRemove);
@@ -432,15 +449,14 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netBaseTokenOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         uint256 netSyOut;
 
-        (netSyOut, netSyFee, priceImpact) = MarketMathStatic.removeLiquiditySingleSyStatic(
-            market,
-            netLpToRemove
-        );
+        (netSyOut, netSyFee, priceImpact, exchangeRateAfter) = MarketMathStatic
+            .removeLiquiditySingleSyStatic(market, netLpToRemove);
 
         netBaseTokenOut = previewRedeemStatic(getSyMarket(market), baseToken, netSyOut, bulk);
     }
@@ -450,7 +466,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netSyOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         return MarketMathStatic.swapExactPtForSyStatic(market, exactPtIn);
@@ -461,7 +478,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netSyIn,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         return MarketMathStatic.swapSyForExactPtStatic(market, exactPtOut);
@@ -472,11 +490,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netPtOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.swapExactSyForPtStatic(market, exactSyIn, getDefaultApproxParams());
+        return MarketMathStatic.swapExactSyForPtStatic(market, exactSyIn);
     }
 
     function swapPtForExactSyStatic(address market, uint256 exactSyOut)
@@ -484,11 +502,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netPtIn,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.swapPtForExactSyStatic(market, exactSyOut, getDefaultApproxParams());
+        return MarketMathStatic.swapPtForExactSyStatic(market, exactSyOut);
     }
 
     function swapExactBaseTokenForPtStatic(
@@ -501,7 +519,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netPtOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         uint256 netSyIn = previewDepositStatic(
@@ -510,7 +529,7 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             amountBaseToken,
             bulk
         );
-        return MarketMathStatic.swapExactSyForPtStatic(market, netSyIn, getDefaultApproxParams());
+        return MarketMathStatic.swapExactSyForPtStatic(market, netSyIn);
     }
 
     function swapExactPtForBaseTokenStatic(
@@ -523,14 +542,13 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netBaseTokenOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         uint256 netSyOut;
-        (netSyOut, netSyFee, priceImpact) = MarketMathStatic.swapExactPtForSyStatic(
-            market,
-            exactPtIn
-        );
+        (netSyOut, netSyFee, priceImpact, exchangeRateAfter) = MarketMathStatic
+            .swapExactPtForSyStatic(market, exactPtIn);
 
         netBaseTokenOut = previewRedeemStatic(getSyMarket(market), baseToken, netSyOut, bulk);
     }
@@ -540,7 +558,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netSyIn,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         return MarketMathStatic.swapSyForExactYtStatic(market, exactYtOut);
@@ -551,11 +570,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netYtOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.swapExactSyForYtStatic(market, exactSyIn, getDefaultApproxParams());
+        return MarketMathStatic.swapExactSyForYtStatic(market, exactSyIn);
     }
 
     function swapExactYtForSyStatic(address market, uint256 exactYtIn)
@@ -563,7 +582,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netSyOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         return MarketMathStatic.swapExactYtForSyStatic(market, exactYtIn);
@@ -574,11 +594,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netYtIn,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return
-            MarketMathStatic.swapYtForExactSyStatic(market, exactSyOut, getDefaultApproxParams());
+        return MarketMathStatic.swapYtForExactSyStatic(market, exactSyOut);
     }
 
     function swapExactYtForBaseTokenStatic(
@@ -591,14 +611,13 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netBaseTokenOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         uint256 netSyOut;
-        (netSyOut, netSyFee, priceImpact) = MarketMathStatic.swapExactYtForSyStatic(
-            market,
-            exactYtIn
-        );
+        (netSyOut, netSyFee, priceImpact, exchangeRateAfter) = MarketMathStatic
+            .swapExactYtForSyStatic(market, exactYtIn);
 
         netBaseTokenOut = previewRedeemStatic(getSyMarket(market), baseToken, netSyOut, bulk);
     }
@@ -613,7 +632,8 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         returns (
             uint256 netYtOut,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
         uint256 netSyIn = previewDepositStatic(
@@ -623,7 +643,7 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             bulk
         );
 
-        return MarketMathStatic.swapExactSyForYtStatic(market, netSyIn, getDefaultApproxParams());
+        return MarketMathStatic.swapExactSyForYtStatic(market, netSyIn);
     }
 
     function swapExactPtForYtStatic(address market, uint256 exactPtIn)
@@ -632,10 +652,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 netYtOut,
             uint256 totalPtToSwap,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return MarketMathStatic.swapExactPtForYt(market, exactPtIn, getDefaultApproxParams());
+        return MarketMathStatic.swapExactPtForYt(market, exactPtIn);
     }
 
     function swapExactYtForPtStatic(address market, uint256 exactYtIn)
@@ -644,10 +665,11 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
             uint256 netPtOut,
             uint256 totalPtSwapped,
             uint256 netSyFee,
-            uint256 priceImpact
+            uint256 priceImpact,
+            uint256 exchangeRateAfter
         )
     {
-        return MarketMathStatic.swapExactYtForPt(market, exactYtIn, getDefaultApproxParams());
+        return MarketMathStatic.swapExactYtForPt(market, exactYtIn);
     }
 
     // ============= vePENDLE =============
@@ -778,7 +800,7 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         public
         returns (uint256 priceImpact)
     {
-        return MarketMathStatic.calcPriceImpact(market, netPtOut);
+        return MarketMathStatic.calcPriceImpactPt(market, netPtOut);
     }
 
     // either but not both pyToken or market must be != 0
@@ -803,7 +825,7 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
         address bulk,
         uint256 netSyOut
     ) public view returns (uint256 netTokenIn) {
-        uint256 pivotAmount = netSyOut;
+        uint256 pivotAmount = 10**IERC20Metadata(tokenIn).decimals();
 
         uint256 low = pivotAmount;
         {

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