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

package/contracts/router/PendleRouter.sol

@@ -1,103 +1,242 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.17;
 
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/Proxy.sol";
 import "../interfaces/IPAllAction.sol";
-import "../interfaces/IPMarketSwapCallback.sol";
-import "../core/libraries/Errors.sol";
-
-/// @dev this contract will be deployed behind an ERC1967 proxy
-/// calls to the ERC1967 proxy will be resolved at this contract, and proxied again to the
-/// corresponding implementation contracts
+import "../interfaces/IDiamondLoupe.sol";
+import "../interfaces/IDiamondCut.sol";
 
 // solhint-disable no-empty-blocks
-contract PendleRouter is Proxy {
-    address public immutable ACTION_MINT_REDEEM;
-    address public immutable ACTION_ADD_REMOVE_LIQ;
-    address public immutable ACTION_SWAP_PT;
-    address public immutable ACTION_SWAP_YT;
-    address public immutable ACTION_SWAP_PTYT;
-    address public immutable ACTION_CALLBACK;
-    address public immutable ACTION_MISC;
+contract PendleRouter is Proxy, IDiamondLoupe {
+    address internal immutable ACTION_MINT_REDEEM;
+    address internal immutable ACTION_ADD_REMOVE_LIQ;
+    address internal immutable ACTION_SWAP_PT;
+    address internal immutable ACTION_SWAP_YT;
+    address internal immutable ACTION_MISC;
+
+    event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);
 
     constructor(
         address _ACTION_MINT_REDEEM,
         address _ACTION_ADD_REMOVE_LIQ,
         address _ACTION_SWAP_PT,
         address _ACTION_SWAP_YT,
-        address _ACTION_SWAP_PTYT,
-        address _ACTION_CALLBACK,
         address _ACTION_MISC
     ) {
         ACTION_MINT_REDEEM = _ACTION_MINT_REDEEM;
         ACTION_ADD_REMOVE_LIQ = _ACTION_ADD_REMOVE_LIQ;
         ACTION_SWAP_PT = _ACTION_SWAP_PT;
         ACTION_SWAP_YT = _ACTION_SWAP_YT;
-        ACTION_SWAP_PTYT = _ACTION_SWAP_PTYT;
-        ACTION_CALLBACK = _ACTION_CALLBACK;
         ACTION_MISC = _ACTION_MISC;
+        _emitEvents();
+    }
+
+    function _emitEvents() internal {
+        Facet[] memory facets_ = facets();
+
+        uint256 nFacets = facets_.length;
+
+        IDiamondCut.FacetCut[] memory cuts = new IDiamondCut.FacetCut[](nFacets);
+        for (uint256 i; i < nFacets; ) {
+            cuts[i].facetAddress = facets_[i].facetAddress;
+            cuts[i].action = IDiamondCut.FacetCutAction.Add;
+            cuts[i].functionSelectors = facets_[i].functionSelectors;
+            unchecked {
+                ++i;
+            }
+        }
+
+        emit DiamondCut(cuts, address(0), "");
     }
 
     receive() external payable virtual override {}
 
-    function getRouterImplementation(bytes4 sig) public view returns (address) {
-        if (
-            sig == IPActionMintRedeem.mintSyFromToken.selector ||
-            sig == IPActionMintRedeem.redeemSyToToken.selector ||
-            sig == IPActionMintRedeem.mintPyFromToken.selector ||
-            sig == IPActionMintRedeem.redeemPyToToken.selector ||
-            sig == IPActionMintRedeem.mintPyFromSy.selector ||
-            sig == IPActionMintRedeem.redeemPyToSy.selector ||
-            sig == IPActionMintRedeem.redeemDueInterestAndRewards.selector ||
-            sig == IPActionMintRedeem.redeemDueInterestAndRewardsThenSwapAll.selector
-        ) {
-            return ACTION_MINT_REDEEM;
-        } else if (
-            sig == IPActionAddRemoveLiq.addLiquidityDualSyAndPt.selector ||
-            sig == IPActionAddRemoveLiq.addLiquidityDualTokenAndPt.selector ||
-            sig == IPActionAddRemoveLiq.addLiquiditySinglePt.selector ||
-            sig == IPActionAddRemoveLiq.addLiquiditySingleSy.selector ||
-            sig == IPActionAddRemoveLiq.addLiquiditySingleToken.selector ||
-            sig == IPActionAddRemoveLiq.removeLiquidityDualSyAndPt.selector ||
-            sig == IPActionAddRemoveLiq.removeLiquidityDualTokenAndPt.selector ||
-            sig == IPActionAddRemoveLiq.removeLiquiditySinglePt.selector ||
-            sig == IPActionAddRemoveLiq.removeLiquiditySingleSy.selector ||
-            sig == IPActionAddRemoveLiq.removeLiquiditySingleToken.selector
-        ) {
-            return ACTION_ADD_REMOVE_LIQ;
-        } else if (
-            sig == IPActionSwapPT.swapExactPtForSy.selector ||
-            sig == IPActionSwapPT.swapPtForExactSy.selector ||
-            sig == IPActionSwapPT.swapSyForExactPt.selector ||
-            sig == IPActionSwapPT.swapExactSyForPt.selector ||
-            sig == IPActionSwapPT.swapExactTokenForPt.selector ||
-            sig == IPActionSwapPT.swapExactPtForToken.selector
-        ) {
-            return ACTION_SWAP_PT;
-        } else if (
-            sig == IPActionSwapYT.swapExactYtForSy.selector ||
-            sig == IPActionSwapYT.swapSyForExactYt.selector ||
-            sig == IPActionSwapYT.swapExactSyForYt.selector ||
-            sig == IPActionSwapYT.swapExactTokenForYt.selector ||
-            sig == IPActionSwapYT.swapExactYtForToken.selector ||
-            sig == IPActionSwapYT.swapYtForExactSy.selector
-        ) {
-            return ACTION_SWAP_YT;
-        } else if (
-            sig == IPActionSwapPTYT.swapExactPtForYt.selector ||
-            sig == IPActionSwapPTYT.swapExactYtForPt.selector
-        ) {
-            return ACTION_SWAP_PTYT;
-        } else if (sig == IPMarketSwapCallback.swapCallback.selector) {
-            return ACTION_CALLBACK;
-        } else if (sig == IPActionMisc.consult.selector) {
-            return ACTION_MISC;
+    /// @notice Gets all facet addresses and their four byte function selectors.
+    /// @return facets_ Facet
+    function facets() public view returns (Facet[] memory facets_) {
+        address[] memory facetAddresses_ = facetAddresses();
+        uint256 numFacets = facetAddresses_.length;
+
+        facets_ = new Facet[](numFacets);
+        for (uint256 i; i < numFacets; ) {
+            facets_[i].facetAddress = facetAddresses_[i];
+            facets_[i].functionSelectors = facetFunctionSelectors(facetAddresses_[i]);
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    function facetFunctionSelectors(address facet) public view returns (bytes4[] memory res) {
+        if (facet == ACTION_ADD_REMOVE_LIQ) {
+            res = new bytes4[](12);
+            res[0] = 0x97ee279e; // addLiquidityDualSyAndPt
+            res[1] = 0xcb591eb2; // addLiquidityDualTokenAndPt
+            res[2] = 0x3af1f329; // addLiquiditySinglePt
+            res[3] = 0x409c7a89; // addLiquiditySingleSy
+            res[4] = 0x015491d1; // addLiquiditySingleToken
+            res[5] = 0xb7d75b8b; // removeLiquidityDualSyAndPt
+            res[6] = 0xe6eaba01; // removeLiquidityDualTokenAndPt
+            res[7] = 0x694ab559; // removeLiquiditySinglePt
+            res[8] = 0x178d29d3; // removeLiquiditySingleSy
+            res[9] = 0x690807ad; // removeLiquiditySingleToken
+            res[10] = 0xdfbc814e; // addLiquiditySingleTokenKeepYt
+            res[11] = 0x844384aa; // addLiquiditySingleSyKeepYt
+            return res;
+        }
+        if (facet == ACTION_MINT_REDEEM) {
+            res = new bytes4[](7);
+            res[0] = 0x1a8631b2; // mintPyFromSy
+            res[1] = 0x46eb2db6; // mintPyFromToken
+            res[2] = 0x443e6512; // mintSyFromToken
+            res[3] = 0xf7e375e8; // redeemDueInterestAndRewards
+            res[4] = 0x339748cb; // redeemPyToSy
+            res[5] = 0x527df199; // redeemPyToToken
+            res[6] = 0x85b29936; // redeemSyToToken
+            return res;
+        }
+        if (facet == ACTION_SWAP_PT) {
+            res = new bytes4[](6);
+            res[0] = 0x2032aecd; // swapExactPtForSy
+            res[1] = 0xb85f50ba; // swapExactPtForToken
+            res[2] = 0x83c71b69; // swapExactSyForPt
+            res[3] = 0xa5f9931b; // swapExactTokenForPt
+            res[4] = 0xdd371acd; // swapPtForExactSy
+            res[5] = 0x6b8bdf32; // swapSyForExactPt
+            return res;
+        }
+        if (facet == ACTION_SWAP_YT) {
+            res = new bytes4[](9);
+            res[0] = 0xfa483e72; // swapCallback
+            res[1] = 0xc861a898; // swapExactPtForYt
+            res[2] = 0x448b9b95; // swapExactYtForPt
+            res[3] = 0xfdd71f43; // swapExactSyForYt
+            res[4] = 0xc4a9c7de; // swapExactTokenForYt
+            res[5] = 0x357d6540; // swapExactYtForSy
+            res[6] = 0xd6308fa4; // swapExactYtForToken
+            res[7] = 0xbf1bd434; // swapSyForExactYt
+            res[8] = 0xe15cc098; // swapYtForExactSy
+            return res;
+        }
+        if (facet == ACTION_MISC) {
+            res = new bytes4[](2);
+            res[0] = 0xacdb32df; // approveInf
+            res[1] = 0xd617b03b; // batchExec
+            return res;
+        }
+        if (facet == address(this)) {
+            res = new bytes4[](4);
+            res[0] = 0xcdffacc6; // facetAddress
+            res[1] = 0x52ef6b2c; // facetAddresses
+            res[2] = 0xadfca15e; // facetFunctionSelectors
+            res[3] = 0x7a0ed627; // facets
+            return res;
+        }
+        revert Errors.RouterInvalidFacet(facet);
+    }
+
+    function facetAddress(bytes4 sig) public view returns (address) {
+        if (sig < 0x97ee279e) {
+            if (sig < 0x46eb2db6) {
+                if (sig < 0x357d6540) {
+                    if (sig < 0x1a8631b2) {
+                        if (sig == 0x015491d1) return ACTION_ADD_REMOVE_LIQ; // addLiquiditySingleToken 5
+                        if (sig == 0x178d29d3) return ACTION_ADD_REMOVE_LIQ; // removeLiquiditySingleSy 6
+                    } else {
+                        if (sig == 0x1a8631b2) return ACTION_MINT_REDEEM; // mintPyFromSy 5
+                        if (sig == 0x2032aecd) return ACTION_SWAP_PT; // swapExactPtForSy 6
+                        if (sig == 0x339748cb) return ACTION_MINT_REDEEM; // redeemPyToSy 7
+                    }
+                } else {
+                    if (sig < 0x409c7a89) {
+                        if (sig == 0x357d6540) return ACTION_SWAP_YT; // swapExactYtForSy 5
+                        if (sig == 0x3af1f329) return ACTION_ADD_REMOVE_LIQ; // addLiquiditySinglePt 6
+                    } else {
+                        if (sig == 0x409c7a89) return ACTION_ADD_REMOVE_LIQ; // addLiquiditySingleSy 5
+                        if (sig == 0x443e6512) return ACTION_MINT_REDEEM; // mintSyFromToken 6
+                        if (sig == 0x448b9b95) return ACTION_SWAP_YT; // swapExactYtForPt 7
+                    }
+                }
+            } else {
+                if (sig < 0x6b8bdf32) {
+                    if (sig < 0x52ef6b2c) {
+                        if (sig == 0x46eb2db6) return ACTION_MINT_REDEEM; // mintPyFromToken 5
+                        if (sig == 0x527df199) return ACTION_MINT_REDEEM; // redeemPyToToken 6
+                    } else {
+                        if (sig == 0x690807ad) return ACTION_ADD_REMOVE_LIQ; // removeLiquiditySingleToken 5
+                        if (sig == 0x694ab559) return ACTION_ADD_REMOVE_LIQ; // removeLiquiditySinglePt 6
+                        if (sig == 0x52ef6b2c) return address(this); // facetAddresses 7
+                    }
+                } else {
+                    if (sig < 0x83c71b69) {
+                        if (sig == 0x6b8bdf32) return ACTION_SWAP_PT; // swapSyForExactPt 5
+                        if (sig == 0x7a0ed627) return address(this); // facets 6
+                    } else {
+                        if (sig == 0x85b29936) return ACTION_MINT_REDEEM; // redeemSyToToken 5
+                        if (sig == 0x844384aa) return ACTION_ADD_REMOVE_LIQ; // addLiquiditySingleSyKeepYt 6
+                        if (sig == 0x83c71b69) return ACTION_SWAP_PT; // swapExactSyForPt 7
+                    }
+                }
+            }
+        } else {
+            if (sig < 0xcdffacc6) {
+                if (sig < 0xb85f50ba) {
+                    if (sig < 0xacdb32df) {
+                        if (sig == 0xa5f9931b) return ACTION_SWAP_PT; // swapExactTokenForPt 5
+                        if (sig == 0x97ee279e) return ACTION_ADD_REMOVE_LIQ; // addLiquidityDualSyAndPt 6
+                    } else {
+                        if (sig == 0xb7d75b8b) return ACTION_ADD_REMOVE_LIQ; // removeLiquidityDualSyAndPt 5
+                        if (sig == 0xacdb32df) return ACTION_MISC; // approveInf 6
+                        if (sig == 0xadfca15e) return address(this); // facetFunctionSelectors 7
+                    }
+                } else {
+                    if (sig < 0xc4a9c7de) {
+                        if (sig == 0xb85f50ba) return ACTION_SWAP_PT; // swapExactPtForToken 5
+                        if (sig == 0xbf1bd434) return ACTION_SWAP_YT; // swapSyForExactYt 6
+                    } else {
+                        if (sig == 0xc4a9c7de) return ACTION_SWAP_YT; // swapExactTokenForYt 5
+                        if (sig == 0xcb591eb2) return ACTION_ADD_REMOVE_LIQ; // addLiquidityDualTokenAndPt 6
+                        if (sig == 0xc861a898) return ACTION_SWAP_YT; // swapExactPtForYt 7
+                    }
+                }
+            } else {
+                if (sig < 0xe15cc098) {
+                    if (sig < 0xd6308fa4) {
+                        if (sig == 0xd617b03b) return ACTION_MISC; // batchExec 5
+                        if (sig == 0xcdffacc6) return address(this); // facetAddress 6
+                    } else {
+                        if (sig == 0xd6308fa4) return ACTION_SWAP_YT; // swapExactYtForToken 5
+                        if (sig == 0xdfbc814e) return ACTION_ADD_REMOVE_LIQ; // addLiquiditySingleTokenKeepYt 6
+                        if (sig == 0xdd371acd) return ACTION_SWAP_PT; // swapPtForExactSy 7
+                    }
+                } else {
+                    if (sig < 0xf7e375e8) {
+                        if (sig == 0xe6eaba01) return ACTION_ADD_REMOVE_LIQ; // removeLiquidityDualTokenAndPt 5
+                        if (sig == 0xe15cc098) return ACTION_SWAP_YT; // swapYtForExactSy 6
+                    } else {
+                        if (sig == 0xfa483e72) return ACTION_SWAP_YT; // swapCallback 5
+                        if (sig == 0xf7e375e8) return ACTION_MINT_REDEEM; // redeemDueInterestAndRewards 6
+                        if (sig == 0xfdd71f43) return ACTION_SWAP_YT; // swapExactSyForYt 7
+                    }
+                }
+            }
         }
         revert Errors.RouterInvalidAction(sig);
+        // NUM_FUNC: 40 AVG:5.80 STD:0.75 WORST_CASE:7 STOP_BRANCH:3
+    }
+
+    function facetAddresses() public view returns (address[] memory) {
+        address[] memory res = new address[](6);
+        res[0] = ACTION_ADD_REMOVE_LIQ;
+        res[1] = ACTION_MINT_REDEEM;
+        res[2] = ACTION_SWAP_PT;
+        res[3] = ACTION_SWAP_YT;
+        res[4] = ACTION_MISC;
+        res[5] = address(this);
+        return res;
     }
 
     function _implementation() internal view override returns (address) {
-        return getRouterImplementation(msg.sig);
+        return facetAddress(msg.sig);
     }
 }

package/contracts/router/PendleRouterHelper.sol

@@ -0,0 +1,315 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../interfaces/IPAllAction.sol";
+import "../interfaces/IPMarket.sol";
+import "../interfaces/IPLiquidityMigrator.sol";
+import "./base/ActionBaseMintRedeem.sol";
+import "./base/MarketApproxLib.sol";
+
+contract PendleRouterHelper is TokenHelper, IPLiquidityMigrator {
+    IPAllAction private immutable ROUTER;
+    address private immutable WETH;
+
+    constructor(address _ROUTER, address _WETH) {
+        ROUTER = IPAllAction(_ROUTER);
+        WETH = _WETH;
+    }
+
+    receive() external payable {}
+
+    /// @dev input should be all based on input token being WETH
+    function addLiquiditySingleTokenKeepYtWithEth(
+        address receiver,
+        address market,
+        uint256 minLpOut,
+        uint256 minYtOut,
+        TokenInput calldata input
+    ) external payable returns (uint256 netLpOut, uint256 netYtOut) {
+        _wrap_unwrap_ETH(NATIVE, WETH, msg.value);
+
+        _safeApproveInf(WETH, address(ROUTER));
+
+        (netLpOut, netYtOut) = ROUTER.addLiquiditySingleTokenKeepYt(
+            receiver,
+            market,
+            minLpOut,
+            minYtOut,
+            input
+        );
+    }
+
+    // ============ Same SY ============
+
+    function migrateDifferentSyNormal(
+        RemoveLiquiditySingleTokenStruct calldata fromMarket,
+        AddLiquiditySingleTokenStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netTokenZapIn,
+            uint256 netSyFeeOfRemove,
+            uint256 netSyFeeOfAdd
+        )
+    {
+        (netTokenZapIn, netSyFeeOfRemove) = _removeLiquiditySingleToken(fromMarket);
+        (netLpOut, netSyFeeOfAdd) = _addLiquiditySingleToken(
+            toMarket,
+            fromMarket.output.tokenOut,
+            netTokenZapIn
+        );
+
+        emit MigrateDifferentSyNormal(
+            fromMarket.market,
+            toMarket.market,
+            msg.sender,
+            fromMarket.netLpToRemove,
+            netLpOut
+        );
+    }
+
+    function migrateDifferentSyKeepYt(
+        RemoveLiquiditySingleTokenStruct calldata fromMarket,
+        AddLiquiditySingleTokenKeepYtStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netYtOut,
+            uint256 netTokenZapIn,
+            uint256 netSyFeeOfRemove
+        )
+    {
+        (netTokenZapIn, netSyFeeOfRemove) = _removeLiquiditySingleToken(fromMarket);
+        (netLpOut, netYtOut) = _addLiquiditySingleTokenKeepYt(
+            toMarket,
+            fromMarket.output.tokenOut,
+            netTokenZapIn
+        );
+
+        emit MigrateDifferentSyKeepYt(
+            fromMarket.market,
+            toMarket.market,
+            msg.sender,
+            fromMarket.netLpToRemove,
+            netLpOut,
+            netYtOut
+        );
+    }
+
+    function migrateSameSyNormal(
+        RemoveLiquiditySingleSyStruct calldata fromMarket,
+        AddLiquiditySingleSyStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netSyMigrated,
+            uint256 netSyFeeOfRemove,
+            uint256 netSyFeeOfAdd
+        )
+    {
+        (netSyMigrated, netSyFeeOfRemove) = _removeLiquiditySingleSy(fromMarket);
+        (netLpOut, netSyFeeOfAdd) = _addLiquiditySingleSy(toMarket, netSyMigrated);
+        emit MigrateSameSyNormal(
+            fromMarket.market,
+            toMarket.market,
+            msg.sender,
+            fromMarket.netLpToRemove,
+            netLpOut
+        );
+    }
+
+    function migrateSameSyKeepYt(
+        RemoveLiquiditySingleSyStruct calldata fromMarket,
+        AddLiquiditySingleSyKeepYtStruct calldata toMarket
+    )
+        external
+        returns (
+            uint256 netLpOut,
+            uint256 netYtOut,
+            uint256 netSyMigrated,
+            uint256 netSyFeeOfRemove
+        )
+    {
+        (netSyMigrated, netSyFeeOfRemove) = _removeLiquiditySingleSy(fromMarket);
+        (netLpOut, netYtOut) = _addLiquiditySingleSyKeepYt(toMarket, netSyMigrated);
+        emit MigrateSameSyKeepYt(
+            fromMarket.market,
+            toMarket.market,
+            msg.sender,
+            fromMarket.netLpToRemove,
+            netLpOut,
+            netYtOut
+        );
+    }
+
+    function _removeLiquiditySingleToken(RemoveLiquiditySingleTokenStruct calldata fromMarket)
+        internal
+        returns (uint256 netTokenOut, uint256 netSyFee)
+    {
+        _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
+        );
+
+        if (fromMarket.doRedeemRewards) {
+            IPMarket(fromMarket.market).redeemRewards(msg.sender);
+        }
+    }
+
+    function _removeLiquiditySingleSy(RemoveLiquiditySingleSyStruct calldata fromMarket)
+        internal
+        returns (uint256 netSyOut, uint256 netSyFee)
+    {
+        _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
+        );
+
+        if (fromMarket.doRedeemRewards) {
+            IPMarket(fromMarket.market).redeemRewards(msg.sender);
+        }
+    }
+
+    function _addLiquiditySingleToken(
+        AddLiquiditySingleTokenStruct calldata toMarket,
+        address tokenToZapIn,
+        uint256 actualNetTokenIn
+    ) internal returns (uint256 netLpOut, uint256 netSyFee) {
+        uint256 netNativeToAttach;
+        if (tokenToZapIn == NATIVE) {
+            netNativeToAttach = actualNetTokenIn;
+        }
+
+        _safeApproveInf(tokenToZapIn, address(ROUTER));
+
+        (netLpOut, netSyFee) = ROUTER.addLiquiditySingleToken{ value: netNativeToAttach }(
+            msg.sender,
+            toMarket.market,
+            toMarket.minLpOut,
+            _scaleApproxParams(
+                toMarket.guessPtReceivedFromSy,
+                toMarket.guessNetTokenIn,
+                actualNetTokenIn
+            ),
+            _newTokenInputStruct(tokenToZapIn, actualNetTokenIn, toMarket.bulk)
+        );
+    }
+
+    function _addLiquiditySingleSy(
+        AddLiquiditySingleSyStruct calldata toMarket,
+        uint256 actualNetSyIn
+    ) internal returns (uint256 netLpOut, uint256 netSyFee) {
+        (IStandardizedYield SY, , ) = IPMarket(toMarket.market).readTokens();
+
+        _safeApproveInf(address(SY), address(ROUTER));
+
+        (netLpOut, netSyFee) = ROUTER.addLiquiditySingleSy(
+            msg.sender,
+            toMarket.market,
+            actualNetSyIn,
+            toMarket.minLpOut,
+            _scaleApproxParams(
+                toMarket.guessPtReceivedFromSy,
+                toMarket.guessNetSyIn,
+                actualNetSyIn
+            )
+        );
+    }
+
+    function _addLiquiditySingleTokenKeepYt(
+        AddLiquiditySingleTokenKeepYtStruct calldata toMarket,
+        address tokenToZapIn,
+        uint256 actualNetTokenIn
+    ) internal returns (uint256 netLpOut, uint256 netSyFee) {
+        if (tokenToZapIn == NATIVE) {
+            tokenToZapIn = WETH;
+            _wrap_unwrap_ETH(NATIVE, WETH, actualNetTokenIn);
+        }
+
+        _safeApproveInf(tokenToZapIn, address(ROUTER));
+
+        (netLpOut, netSyFee) = ROUTER.addLiquiditySingleTokenKeepYt(
+            msg.sender,
+            toMarket.market,
+            toMarket.minLpOut,
+            toMarket.minYtOut,
+            _newTokenInputStruct(tokenToZapIn, actualNetTokenIn, toMarket.bulk)
+        );
+    }
+
+    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
+        );
+    }
+
+    // ============ struct helpers ============
+
+    function _newTokenInputStruct(
+        address tokenIn,
+        uint256 netTokenIn,
+        address bulk
+    ) 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) {
+        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
+            });
+    }
+}