@pendle/core-v2 3.0.0 → 4.0.1

package/contracts/router/PendleRouter.sol

@@ -1,242 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "@openzeppelin/contracts/proxy/Proxy.sol";
-import "../interfaces/IPAllAction.sol";
-import "../interfaces/IDiamondLoupe.sol";
-import "../interfaces/IDiamondCut.sol";
-
-// solhint-disable no-empty-blocks
-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_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_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 {}
-
-    /// @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 facetAddress(msg.sig);
-    }
-}

package/contracts/router/PendleRouterHelper2.sol

@@ -1,41 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../interfaces/IPAllAction.sol";
-import "../interfaces/IPMarket.sol";
-import "../interfaces/IPRouterHelper.sol";
-import "./base/ActionBaseMintRedeem.sol";
-import "./base/MarketApproxLib.sol";
-import "../interfaces/IAddressProvider.sol";
-
-contract PendleRouterHelper2 is TokenHelper {
-    IPAllAction public immutable ROUTER;
-    address public immutable WETH;
-
-    constructor(address _ROUTER, address _WETH) {
-        ROUTER = IPAllAction(_ROUTER);
-        WETH = _WETH;
-        _safeApproveInf(WETH, address(ROUTER));
-    }
-
-    receive() external payable {}
-
-    /**
-     * @dev all the parameters for this function should be generated in the same way as they are
-     *  generated for the main Router, except that input.tokenIn & swapData should be generated
-     *  for tokenIn == WETH instead of ETH
-     */
-    function mintSyFromToken(
-        address receiver,
-        address SY,
-        uint256 minSyOut,
-        TokenInput calldata input
-    ) external payable returns (uint256 netSyOut) {
-        require(input.tokenIn == WETH);
-
-        _transferIn(NATIVE, msg.sender, input.netTokenIn);
-
-        _wrap_unwrap_ETH(NATIVE, WETH, input.netTokenIn);
-        netSyOut = ROUTER.mintSyFromToken(receiver, SY, minSyOut, input);
-    }
-}

package/contracts/router/base/ActionBaseCallback.sol

@@ -1,152 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../..//interfaces/IPMarketFactory.sol";
-import "../..//interfaces/IPMarket.sol";
-import "../..//interfaces/IPMarketSwapCallback.sol";
-import "../..//core/libraries/Errors.sol";
-
-import "./MarketApproxLib.sol";
-import "./ActionBaseMintRedeem.sol";
-import "./CallbackHelper.sol";
-
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-abstract contract ActionBaseCallback is IPMarketSwapCallback, CallbackHelper, TokenHelper {
-    using PMath for int256;
-    using PMath for uint256;
-    using PYIndexLib for PYIndex;
-    using PYIndexLib for IPYieldToken;
-
-    address internal immutable marketFactory;
-
-    modifier onlyPendleMarket(address caller) {
-        if (!IPMarketFactory(marketFactory).isValidMarket(caller)) revert Errors.RouterCallbackNotPendleMarket(caller);
-        _;
-    }
-
-    /// @dev since this contract will be proxied, it must not contains non-immutable variables
-    constructor(address _marketFactory) {
-        marketFactory = _marketFactory;
-    }
-
-    /**
-     * @dev The callback is only callable by a Pendle Market created by the factory
-     */
-    function swapCallback(int256 ptToAccount, int256 syToAccount, bytes calldata data) external override {
-        ActionType swapType = _getActionType(data);
-        if (swapType == ActionType.SwapExactSyForYt) {
-            _callbackSwapExactSyForYt(ptToAccount, syToAccount, data);
-        } else if (swapType == ActionType.SwapSyForExactYt) {
-            _callbackSwapSyForExactYt(ptToAccount, syToAccount, data);
-        } else if (swapType == ActionType.SwapYtForSy) {
-            _callbackSwapYtForSy(ptToAccount, syToAccount, data);
-        } else if (swapType == ActionType.SwapExactYtForPt) {
-            _callbackSwapExactYtForPt(ptToAccount, syToAccount, data);
-        } else if (swapType == ActionType.SwapExactPtForYt) {
-            _callbackSwapExactPtForYt(ptToAccount, syToAccount, data);
-        } else {
-            assert(false);
-        }
-    }
-
-    /// @dev refer to _swapExactSyForYt
-    function _callbackSwapExactSyForYt(int256 ptToAccount, int256 /*syToAccount*/, bytes calldata data) internal {
-        (address receiver, uint256 minYtOut, IPYieldToken YT) = _decodeSwapExactSyForYt(data);
-
-        uint256 ptOwed = ptToAccount.abs();
-        uint256 netPyOut = YT.mintPY(msg.sender, receiver);
-
-        if (netPyOut < ptOwed) revert Errors.RouterInsufficientPtRepay(netPyOut, ptOwed);
-        if (netPyOut < minYtOut) revert Errors.RouterInsufficientYtOut(netPyOut, minYtOut);
-    }
-
-    /// @dev refer to _swapSyForExactYt
-    /// @dev we require msg.sender to be market here to make sure payer is the original msg.sender
-    function _callbackSwapSyForExactYt(
-        int256 ptToAccount,
-        int256 syToAccount,
-        bytes calldata data
-    ) internal onlyPendleMarket(msg.sender) {
-        (
-            address payer,
-            address receiver,
-            uint256 maxSyToPull,
-            IStandardizedYield SY,
-            IPYieldToken YT
-        ) = _decodeSwapSyForExactYt(data);
-
-        /// ------------------------------------------------------------
-        /// calc totalSyNeed
-        /// ------------------------------------------------------------
-        PYIndex pyIndex = YT.newIndex();
-        uint256 ptOwed = ptToAccount.abs();
-        uint256 totalSyNeed = pyIndex.assetToSyUp(ptOwed);
-
-        /// ------------------------------------------------------------
-        /// calc netSyToPull
-        /// ------------------------------------------------------------
-        uint256 syReceived = syToAccount.Uint();
-        uint256 netSyToPull = totalSyNeed.subMax0(syReceived);
-
-        if (netSyToPull > maxSyToPull) revert Errors.RouterExceededLimitSyIn(netSyToPull, maxSyToPull);
-
-        /// ------------------------------------------------------------
-        /// mint & transfer
-        /// ------------------------------------------------------------
-        if (netSyToPull > 0) {
-            _transferFrom(IERC20(SY), payer, address(YT), netSyToPull);
-        }
-
-        uint256 netPyOut = YT.mintPY(msg.sender, receiver);
-        if (netPyOut < ptOwed) revert Errors.RouterInsufficientPtRepay(netPyOut, ptOwed);
-    }
-
-    /// @dev refer to _swapExactYtForSy or _swapYtForExactSy
-    function _callbackSwapYtForSy(int256 ptToAccount, int256 syToAccount, bytes calldata data) internal {
-        (address receiver, uint256 minSyOut, IPYieldToken YT) = _decodeSwapYtForSy(data);
-        PYIndex pyIndex = YT.newIndex();
-
-        uint256 syOwed = syToAccount.neg().Uint();
-
-        address[] memory receivers = new address[](2);
-        uint256[] memory amountPYToRedeems = new uint256[](2);
-
-        (receivers[0], amountPYToRedeems[0]) = (msg.sender, pyIndex.syToAssetUp(syOwed));
-        (receivers[1], amountPYToRedeems[1]) = (receiver, ptToAccount.Uint() - amountPYToRedeems[0]);
-
-        uint256[] memory amountSyOuts = YT.redeemPYMulti(receivers, amountPYToRedeems);
-        if (amountSyOuts[1] < minSyOut) revert Errors.RouterInsufficientSyOut(amountSyOuts[1], minSyOut);
-    }
-
-    function _callbackSwapExactPtForYt(int256 ptToAccount, int256 /*syToAccount*/, bytes calldata data) internal {
-        (address receiver, uint256 exactPtIn, uint256 minYtOut, IPYieldToken YT) = _decodeSwapExactPtForYt(data);
-        uint256 netPtOwed = ptToAccount.abs();
-
-        uint256 netPyOut = YT.mintPY(msg.sender, receiver);
-        if (netPyOut < minYtOut) revert Errors.RouterInsufficientYtOut(netPyOut, minYtOut);
-        if (exactPtIn + netPyOut < netPtOwed) revert Errors.RouterInsufficientPtRepay(exactPtIn + netPyOut, netPtOwed);
-    }
-
-    function _callbackSwapExactYtForPt(int256 ptToAccount, int256 syToAccount, bytes calldata data) internal {
-        (
-            address receiver,
-            uint256 exactYtIn,
-            uint256 minPtOut,
-            IPPrincipalToken PT,
-            IPYieldToken YT
-        ) = _decodeSwapExactYtForPt(data);
-
-        uint256 netSyOwed = syToAccount.abs();
-
-        _transferOut(address(PT), address(YT), exactYtIn);
-        uint256 netSyToMarket = YT.redeemPY(msg.sender);
-
-        if (netSyToMarket < netSyOwed) revert Errors.RouterInsufficientSyRepay(netSyToMarket, netSyOwed);
-
-        uint256 netPtOut = ptToAccount.Uint() - exactYtIn;
-        if (netPtOut < minPtOut) revert Errors.RouterInsufficientPtOut(netPtOut, minPtOut);
-
-        _transferOut(address(PT), receiver, netPtOut);
-    }
-}

package/contracts/router/base/ActionBaseMintRedeem.sol

@@ -1,182 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../../core/libraries/TokenHelper.sol";
-import "../../interfaces/IStandardizedYield.sol";
-import "../../interfaces/IPYieldToken.sol";
-import "../../interfaces/IPBulkSeller.sol";
-
-import "../../core/libraries/Errors.sol";
-import "../swap-aggregator/IPSwapAggregator.sol";
-
-struct TokenInput {
-    // Token/Sy data
-    address tokenIn;
-    uint256 netTokenIn;
-    address tokenMintSy;
-    address bulk;
-    // aggregator data
-    address pendleSwap;
-    SwapData swapData;
-}
-
-struct TokenOutput {
-    // Token/Sy data
-    address tokenOut;
-    uint256 minTokenOut;
-    address tokenRedeemSy;
-    address bulk;
-    // aggregator data
-    address pendleSwap;
-    SwapData swapData;
-}
-
-// solhint-disable no-empty-blocks
-abstract contract ActionBaseMintRedeem is TokenHelper {
-    bytes internal constant EMPTY_BYTES = abi.encode();
-
-    function _mintSyFromToken(
-        address receiver,
-        address SY,
-        uint256 minSyOut,
-        TokenInput calldata inp
-    ) internal returns (uint256 netSyOut) {
-        SwapType swapType = inp.swapData.swapType;
-
-        uint256 netTokenMintSy;
-
-        if (swapType == SwapType.NONE) {
-            _transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);
-            netTokenMintSy = inp.netTokenIn;
-        } else if (swapType == SwapType.ETH_WETH) {
-            _transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);
-            _wrap_unwrap_ETH(inp.tokenIn, inp.tokenMintSy, inp.netTokenIn);
-            netTokenMintSy = inp.netTokenIn;
-        } else {
-            if (inp.tokenIn == NATIVE) _transferIn(NATIVE, msg.sender, inp.netTokenIn);
-            else _transferFrom(IERC20(inp.tokenIn), msg.sender, inp.pendleSwap, inp.netTokenIn);
-
-            IPSwapAggregator(inp.pendleSwap).swap{value: inp.tokenIn == NATIVE ? inp.netTokenIn : 0}(
-                inp.tokenIn,
-                inp.netTokenIn,
-                inp.swapData
-            );
-            netTokenMintSy = _selfBalance(inp.tokenMintSy);
-        }
-
-        // outcome of all branches: satisfy pre-condition of __mintSy
-
-        netSyOut = __mintSy(receiver, SY, netTokenMintSy, minSyOut, inp);
-    }
-
-    /// @dev pre-condition: having netTokenMintSy of tokens in this contract
-    function __mintSy(
-        address receiver,
-        address SY,
-        uint256 netTokenMintSy,
-        uint256 minSyOut,
-        TokenInput calldata inp
-    ) private returns (uint256 netSyOut) {
-        uint256 netNative = inp.tokenMintSy == NATIVE ? netTokenMintSy : 0;
-
-        if (inp.bulk != address(0)) {
-            netSyOut = IPBulkSeller(inp.bulk).swapExactTokenForSy{value: netNative}(receiver, netTokenMintSy, minSyOut);
-        } else {
-            netSyOut = IStandardizedYield(SY).deposit{value: netNative}(
-                receiver,
-                inp.tokenMintSy,
-                netTokenMintSy,
-                minSyOut
-            );
-        }
-    }
-
-    function _redeemSyToToken(
-        address receiver,
-        address SY,
-        uint256 netSyIn,
-        TokenOutput calldata out,
-        bool doPull
-    ) internal returns (uint256 netTokenOut) {
-        SwapType swapType = out.swapData.swapType;
-
-        if (swapType == SwapType.NONE) {
-            netTokenOut = __redeemSy(receiver, SY, netSyIn, out, doPull);
-        } else if (swapType == SwapType.ETH_WETH) {
-            netTokenOut = __redeemSy(address(this), SY, netSyIn, out, doPull); // ETH:WETH is 1:1
-
-            _wrap_unwrap_ETH(out.tokenRedeemSy, out.tokenOut, netTokenOut);
-
-            _transferOut(out.tokenOut, receiver, netTokenOut);
-        } else {
-            uint256 netTokenRedeemed = __redeemSy(out.pendleSwap, SY, netSyIn, out, doPull);
-
-            IPSwapAggregator(out.pendleSwap).swap(out.tokenRedeemSy, netTokenRedeemed, out.swapData);
-
-            netTokenOut = _selfBalance(out.tokenOut);
-
-            _transferOut(out.tokenOut, receiver, netTokenOut);
-        }
-
-        // outcome of all branches: netTokenOut of tokens goes back to receiver
-
-        if (netTokenOut < out.minTokenOut) {
-            revert Errors.RouterInsufficientTokenOut(netTokenOut, out.minTokenOut);
-        }
-    }
-
-    function __redeemSy(
-        address receiver,
-        address SY,
-        uint256 netSyIn,
-        TokenOutput calldata out,
-        bool doPull
-    ) private returns (uint256 netTokenRedeemed) {
-        if (doPull) {
-            _transferFrom(IERC20(SY), msg.sender, _syOrBulk(SY, out), netSyIn);
-        }
-
-        if (out.bulk != address(0)) {
-            netTokenRedeemed = IPBulkSeller(out.bulk).swapExactSyForToken(receiver, netSyIn, 0, true);
-        } else {
-            netTokenRedeemed = IStandardizedYield(SY).redeem(receiver, netSyIn, out.tokenRedeemSy, 0, true);
-        }
-    }
-
-    function _mintPyFromSy(
-        address receiver,
-        address SY,
-        address YT,
-        uint256 netSyIn,
-        uint256 minPyOut,
-        bool doPull
-    ) internal returns (uint256 netPyOut) {
-        if (doPull) {
-            _transferFrom(IERC20(SY), msg.sender, YT, netSyIn);
-        }
-
-        netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
-        if (netPyOut < minPyOut) revert Errors.RouterInsufficientPYOut(netPyOut, minPyOut);
-    }
-
-    function _redeemPyToSy(
-        address receiver,
-        address YT,
-        uint256 netPyIn,
-        uint256 minSyOut
-    ) internal returns (uint256 netSyOut) {
-        address PT = IPYieldToken(YT).PT();
-
-        _transferFrom(IERC20(PT), msg.sender, YT, netPyIn);
-
-        bool needToBurnYt = (!IPYieldToken(YT).isExpired());
-        if (needToBurnYt) _transferFrom(IERC20(YT), msg.sender, YT, netPyIn);
-
-        netSyOut = IPYieldToken(YT).redeemPY(receiver);
-        if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
-    }
-
-    function _syOrBulk(address SY, TokenOutput calldata output) internal pure returns (address addr) {
-        return output.bulk != address(0) ? output.bulk : SY;
-    }
-}

package/deployments/5000-core.json

@@ -1,31 +0,0 @@
-{
-    "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
-    "network": {
-        "chainId": 5000,
-        "treasury": "0x5C30d3578A4D07a340650a76B9Ae5dF20D5bdF55",
-        "governance": "0x9F72a06084EdD040E973C32Bf026b1ACf65db9aB",
-        "pendle": "0xd27B18915e7acc8FD6Ac75DB6766a80f8D2f5729",
-        "lzEndpoint": "0xb6319cC6c8c27A8F5dAF0dD3DF91EA35C4720dd7",
-        "wrappedNative": "0x78c1b0c915c4faa5fffa6cabf0219da63d7f4cb8",
-        "initialRewardFee": "30000000000000000",
-        "initialInterestFee": "30000000000000000",
-        "initialFeeRateRoot": "999500333083533",
-        "initialReserveFeePercent": "80",
-        "safeWaitTime": 15000,
-        "sySwapper": ""
-    },
-    "baseCodeSplitter": "0x58732F1C1243A0D5876a601FB8D1Ee508B21580D",
-    "PENDLE": "0xd27B18915e7acc8FD6Ac75DB6766a80f8D2f5729",
-    "yieldContractFactory": "0x4A2B38b9cBd83c86F261a4d64c243795D4d44aBC",
-    "marketFactory": "0x523eCB8501C14507bCa56d4752dA1991c6176758",
-    "router": "0x0000000001E4ef00d069e71d6bA041b0A16F7eA0",
-    "routerStatic": "0xb4853cc09De22A70977a2B1569a6792B5ba7d1d5",
-    "pendleSwap": "0xcb645C93820B92E5F21781C5c3c18C29BCb6126B",
-    "routerHelper": "0x462206b11d185ef6F64B41D344325401C37EC335",
-    "ptOracle": "0x52420A287d9b29394f7dA44b1E4C0D4f7753a803",
-    "externalRewardDistributor": "0x8e21083cD387808BA8EE08e555622F997338eb1D",
-    "liquiditySeedingHelper": "0x8536b3519eaE59741B340bccE6c522c545606C59",
-    "receiverEndpoint": "0xA8CD765E7F6D164F873794C53021693B14925C91",
-    "vePendle": "0xf3038Be5aA8cB10fE3F3B42809283F05A9776598",
-    "gaugeController": "0x59f0C4a186744b573f15fbbC3737014F7F3Da835"
-}

package/deployments/5000-markets/WSTETH-MANTLE-MARCH2024.json

@@ -1,10 +0,0 @@
-{
-    "name": "SY wstETH",
-    "SY": "0xeC030Ca1A8bc0084271d5CC3E0bd3184B1DDFC27",
-    "YT": "0x170Ede592224b6Da02B0e85D4019416008596B96",
-    "PT": "0x7bA5Ee452EC9a9872B97E5ab978cd1358c752d12",
-    "market": "0x900A84AA9B31b9898533Df12cF5F8B2447118ba6",
-    "expiry": 1711584000,
-    "scalarRoot": "197935131557000000000",
-    "initAnchor": "1024944235000000000"
-}

package/deployments/5000-offchain-helper.json

@@ -1,4 +0,0 @@
-{
-    "multicall": "0xfd6Df9EFACfEfdF4E610d687A9c9b941D1b1Bf75",
-    "pendleMulticallV2": "0x539fd510fE352CC81822a222F821c340133Ed41C"
-}